Customizing-Beispiele

from ppms import ppms
from ppms.module_subclasses.base_class import Base
from ppms.constants import MENU_FILTER, MENU_RESET, MENU_SAVE

class ModuleThatOverwritesSave(Base):
    def menu_override(self, menu_id):
        if menu_id == MENU_SAVE:
            ppms.ui_message_box('No saving allowed!')
            return self.MENU_OVERRIDE_SUCCESS

        # Don't allow resetting as that brings up a save prompt
        elif menu_id == MENU_RESET:
            return self.MENU_OVERRIDE_SUCCESS
            
        return super(ModuleThatOverwritesSave, self).menu_override(menu_id)

Erweiterung der Listbox für dynamische Gruppierung

Vorgenhesweise

• Im Modul Textkonstanten eine Textkonstante für das neue Kriterium anlegen, z. B. für DI005352 Produkt.
• Im Wertebereich des DI029130 die neue Textkonstante an Stelle 12 eintragen.
• DI005352 Produkt in die Listbox-Kategorie 00000333 analog den anderen eintragen.
• In der ppms_cu.py unter groupings 12:‘product‘ ergänzen (…./py/api/ppms/customizing/venus/ppms):

GROUPINGS = {1:'customer', 2:'pr_manager_name', 3:'ht_pr_code_name', 4:'pr_group_1',
             5:'pr_group_2', 6:'pr_group_3', 7:'ou_cctr_name', 8:'calculated_end_date',
             9:'phase_name', 10:'ht_pr_plan_idea', 12:'product'}

• In DI029160 im Wertebereich das DI005352 analog den anderen eintragen.
• Server neustarten.
• DI005352 im Datenbereich 041023 in F9 eintragen.
• Client neustarten.

Hinweis

• Die Vorgehensweise gilt für alphanummerische Datenfelder. Für Aufnahme der Termin-Datenfelder in die Listbox, kontaktieren Sie bitte Ihren PLANTA-Consulatant, da hierfür Anlage von neuen DIs und Wertebereichen erforderlich ist.

Angemeldete Benutzer anzeigen

Ziel

• Customizen eines Moduls, das die angemeldeten Benutzer anzeigt.

• Anlegen eines Moduls mit drei Datenbereichen
  • Datenbereich 1:
    • Gruppiert nach DI001603 Startdatum
    • Angezeigt in Fenster 1: DI001603 Startdatum
  • Datenbereich 2:
    • Gruppiert nach DI001606 Benutzer
    • Angezeigt in Fenster 1: DI001606 Benutzer, DI010670 Benutzername
  • Datenbereich 3:
    • Angezeigt in Fenster 1: DI001603 Startdatum (Filtern von @15), DI = 004353 Startzeit, DI004376 Endzeit (Filtern von= 00:00, Fenster = 9)

Schritt 1: Neues Modul anlegen

• Im Modul Module ein neues Modul mit dem gewünschten Namen anlegen und ein Makro einfügen, das bei Modulaufruf filtert.

Schritt 2: Datenbereich Datum anlegen

• Neue Datenbereichszuordnung einfügen:
• Einen neuen Datenbereich mit den folgenden Parametern anlegen:
  • DDI = 001603 Startdatum
  • Gruppierung =
• Das folgende Datenfeld einfügen:
  • DI = 001603 Startdatum
• Speichern
• Datenbereich dem Modul zuordnen und folgende Parameter anpassen:
  • Pos. = 1
• Modul speichern

Schritt 3: Datenbereich Benutzer anlegen

• Neue Datenbereichszuordnung einfügen
• Einen neuen Datenbereich mit den folgenden Parametern anlegen:
  • DDI = 001606 Benutzer
  • Gruppierung =
• Zwei neue Datenfelder im Modul Datenbereiche einfügen:
  • DI = 001606 Benutzer
  • DI = 010670 Benutzername
• Speichern
• Datenbereich dem Modul zuordnen und folgende Parameter anpassen:
  • Pos. = 2
  • Oberbereich = 1
  • Ausgabe =
• Modul speichern

Schritt 4: Datenbereich Anmeldezeiten anlegen

• Neue Datenbereichszuordnung einfügen
• Einen neuen Datenbereich mit den folgenden Parametern anlegen:
  • DDI = 001595 Session
• Die folgenden Datenfelder im Modul Datenbereiche einfügen:
  • DI = 001603 Startdatum
  • DI = 004353 Startzeit
  • DI = 004376 Endzeit
• Für das Datenfeld Startdatum in den Parameter Filtern von @15 eintragen
• Für das Datenfeld Endzeit die folgenden Parameter anpassen
  • Filtern von = 00:00
  • Fenster = 9
• Speichern
• Datenbereich dem Modul zuordnen und folgende Parameter anpassen:
  • Pos. = 3
  • Oberbereich = 2
  • Ausgabe =
• Modul speichern

Schritt 5: Modul testen

• Im Modul Module die Schaltfläche Aktuelles Modul starten betätigen, um das neu erstellte Modul zu testen.

• Mit aktivierter Baumdarstellung sowie mit Symbolen sieht das Ergebnis z.B. folgendermaßen aus:

Beispiel:

mod_obj = ppms.get_target_module()
uid = mod_obj.get_uid()

ppms.client_exec("""
env = get_Env()
mod = env.ActivePanel.ModuleManager.__getitem__('%s')
doc = mod.CreateExcelExportDocument()
env.GenerateExcelFile(doc)
""" % uid)

Beispiel für ein individuelles Customizing von Listboxen

• Es soll eine Listbox gebaut werden, die einen kombinierten Schlüssel direkt auswählt.

Hinweis

• get_listboxvalue() aus dem Customizing Helper Modul implementiert lediglich ein Mapping zwischen tatsächlichen Werten in Datentabellen und den IDs festgelegter Listboxwerte in der entsprechenden Tabelle, kann aber kein X-beliebigen Werte aus einem Listbox-Datensatz auslesen.
  • Lösungsvorschlag: Zusammensetzen und Auseinanderschneiden der Schlüsselwerte über einen Python-Wertebereich

Vorgehensweise

• Ein neues DI vom Typ X / ALG wird als Python-Wertebereich angelegt.
• Dieses DI wird in der Inkarnation als ID-Feld und im Datenbereich der Listbox für LB-Auswahl benutzt.
• Die Methode computeOutput liest die entsprechenden Schlüssel-DIs aus und konkateniert sie mit einer Pipe "|" als Trennzeichen, was mit der Methode format der String-Klasse in Python erreicht werden kann.
• Die processInput-Methode trennt die Werte analog wieder auf und schreibt sie in die einzelnen Schlüssel-DIs.
• Als Voraussetzung für das korrekte Funktionieren dieses Verfahrens ist die Verwendung des Pipe-Zeichens in Schlüsselwerten verboten.
• Die Beispielimplementierung prüft nicht auf das Vorhandensein von Pipes in Schlüsselwerten beim Zusammensetzen und auch nicht auf überschüssige Trenner bzw. Werte beim Zerschneiden

def computeOutput(di):
    record = di.get_dtp_record()
     
    key0 = record.get_di_by_id(<key0_numeric_di_no>).get_value()
    # etc. für weitere DIs

    multicol_key_template = '{0}|{1}|{2}'
    multicol_key_value = multicol_key_template.format(key0, key1, key2)

    return multicol_key_value 

computeOutput.deps = ('DI<key0_textual_di_no>', 'DI<key1_textual_di_no>', ) # etc. für weitere DIs

def processInput(di, oldvalue):
    record = di.get_dtp_record()

    key0_di = record.get_di_by_id(<key0_numeric_di_no>)
    # etc. für weitere DIs

    new_value = di.get_value()
    key_values = new_value.split('|', 3)

    key0_di.set_value(key_values[0])

    return new_value

processInput.deps = ('DI<key0_textual_di_no>', 'DI<key1_textual_di_no>', ) # etc. für weitere DIs

Hinweise

• Eine textual_di_no ist z.B. der String 000123, numeric_di_no dagegen die Zahl 123
• Weiterführende Dokumentation ist zu finden unter PythonValueRange sowie in der Python-Referenz: http://docs.python.org/py3k/ bzw. http://docs.python.org/py3k/library/stdtypes.html#str.split

E-Mail-Client aufrufen

Ziel

• Customizing von Hyperlink-Datenfeldern zum Aufrufen eines E-Mail-Clients mit Python
  • Für Datenfelder mit Dataitems, die den DF-Typ AM besitzen

Vorgehensweise

• Modul Datenbereich aufrufen
• Neuen Datenbereich anlegen
• Datenfeld mit folgenden Eigenschaften einfügen:
  • DB-Typ = X
  • DF-Typ = AM
  • PPMS-Typ = AM
• Für dieses Datenfeld folgende Parameter setzen:
  • DF-Verhalten = e4
  • Aktions-ID = 009AAK
  • Symbol-ID = 001807
  • DF-Python-ID= email_id
• Die Baumdarstellung des Datenfelds öffnen und in Datenfeld-Konfiguration Folgendes eintragen:

subject_text = "" body_text = ""

• subject_text = Betreff der E-Mail
• body_text = Inhalt der E-Mail

• Mit dem obigen Customizing werden Betreff und Inhalt nicht befüllt. Es ist eine manuelle Eingabe in der E-Mail nötig.
• Um den Betreff oder Inhalt zu befüllen kann die PythonAPIReference benutzt werden.
  • Hierzu im Datenfeld Datenfeld-Konfiguration die Variablen subject_text und body_text über Python setzen.
  • Um auf die Werte der Datensätze zuzugreifen kann man sich des Objekts record bedienen, das eine Instanz der MTSRecord Klasse darstellt.

subject_text = record.name.get_raw_value()

Beispiel für einen Python-Wertebereich

Ziel

• DI041088 DF-Python-ID im Modul Datenbereiche

Beispiel

DI_PREFIX = 'DI: '


def di041088_df_python_id_checkInput(di, old_value):
    if not python_id.is_valid_python_id(di.get_value()):
        return False

    dtp_record = di.get_dtp_record()
    own_lic = python_id.get_owner_license_of_record(dtp_record)
    da = dtp_record.da.get_value()

    da_record = ppms.search_record(410, [da], ['own_lic'])
    parent_own_lic = python_id.get_owner_license_of_record(da_record)

    return python_id.is_allowed_to_change_python_id(current_python_id=old_value,
                                                    owner_license=own_lic,
                                                    user_license=ppms.uvar_get(SYS_VAR_LICENSE),
                                                    parent_license=parent_own_lic)


def di041088_df_python_id_processInput(di, oldvalue):
    dtp_record = di.get_dtp_record()
    own_lic = python_id.get_owner_license_of_record(dtp_record)
    da = dtp_record.da.get_value()

    da_record = ppms.search_record(410, [da], ['own_lic'])
    parent_own_lic = python_id.get_owner_license_of_record(da_record)

    py_id = di.get_value()

    py_id = python_id.modify_python_id_for_parent_license(python_id=py_id,
                                                          owner_license=own_lic,
                                                          user_license=ppms.uvar_get(SYS_VAR_LICENSE),
                                                          parent_license=parent_own_lic)

    di.get_dtp_record().df_customizing_name.set_value(py_id)
    return py_id


def get_df_cust_name(di):
    df_name = di.get_dtp_record().df_customizing_name.get_value()
    if df_name:
        return df_name

    return None


def get_di_cust_name(di):
    di_nr = di.get_dtp_record().di.get_value()

    if not di_nr:
        return None

    di_record = ppms.search_record(412, [di_nr], ['di_customizing_name'])

    if di_record:
        return di_record.di_customizing_name.get_value()

    return None


def di041088_df_python_id_computeOutput(di):
    name = get_df_cust_name(di)
    if name is None:
        di_name = get_di_cust_name(di)
        if di_name is None:
            return ''

        name = DI_PREFIX + di_name

    return name


di041088_df_python_id_checkInput.deps = ('DI000306', 'DI001862')
di041088_df_python_id_processInput.deps = ('DI001869', 'DI000239')
di041088_df_python_id_computeOutput.deps = ('DI041036', 'DI000213', 'DI000984')

Abbilden der Menüpunkte 154/151 (Alles markieren/Alles demarkieren) mit Python

Ziel

• Die Menüpunkte 154 (Alles markieren) und 151 (Alles demarkieren) mit Python abbilden

# get module object
mod_obj=ppms.get_target_module() 

#mark all records of all datareas in the module
with ppms.echo_disabled():
    [[mts_rec.mark() for mts_rec in mts_rec_list]for mts_rec_list in [da_obj.get_records() for da_obj in mod_obj.get_das()]]

# get module object
mod_obj=ppms.get_target_module() 

#unmark all marked records of all dataareas in the module
with ppms.echo_disabled():
    [[mts_rec.unmark() for mts_rec in mts_rec_list]for mts_rec_list in [da_obj.get_marked_records() for da_obj in mod_obj.get_das()]]

# get module object
mod_obj=ppms.get_target_module() 

#mark all records of all datareas in the module
ppms.echo_off()
[[mts_rec.mark() for mts_rec in mts_rec_list]for mts_rec_list in [da_obj.get_records() for da_obj in mod_obj.get_das()]]
ppms.echo_on() 

# get module object
mod_obj=ppms.get_target_module() 

#unmark all marked records of all dataareas in the module
ppms.echo_off()
[[mts_rec.unmark() for mts_rec in mts_rec_list]for mts_rec_list in [da_obj.get_marked_records() for da_obj in mod_obj.get_das()]]
ppms.echo_on() 

Kundenlogo einbinden

Ziel

• Das Kundenlogo soll in Modulen (als Produktlogo), im Druckkopf und als Splash Screen ausgegeben werden.

Schritt 1: Kundenlogos als Grafikdateien bereitstellen

• PLANTA unterstützt die Formate .png und .jpg.
• Die maximale Bildgröße kann, z.B. je nach Windows-Einstellung, variieren.
  • Unter Verwendung der Standard-Windows-Einstellungen können Sie sich an den Bildgrößen der default-mäßig hinterlegten PLANTA-Logos orientieren (Höhe * Breite).
    • Produktlogo: 49 px * 458 px
    • Druckkopf: 32 px * 32 px
    • Splash Screen: 478 px * 475 px

Schritt 2: Das Logo in Modulen verwenden (als Produktlogo)

• Customizer Darstellungsobjekte OLEs Modulvariante: Produktlogos aufrufen.
• Einen neuen Datensatz einfügen.
• Im Feld Bezeichnung einen Namen vergeben.
  • Die OLE-Identnummer wird automatisch generiert.
• Im Feld Kategorie den Wert Produktlogos aus der Listbox auswählen.
• Im Feld Standard-OLE die bereit gestellte Datei für die Module einfügen.
• Speichern.
• Bei dem gewünschten OLE die Schaltfläche Systemweit als Logo verwenden betätigen.
  • Die Dialogmeldung Soll die gewünschte Grafik systemweit als Produktlogo eingebunden werden? Das Produktlogo aller Module wird durch dieses Logo ersetzt. erscheint.
• Die Meldung mit Ja bestätigen.
• Das Programm neu starten.
• Alle bestehenden Module des Systems haben nun das neue Logo als Produktlogo.
• Neue Module werden automatisch mit dem neuen Produktlogo als Default-Produktlogo belegt.

Schritt 3: Das Logo im Druckkopf verwenden

• Customizer Darstellungsobjekte OLEs aufrufen.
• Im Feld Bezeichnung einen Namen vergeben.
  • Die OLE-Identnummer wird automatisch generiert.
• Im Feld Standard-OLE die bereit gestellte Datei für den Druckkopf einfügen.
• Speichern.
• Customizer Darstellungsobjekte Skins aufrufen.
• Die ID-Nummer des Moduls für Druckbereiche im Feld Modul für Druckber. merken bzw. mit STRG + C kopieren.
• Customizer Modul-Customizer Module aufrufen.
• Das individuelle Druckmodul durch Kopieren des Moduls für Druckbereiche erstellen.
  • Identnummer des zu kopierenden Moduls in das Datenfeld Kopieren von eingeben.
  • Nach Betätigen der ENTER-Taste wird im Datenfeld MOD eine neue Modulidentnummer vergeben.
  • Im Datenfeld Modul den neuen Modultitel eingeben.
  • Speichern. Beim Speichern werden alle Parameter des Quellmoduls sowie seine Unterobjekte (Untermodule, Datenbereiche, Modulvarianten) in das neue Modul kopiert.
• Im individuellen Druckmodul den Datenbereich Druckkopf aufrufen.
• Im Feld Standardwert die OLE-Identnummer (DBOLE (Identnummer)) eintragen.
• Die Positionsfelder ggf. anpassen.
• Speichern.
• Customizer Darstellungsobjekte Skins aufrufen.
• Den verwendeten Skin aus der Listbox auswählen.
  • Skins werden im Modul Benutzer pro Benutzer im Feld Skin-Bezeichnung hinterlegt.
• Im Feld Modul für Druckber. die ID-Nummer des individuellen Moduls eintragen.
• Speichern.

Schritt 4: Das Logo als Splash Screen verwenden

• Die Datei splash.png unter %client_folder%/Resources/ mit der bereitgestellten Datei ersetzen.

Siehe auch: Splash Screen, Produkt- bzw. Firmenlogos verwenden

Erfassung fremder Stunden erleichtern

Ziele

• Aus einem neu erstellten Modul für die Ressourcenübersicht soll in ein verkürztes Panel Mitarbeiterboard gesprungen werden.
  • Das verkürzte Panel Mitarbeiterboard soll mit dem Modul Zeiterfassung geöffnet werden.

Vorgehensweise

• Eine Kopie vom Modul Mitarbeiterboard (MOD0099GU) erstellen. (Hier: MOD100003)
• Im neu erstellten Modul nicht gewünschte Untermodule löschen (hier: Meine Tätigkeiten, Wochenkalender, Infos, Meine Planungsobjekte) oder bei diesen Untermodulen im Feld Anzeigen die gleichnamige Checkbox deaktivieren.
• Die Reihenfolge der restlichen Untermodule so anpassen, dass das Untermodul Zeiterfassung als erstes geöffnet wird:
  • Beim Untermodul Rückmeldung folgende Parametern bearbeiten:
    • Im Feld Positionierung eine 3 eintragen.
    • Im Feld Modulgröße 0,869 eintragen.
    • Die Checkbox Vordergrund aktivieren.
  • Für die Rückmeldung auf ungeplante Vorgänge müssen ggf. noch die Listboxen individualisiert werden
• Im Makro des kopierten Mitarbeiterboards die Funktion call_resource() wie folgt anpassen:

from ppms.text_constant import get_text_constant

def call_resource(resource_id=ppms.get_target_module().get_current_L_var()[5]):
    resource_record = ppms.search_record(467, [resource_id[0]], ['resource_type'], True)
    if not resource_record :
        message = get_text_constant("001247")
        ppms.ui_message_box(message.replace("@user_id", resource_id[0]), blocking=1)
        mod_obj.menu(49)
    elif resource_record.resource_type.get_value() == "2":
        ppms.ui_message_id("0860")
        mod_obj.menu(49)
    else:
        mod_obj.set_current_L_var(5, [resource_id[0]])

• Im Modul Globale Einstellungen im Feld Python-ID die Python-ID für das neue Modul (MOD100003) erstellen, hier: L100_employee_board_for_reporting
• Ein neues Makro (hier: 100004) erstellen, welches das verkürzte Mitarbeiterboard mit der gewählten Ressource (@L5) aufruft.

from ppms.global_setting import get_global_setting_value

mod_obj = ppms.get_target_module()

rm_modul = get_global_setting_value("L100_employee_board_for_reporting", 'alpha120')

inv_rec = ppms.get_context_df().get_record()
res_id = inv_rec.res_id.get_raw_value()
mod_obj.set_new_L_var(5, [res_id])

mod_obj.open_module(rm_modul)

• Ein Modul mit Ressourcenübersicht erstellen.
• Soll das Modul über einen Link auf der Ressourcen-ID aufgerufen werden,
  • bei dem gewünschten Ressourcen-DI im Feld Aktions-ID die Nummer des neuen Makros (hier: 100004) und im Feld DF-Verhalten e4 eintragen.
• Soll das Modul über ein Kontextmenü aufgerufen werden,
  • das DI004336 Button/IronPython hinzufügen und bei diesem im Feld Aktions-ID die Nummer des neuen Makros (hier: 100004) und im Feld DF-Verhalten m4 eintragen.

Aktualisierung von Feldern beim Speichern, wenn ein Wert geändert wurde

Ziel

• Die individuellen Felder Prognose vom und Prognose von sollen aktualisiert werden, wenn der Prognosewert geändert wurde.

Vorgehensweise

• Customizer System-Customizer Data Dictionary aufrufen.
• Individuelle Dataitems anlegen (hier: DI100102 und DI100103).
• Customizer System-Customizer Dataitems aufrufen.
• Den Wertebereich vom Dataitem Prognose (DI006530) wie folgt anpassen:

def processInput(di, oldvalue):
    rec = di.get_dtp_record()
    rec.L100_prognose_vom.set_value(ppms.uvar_get("@15"))
    rec.L100_prognose_von.set_value(ppms.uvar_get("@1"))
    return di.get_value()
processInput.deps = ("L100_prognose_vom", "L100_prognose_von")

Beispiel für Drag & Drop-Kopieren via Python

Ziel

• Der Wert aus dem Feld Aufwand-Soll soll in das Feld Aufwand-Soll fix übertragen werden.

Beispiel

mod_obj = ppms.get_target_module()
mod_obj.menu(12)

for rec in mod_obj.get_da("Python_ID_DA_name").get_records():
    rec.DF_Python_ID_planned_load_fixed.set_raw_value(rec.DF_Python_ID_planned_load.get_raw_value())

mod_obj.menu(34)
mod_obj.menu(49)

Beispiel für Aufruf einer externen Applikation mit Python

Ziel

• Eine Anwendung soll aus PLANTA heraus aufgerufen werden und dabei einen bestimmten Parameter mitgeschickt bekommen

Beispiel

PATH = r'C:\Program Files (x86)\Applikation\anwendung.exe'
# Der String, der den Pfad zur Applikation darstellt, wird mit "r" vorangestellt,
# weil sonst der Backslash \ als Escape-Zeichen interpretiert werden würde.
# Siehe http://docs.python.org/reference/lexical_analysis.html#string-literals
ARGS = 'argument1=PLANTA argument2=Nocheins'
# Die Argumente, die an die Applikation übertragen werden sollen, einfach als
# einen fortlaufenden String deklarieren.

def execute_client_script(path, args):
    ppms.client_exec("""import clr
clr.AddReference('System')
from System.Diagnostics import Process

Process.Start(r'{path}', r'{args}')""".format(path=path, args=args))

execute_client_script(PATH, ARGS)

Beispiel für das Customizen eines PDF-Exports

• Customizen eines PDF-Exports für ausgewählte Statusberichte

Hinweis

• Hier ist nur die generelle Funktionalität eingerichtet. Optimierungen sind bei Bedarf durchzuführen, zum Beispiel:
  • Bearbeitungsmeldungen
  • Variable Eingabe des Exportpfads, des Dateinamens, der Modulvariante usw., z.B. im Modul Globale Einstellungen
  • Handling der PDF-Datei (z.B. das Verhalten, wenn die Datei bereits geöffnet ist oder die Möglichkeit einen anderen Namen anzugeben)

Vorgehensweise

• Ein neues Modul anlegen, das die zu druckenden Statusberichte anzeigt mit einer Schaltfläche PDF erzeugen (=Auswahlmodul)
  • Die Auswahl dieser Statusberichte kann beispielsweise über ein weiteres Modul erfolgen, in dem Statusberichte durch Aktivieren einer Checkbox ausgewählt werden.
• Für diese Schaltfläche ein Makro-Modul erzeugen.
• In diesem Makro die folgenden Parameter anpassen:
  • exp_path = Speicherpfad der erzeugten PDF-Datei
  • file_name = Name der erzeugten PDF-Datei
  • REPORT_MOD_ID = Modul, das für die Ausgabe verwendet wird (=Reportmodul), für die Statusberichte z.B. das Standardmodul MOD009A52 Statusbericht
  • REPORT_VARIANT_ID = gewünschte Variante des Reportmoduls
  • DA_PYTHON_ID = Name des Quell-Datenbereiches im Auswahlmodul

# Moduleinstellungen: Exportpfad. Exportdateiname, Ausgabemodul und zu verwendende Variante, Python-ID des Quell-Datenbereichs
exp_path = 'Exportpfad'.replace(chr(92),chr(92)+chr(92))
file_name = "Name der erzeugten PDF Datei"
REPORT_MOD_ID = "Modul-ID" 
REPORT_VARIANT_ID = "Varianten-ID"  
DA_PYTHON_ID = 'Python-ID' 
                
#Auslesen der Druckeinstellungen aus dem Reportmodul
module_customizing_record = ppms.search_record(405, [REPORT_MOD_ID], [25609,25610,1789,2947], True)
page_size = module_customizing_record.paper_format.get_value()
landscape = not bool(module_customizing_record.portrait_format.get_value())
zoom = float(module_customizing_record.zoom_print_preview.get_value())
fit_to_page = bool(module_customizing_record.default_zoom_col.get_value())

#Modulobjekte 
macro_module = ppms.get_macro_module()
select_module = macro_module.get_invoker_module()

#Zusammensetzung des Befehls fuer den Client
CLIENT_CODE = """
e = get_Env()
pdf_list = e.PdfExportDocumentsList
list = e.PdfExportDocumentsList
page_size = '{page_size}'
landscape = {landscape}
zoom = {zoom}
fit_to_page = {fit_to_page}

for uid in {export_list}:
    module = e.ActivePanel.ModuleManager[uid]
    doc = module.CreatePdfExportDocument(pageSize=page_size, landscape=landscape, zoom=zoom, fitToPage=fit_to_page)
    pdf_list.Add(doc)
    e.ActivePanel.ModuleManager

e.GeneratePdfFile(pdf_list, '{exp_path}', '{file_name}')    
"""
    

def get_selected_reports():
    export_list =[]
    modules_to_close = []
      
    for pr_rec in select_module.get_da(DA_PYTHON_ID).get_records():         
        pr_id = pr_rec.pr_id.get_raw_value()
        main_pr_id = pr_rec.main_pr_id.get_raw_value()
        report_id = pr_rec.report_id.get_raw_value()
        
        #Alle im Reportmodul verwendete Filterkriterien setzen
        select_module.set_new_L_var(30, [pr_id])
        select_module.set_new_L_var(78, [report_id])
        select_module.set_new_L_var(74, [main_pr_id])
        #select_module.set_new_L_var(26, [report_id]) - wird im Makro des Statusberichts gesetzt
        #select_module.set_new_L_var(25, [report_id]) - ist im Standard leer

        #Aufruf der Modul-Variante (angedockt ausserhalb der Bildschirmanzeige)
        reporting_module=select_module.open_module(REPORT_MOD_ID,
                                                                  dock_to_module=select_module.get_uid(),
                                                                  forced_status=2,
                                                                  dock_style=3,
                                                                  dock_proportion=0.001,
                                                                  foreground=0,
                                                                  focus=0)
        reporting_module.apply_mv_by_id(REPORT_VARIANT_ID)
        reporting_module.menu(12)
        modules_to_close.append(reporting_module)
        #Interne Nummer des geoeffneten Moduls 
        uid = str(reporting_module.get_uid())
        
        #Offene Module zur Liste fuer PDF-Schnittstelle anfuegen
        export_list.append((uid))
		
    client_call = CLIENT_CODE.format(export_list=export_list, exp_path=exp_path, file_name=file_name,
                                     page_size=page_size, landscape=landscape,
                                     zoom=zoom, fit_to_page=fit_to_page)

    ppms.client_exec(client_call)
        
    for module in modules_to_close:
        module.menu(49)

    select_module.menu(49)

#Schleife fuer Anzeige Modulvariante 
get_selected_reports() 

Hinweise

• Für die Übergabe der Daten an den Client soll ein rpc service genutzt werden.
• Bei Verwenden der IronPython-Methode CreatePdfExportDocument() müssen die Parameternamen mit angegeben werden.
  • doc = module.CreatePdfExportDocument(pageSize='A4',landscape=TRUE, zoom=100.0, fitToPage=TRUE) statt doc = module.CreatePdfExportDocument('A4', TRUE, 100.0,TRUE)

Customizen eines Formats zur Umrechnung von Kommazahlen in Prozentwerte

• Customizen eines Formats zur Umrechnung von Kommazahlen in Prozentwerte (z.B. Anzeige von 10 % statt 0,1)

Vorgehensweise

• Anlegen eines neuen Zahlenformats im Modul Formate mit Einstellungen wie im folgenden Screenshot

Customizen eines Farbvorschaufelds

• Customizen eines Farbvorschaufelds, hier am Beispiel von DI028197 Hervorhebungsfarbe in der DT030 Skin

Details

• Im Modul Skins fehlt bei DI028197 Hervorhebungsfarbe eine Vorschau für die ausgewählte Farbe:

Unter-Dataitem zuordnen

• Rechtsklick auf das gerade angelegte DI und den Kontextmenü-Befehl Dataitem bearbeiten auswählen.
• Rechtsklick auf das DI Einfügen Unter-DataItem.
  • In das Feld SUBDI die ID des Quell-DIs eintragen ( 028197).
  • Aus der Listbox Funktion den Wert F (Farbe) auswählen.

• Speichern.

• Das angelegte DI nun dem Datenbereich zuordnen, in dem das Quell-DI enthalten ist.
• Das DF-Verhalten auf o (output) setzen.

• Speichern.
• Damit das Datenfeld angezeigt werden kann, müssen folgende Felder angepasst werden:
  • DF-Höhe
  • DF-Breite
  • Y-Pos. Ü
  • X-Pos. Ü
  • Y-Pos. F
  • X-Pos. F

Customizing von Budget/Kosten-Modulen mit n-Kostenartengruppen

Customizen eines individuellen Moduls zum Bearbeiten von Ressourcen

• Sollen in einem individuellen Modul die übergeordnete Ressource oder die Start- und Endperiode angepasst werden, müssen in diesem Modul folgende Anpassungen durchgeführt werden:
  • Im Parameter Python-Modulunterklasse im Modul Module die Python-Modulunterklasse ppms.module_subclasses.resource.ResourceDatasheet hinterlegen.
  • Den Menüpunkt Speichern mit einem Makro mit dem folgenden Code überschreiben:

ppms.get_target_module().on_save_check_person_resource()