Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 8 Current »

Diese Seite führt in die Dokumentfunktion Felder (Fields) ein.

Fields bieten die Möglichkeit, abhängig vom gewählten Profil, dessen Organisationsdaten, von Forms-Feldern und mehr, eine Vorlage dynamisch zu machen.

Der Einfachheit halber und um Missverständnisse vorzubeugen, wird immer von Fields gesprochen.

HINWEIS
Diese Seite gilt als Ergänzung der technischen Dokumentation. Sie erklärt, wie man etwas macht und bietet detailliertere und erklärte Beispiele als die technische Dokumentation.
Im Gegenteil dazu erklärt die technische Dokumentation, wie etwas ist.

Zum besseren Verständnis empfehlen wir daher, weiterführenden Links zu folgen und die entsprechenden Abschnitte zu lesen.

Fields-Dokumentfunktion in Vorlageneditor anhängen

Die Fields bzw. Felder-Dokumentfunktion wird im Vorlageneditor hinzugefügt mittels Klick auf Dokumentfunktionen → Verwalten → + Hinzufügen beim Eintrag Felder.

Die Standardkonfiguration zeigt ein paar Beispiel-Fields:

<FieldsConfiguration>
  <Fields>
    <Text Name="Field01" Value="Content of Field01" />
    <Text Name="Field02" Value="Content of Field02" />
    <Text Name="Field03">
      <Code>
        "[" + $("Field01") + "] [" + $("Field02") + "]"
      </Code>
    </Text>
  </Fields>
</FieldsConfiguration>

Diese Text-Fields sollten zum Anfangen gelöscht werden:

Einfaches Field konfigurieren und in Vorlage einfügen

Wir möchten ein Field Greeting, das den Text “Lorem Ipsum” ausgibt, in der Word-Vorlage einfügen:

<FieldsConfiguration>
  <Fields>
    <!-- ein Text Field -->
    <Text Name="Greeting" Value="Lorem Ipsum" />
  </Fields>
</FieldsConfiguration>

Klicke in der Menüleiste auf den Button Editor oder verwende die Tastenkombination Ctrl+E, um die Vorlage im Word zu öffnen.

In der geöffneten Word-Vorlage, öffne den primedocs Ribbon und klicke anschliessend auf den Button Feld binden.

Dabei öffnet sich das Dialogfenster “Feld auswählen”.

Wähle Greeting aus dem Dropdown aus (in diesem Fall ist Greeting schon vorausgewählt, da es das einzige verfügbare Feld ist).

Klicke auf Einfügen.

Das Feld ist nun eingefügt.

Die Inhaltssteuerelemente von Fields sind blau.

Speichere die Word-Vorlage.

Seit Version 4.0.20093 muss man den Editor nicht mehr schliessen und wieder öffnen, damit man ein neu erstelltes Field binden kann!🥳 Das neu erstellte Field muss lediglich im Editor gespeichert werden, damit es im “Feld auswählen”-Dialog erscheint.

Kehren Sie zum Vorlageneditor zurück und klicken Sie auf “Dokument testen“ oder nutzen Sie Ctrl+T. Füllen Sie nun alle Parameter aus, als ob Sie ein Benutzer wären. Das Dokument wird anschliessend im Test-Modus generiert.

(https://primesoft-group.atlassian.net/wiki/spaces/PD/pages/36929537/Word+Vorlagenbearbeitung+-+Grundlagen#Dokument-testen)

Angezeigt wird nun, was wir im Field als Wert hinterlegt haben, der Text “Lorem Ipsum”:

Informationen zu allen Field-Typen

Bevor wir weiter auf die verschiedenen Field-Typen eingehen, empfehlen wir, folgende Seiten der Technischen Dokumentation aufmerksam durchzulesen. Sie bilden die Basis für die Anwendungsbeispiele, die in diesem Kapitel pro Field-Typ folgen:

Besonders hervorheben möchten wir die Wichtigkeit der folgenden Kapitel:

Die folgenden Informationen sind zur Ergänzung:

Typ Text

In Anwendung

JS-Code

<Text Name="Footer">
  <Code>
    function main() {
      // Felder 
      let profileData = $('Profile.User.FirstName'); // Hole Profildaten (implizit, wie getText())
      let field = $.getText('Forms.TextField'); // Hole Forms-Feld (ein Text-Field, explizit mit getText())
      let formsField = $.getDateAsString('Forms.Date'); // Hole Forms-Feld (ein Date-Feld)
      let otherField = $.getText('Page'); // Hole ein anderes Feld (muss in der gleichen Konfig vorhanden sein!)
      
      // Translations
      let translation = $.translations.getText('Texts.Enclosures'); // hole unformatierter Text
      
      return $.joinNonEmpty("\n", profileData, field, formsField, otherField, " ", translation);
    }
  </Code>
</Text>

<Text Name="Page" translate-Value="Texts.Page" />

Ergebnis in Word

image-20240116-091531.png

Typ FormattedText

TIPP
Lese zuerst die technische Dokumentation: https://primesoft-group.atlassian.net/wiki/x/FAC_Fw.

FormattedTexts als Globale Übersetzung

Der Vorteil von FormattedTexts in den Globalen Übersetzungen ist, dass man keinen Textbaustein erstellen muss sondern den Text mit HTML programmatisch erstellen kann (siehe Beispiele unten).

Beispiel “Footer“

Der FormattedText ist als globale Übersetzung vom Typ “FormattedText” angelegt.

Die Id unseres Beispiels lautet FormattedTexts.FooterBold.

image-20240116-095243.png

<p></p>: ein Absatz (Paragraph)

<b></b>: fett (bold)

Code

Der Zugriff auf die globale Übersetzung Textbaustein funktioniert so:

<FormattedText Name="Footer">
  <Code>$.translations.getFormattedText("FormattedTexts.FooterBold")</Code>
</FormattedText>

Definierter Word-Style

Mit dem Attribut data-word-style-id gibt man an, welchen Style ein Absatz (Paragraph) haben soll. So ist es möglich, mehrere unterschiedlich formatierte Absätze in einem Field auszugeben. Das Attribut kann auch in <span> verwendet werden.

<p data-word-style-id="FusszeileFett">{{bold}}</p>

TIPP
Konsultiere die Entwicklerwerkzeuge in einem erstellten Dokument, um die verfügbaren Word-Styles und deren StyleId herauszufinden. Wie, ist hier beschrieben: Entwicklerwerkzeuge: Register in priorisierter Reihenfolge

Kontrollstruktur (if)

Eine Kontrollstruktur prüft, ob eine Bedingung erfüllt ist und gibt den Inhalt aus.

{{#if bold}}
<p><b>{{bold}}</b></p>
{{/if}}
{{#if normalbold}}
<p>{{normal}}</p>
{{/if}}
{{#if empty}}
<p data-word-style-id="InvisibleLine">{{empty}}</p>
{{/if}}

Schleife (each)

Eine Schleife geht durch eine Liste und wiederholt den Inhalt für jedes Element in der Liste.

{{#each items}}
<p>&#8211;&#009;{{this}}</p>
{{/each}}

Beispiele

Field “Footer” mit benannten Parametern

Im Übersetzungseintrag kann man Platzhalter bzw. Parameter in Absätzen (<p></p>) erstellen, um diese dann mit Daten zu befüllen. Welche Daten schlussendlich in diesen Platzhaltern angezeigt werden, wird im Field über benannte Parameter mit demselben Namen definiert.

Definition in den Globalen Übersetzungen

Globale Übersetzung mit Id: FormattedTexts.FooterBoldWithParams, mit benannten Parametern

<p>Autor: <b>{{firstName}} {{lastName}}</b>, {{function}}</p>

JS-Code

Holt die Übersetzung vom Typ FormattedText. Parameter sind: Snippet-Key und eine Liste von benannten Parametern

<FormattedText Name="Footer">
  <Code>$.translations.getFormattedText("FormattedTexts.FooterBoldWithParams", {
          firstName: $("Forms.FirstName"), // Forms
          lastName: lastName, // Variable
          function: "Doctor" // Fixtext
        })
  </Code>
</FormattedText>

Field “ReferenzNr“

Deckt folgende Inhalte ab:

  • Benannte Parameter ✔️

  • Definierter Word-Style ✔️

  • Kontrollstruktur✔️

Globale Übersetzung mit Id: FormattedTexts.Paragraphs.BoldNormalHeader

{{#if bold}}
<p data-word-style-id="KopfzeileFett">{{bold}}</p>
{{/if}}
{{#if normal}}
<p data-word-style-id="Kopfzeile">{{normal}}</p>
{{/if}}

Field “ReferenzNr”, das die Übersetzung holt:

<FormattedText Name="ReferenzNr">
  <Code>$.translations.getFormattedText("FormattedTexts.Paragraphs.BoldNormalHeader", {
    bold: $.formattedText.fromText("Header_Step"), // Referenz auf das Text-Field "Header_Step"
    normal: $.formattedText.fromText($("Forms.ReferenzNr")),
  })</Code>
</FormattedText>
<Text Name="Header_Step" Value="Referenz-Nr:" />

Ergebnis in Word

Field “EnclosuresBox”

Deckt folgende Inhalte ab:

  • Definierter Word-Style ✔️

  • Kontrollstruktur✔️

  • Schleife ✔️

Globale Übersetzung mit Id: FormattedTexts.EnclosuresBox

{{#if enclosures}}
<p><b>Beilagen</b></p>
{{#each enclosures}}
<p data-word-style-id="NormalNoSpacing">&#8211;&#009;{{this}}</p>
{{/each}}
{{/if}}

{{#if copies}}
<p><b>Kopie an</b></p>
{{#each copies}}
<p data-word-style-id="NormalNoSpacing">&#8211;&#009;{{this}}</p>
{{/each}}
{{/if}}

{{#if empty}}
<p data-word-style-id="InvisibleLine">&#160;</p>
{{/if}}

Field “EnclosuresBox”, das die Übersetzung holt:

<FieldsGlobalFields>
  <FormattedText Name="EnclosuresBox">
    <Code><![CDATA[
        function main() {
          
          let enclosures = [];  // Array erstellen, das mehrere Beilagen enthalten wird
          if($("Forms.Enclosures")){ // wenn der Benutzer im Feld etwas eingegeben hat...
            enclosures = $("Forms.Enclosures").split("\n"); // fülle das Array mit jedem Element, das vor einem Zeilenumbruch steht
          }
          
          let copies = []; // Array erstellen, das mehrere Einträge enthalten wird
          if($("Forms.CopyTo")){ // wenn der Benutzer im Feld etwas eingegeben hat...
            copies = $("Forms.CopyTo").split("\n"); // fülle das Array mit jedem Element, das vor einem Zeilenumbruch steht
          }
          // Wenn beide Arrays die Länge 0 haben (und somit leer sind), ist der Wert 'true'
          let empty = (enclosures.length === 0 && copies.length === 0) ? "true" : "";
          
          return $.translations.getFormattedText("FormattedTexts.EnclosuresBox", { 
                                enclosures: enclosures,
                                copies: copies, 
                                empty: empty }); 
        }
      ]]></Code>
  </FormattedText>
</FieldsGlobalFields>

Ergebnis in Word

FormattedText als Textbaustein

Wie erwähnt, können Textbausteine vom Typ Formatierter Text keine Tabellen, Bilder oder sonst komplexe Word-Inhalte abspeichern. Daher wird ein FormattedText nur als Textbaustein erstellt und in ein Field geholt, wenn es sich um Absätze mit Text handelt, die einen oder mehrere Styles aufweisen.

Der FormattedText ist als Textbaustein vom Typ “Formatierter Text” abgelegt und hat einen Schlüssel (Key).

Der Key unseres Beispiels lautet FooterFTSnippet.

image-20240116-094938.png

Code

Der Zugriff auf den Textbaustein funktioniert so:

<FormattedText Name="FooterFTSnippet">
  <Code>$.snippets.getFormattedText("FooterFTSnippet")</Code>
</FormattedText>

Typ WordContent

Beispiele

WordContent-Field Introduction

<WordContent Name="Introduction">
  <Code>
    $.snippets.getWordContent('Introduction'); // Parameter ist Snippet-Key
  </Code>
</WordContent>

WordContent-Field ContractTitles mit benannten Parametern

Im Textbaustein man Textbausteinplatzhalter bzw. Parameter. Welche Daten schlussendlich in diesen Platzhaltern angezeigt werden, wird im Field über benannte Parameter mit demselben Namen definiert:

<WordContent Name="ContractTitles">
  <Code>$.snippets.getWordContent("Introduction", {
    dateToday: $("Forms.Date").FormattedValue, // Platzhalter wird mit Forms-Feld befüllt
    guests: $("Guests")  } // mit Field befüllt
  )</Code>
</WordContent>

WordContent-Textbaustein erstellen

Bevor man ein WordContent-Field erstellen kann, benötigt man einen WordContent-Textbaustein: einen Textbaustein vom Typ Word Inhalt. Die drei wichtigsten Punkte:

  • Um dynamischen Inhalt (Fields, Forms, Profil-Daten) zu hinterlegen, werden Inhaltssteuerelemente, sogenannte Textbausteinplatzhalter, im entsprechenden Absatz eingefügt.

  • WordContent-Textbausteine werden wie alle anderen Textbausteine mittels Drag’n’Drop in die gewünschte Kategorie in der Textbaustein-Leiste abgespeichert.

  • Zur Verwendung in Fields benötigst du einen Schlüssel (Key).

Textbausteinplatzhalter einfügen

Damit in ein WordContent-Textbaustein dynamischer Text (von Fields, Forms-Feldern oder Profil-Daten) eingefügt werden kann, benötigen wir Inhaltssteuerelemente, sogenannte Textbausteinplatzhalter.

Ein Textbausteinplatzhalter kann im Word-Editor einer Vorlage in einen Textabschnitt eingefügt werden, der anschliessend als WordContent-Textbaustein abgespeichert wird.

Die Inhaltssteuerelemente von Textbausteinplatzhaltern sind gelb.

Vorgehen

  1. Den Cursor im Textabschnitt an die gewünschte Stelle setzen.

  2. Im primedocs Ribbon auf den Button Textbausteinplatzhalter einfügen klicken.

  3. Den Namen des Platzhalters eingeben und mit Klick auf den Button Einfügen bestätigen.

  4. Dann wird ein gelbes Inhaltssteuerelement eingefügt.

WordContent-Textbaustein abspeichern

WordContent-Textbausteine werden wie alle anderen Textbausteine mittels Drag’n’Drop abgespeichert.
Sehe dir die Demo an oder lese die Anleitung mit allen Erklärungen:

Demo

 WordContent-Textbaustein abspeichern
SaveWordContentSnippet.mp4

Vorgehen

Öffne die Textbaustein-Leiste mittels Klick auf Textbausteine im primedocs Ribbon.

Markiere den Textabschnitt und ziehe diesen mit gedrückter Maustaste (mittels Drag’n’Drop) in den Ordner Vorlagen-Textbausteine in eine beliebige Kategorie.

ACHTUNG
Stelle sicher, dass du dich im Administrationsmodus befindest, denn WordContents können nur in den Vorlagen-Textbausteinen abgelegt werden. Grund dafür ist, dass WordContents eine technische Art von Textbausteinen sind.

Die Vorlagen-Textbausteine sind nur für Template-Administratoren sichtbar.

Benutzer speichern ihre persönlichen Textbausteine weiterhin als classic OpenXml Textbausteine ab.

Passe nun die Eigenschaften des zu erstellenden Textbausteins an:

  • Der Name wird automatisch generiert. Passe ihn gegebenenfalls an.

  • Wähle den Typ “Word Inhalt” (WordContent).

  • Hinterlege einen Schlüssel (Key).

In Fields wird ausschliesslich auf den Schlüssel/Key eines WordContent zugegriffen.

Bestätige anschliessend mit OK.

Anwendungsbeispiel: Einladung

Eine Abteilung hat mehrere Vorlagen für eine Einladung. Der Einladungstext ist zwar immer gleich, zwei Werte sind jedoch je nach Vorlage unterschiedlich. Daher wird der Text als WordContent-Textbaustein mit Textbausteinplatzhaltern für mehr Flexibilität abgespeichert.

Im erstellten Dokument soll am Schluss der folgende Text angezeigt werden:
Einladung zum Event «[Event]» am [Datum].

Dabei sind Event und Datum dynamische Inhalte, die wir über Forms beim Benutzer abfragen möchten und dann im Text ausgegeben werden sollen.

Für dieses Anwendungsbeispiel benötigen wir:

  1. einen Textbaustein mit den Textbausteinplatzhaltern und mit Schlüssel

  2. Forms-Felder, die später im Textbaustein sein sollen

  3. ein WordContent-Field, das den Textbaustein holt, die Parameter mit den Forms-Feldern befüllt und später in die Vorlage kommt

Vorgehen

  1. Textbaustein vom Typ WordContent erstellen:

    1. Einen Textbausteinplatzhalter einfügen mit Name EventName.

    2. Einen zweiten Textbaustenplatzhalter einfügen mit Name EventDate.

    3. in Word:

    4. Textabschnitt markieren und in der gewünschten Kategorie abspeichern:

      1. als Typ “Word Inhalt”

      2. als Schlüssel setzen wir “Invitation”.

  2. Forms-Felder erstellen in Forms, siehe Dokumentation Formulare (Forms)

    1. ein Text-Feld für EventName

    2. ein Date-Feld für EventDate

  3. WordContent-Field erstellen und in der Vorlage platzieren:

    1. Der folgende Code zeigt ein WordContent-Field InvitationSnippet.

    2. Über die Funktion getWordContent() der Snippet API wird der Textbaustein mit Schlüssel Invitation geholt.

    3. Um die Textbausteinplatzhalter mit Inhalt zu füllen, werden die Daten über die Parameter EventName und EventDate mitgegeben. Diese können mit allen Arten von Text gefüllt werden (Fixtext, Forms-Felder, Fields, Benutzerdaten etc.).

    4. Füge die vorhin erstellten Forms-Felder in die Parameter ein:

      1. Dem Textbausteinplatzhalter EventName wird das Forms-Feld Forms.EventName übergeben.

      2. Dem Textbausteinplatzhalter EventDate wird das Forms-Feld Forms.EventDate übergeben. Wir nutzen die Funktion getDateAsString(), da es sich um ein Datumsfeld handelt, das ein Date zurückgibt - wir aber einen String benötigen. Hier mehr Informationen dazu: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/398131214/Code#%C3%9Cbersicht-%C3%BCber-alle-primedocs-eigenen-Funktionen

        <WordContent Name="InvitationSnippet">
  <Code>
    // Snippet vom Typ WordContent mit zwei Parameter "EventName" und "EventDate"
    $.snippets.getWordContent('Invitation', { 
                              EventName: $('Forms.EventName'), 
                              EventDate: $.getDateAsString('Forms.EventDate') 
    });
  </Code>
</WordContent>

  4. Das Field InvitationSnippet wird dann in der Word-Vorlage über die Schaltfläche Feld binden im Dokument eingefügt und die Vorlage gespeichert.

  5. Das ist das Ergebnis in Word, wenn man das Dokument testet:

Builder (Advanced)

Der Builder ermöglicht das Zusammensetzen von Texts, FormattedTexts und WordContents im Sinne eines Baukastensystems, wobei die einzelnen Elemente dem Typ des Builder entsprechen müssen. Ein Text kann dazu in FormattedText oder WordContent sowie ein FormattedText in WordContent konvertiert werden.

Die Builder API kann in Fields vom Typ WordContent und FormattedText verwendet werden: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/398131214/Code#Builder-API

FormattedText-Field Footer mit Builder

<FormattedText Name="Footer">
  <Code>
    function main() {
      // Snippet vom Typ FormattedText, Parameter ist Snippet-Key
      let ftSnippet =     $.snippets.getFormattedText("FooterFTSnippet");
      
      // Translation vom Typ FormattedText, Parameter ist Id des Übersetzungseintrags
      let ftTranslation = $.translations.getFormattedText("FormattedTexts.FooterBold");
      
      // Translation vom Typ FormattedText mit drei Parameter "firstName", "lastName" und "function"
      let lastName =      $("Forms.LastName");
      
      // Translation vom Typ FormattedText mit Parameter; Parameter ist Snippet-Key und eine Liste von Parameter
      let ftAdvanced =    $.translations.getFormattedText("FormattedTexts.FooterBoldWithParams", {
                            firstName: $("Forms.FirstName"), // Forms
                            lastName: lastName, // Variable
                            function: "Doctor" // Fixtext
                           });
                           
      // Ziel: alle oben erstellten Variablen miteinander verknüpfen mit Builder: Information über Builder weiter unten
      return $.formattedText
              .getBuilder()
              .append(ftSnippet)
              .append(ftTranslation)
              .append(ftAdvanced)
              .build();
    }
  </Code>
</FormattedText>

Ergebnis in Word

image-20240116-094538.png

FormattedText-Field KopfzeileContact mit Builder

JS-Code

<FormattedText Name="KopfzeileContact">
  <Code>
    function main(){
      let job = $("Profile.User.Function");
      let name = $.joinNonEmpty(" ", $("Profile.User.Title"), $("Profile.User.FirstName"), $("Profile.User.LastName"));
      let address = $("Forms.Address");
      let refCityDate = $.joinNonEmpty("\n",
        $("RefNrForm"),
        $("Profile.User.Postal.City") + ", " + $.getDateAsString("Forms.Date"));

      // Builder
      return $.formattedText.getBuilder()
        .append($.translations.getFormattedText("FormattedTexts.Paragraphs.NormalBoldHeader", {
          bold: "", // bold erscheint danach nicht
          normal: job }))
        .append($.translations.getFormattedText("FormattedTexts.Paragraphs.BoldNormalHeader", {
          bold: name,
          normal: address }))
        .append($.translations.getFormattedText("FormattedTexts.Paragraphs.NormalBoldHeader", {
          bold: "", // bold erscheint danach nicht
          normal: "\n" + refCityDate + "\n\n" }))
        .build();
    }
  </Code>
</FormattedText>

Ergebnis in Word

image-20240815-151210.png

WordContent-Field KopfzeileContact mit Builder

JS-Code

<WordContent Name="KopfzeileContact">
  <Code>
    function main(){
      let job = "\n" + $("Profile.User.Function");
      let name = $.joinNonEmpty(" ", $("Profile.User.Title"), $("Profile.User.FirstName"), $("Profile.User.LastName"));
      let addressSnippet = $.snippets.getWordContent("AddressSnippet", {
        address: $.wordContent.fromText("Forms.Address");
      });
      let refCityDate = $.joinNonEmpty("\n",
        $("RefNrForm"),
        $("Profile.User.Postal.City") + ", " + $.getDateAsString("Forms.Date"));
      
      let nameFT = $.translations.getFormattedText("FormattedTexts.Normal", {
          normal: name });

      // Builder
      return $.wordContent.getBuilder()
        .append($.wordContent.fromText(job))
        .append($.wordContent.fromFormattedText(nameFT))
        .append($.snippets.getWordContent(addressSnippet))
        .append($.wordContent.fromText("\n" + refCityDate + "\n\n"))
        .build();
    }
  </Code>
</WordContent>

Ergebnis in Word

image-20240815-151146.png

Typ Date

Siehe technische Dokumentation: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/56918029/Felder+Fields#Date

HINWEIS
Beachte: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/56918029/Felder+Fields#%C3%9Cbersicht-Field-Typ-pro-Office-Anwendung

Das Datum erscheint in dem Format, das in Forms definiert wurde.

Hier gibt es mehr Informationen: https://primesoft-group.atlassian.net/wiki/spaces/PD/pages/395444225/JavaScript+in+Fields#Datumsfunktionen-und-mit-Daten-rechnen

Typ YesNo

Siehe technische Dokumentation: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/56918029/Felder+Fields#YesNo

Das CheckBox-Inhaltssteuerelement kann man nicht in Vorlagen einfügen:
https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/56918029/Felder+Fields#%C3%9Cbersicht-Field-Typ-pro-Office-Anwendung

Ein Field vom Typ YesNo wird momentan eingesetzt, um eine Logik in mehreren Fields zu verwenden und so den Code übersichtlicher zu gestalten.

Beispiele

Simples Beispiel

In diesem Beispiel wird die folgende Bedingung geprüft: Wenn das Forms-Feld nicht null ist (wenn es also existiert), wird true ausgegeben, sonst false.

<YesNo Name="HasSignerMain">
  <Code>$("Forms.SignerMain") !== null</Code>
</YesNo>

Umfangreicheres Beispiel

In diesem Beispiel werden mehrere Bedingungen geprüft:

<YesNo Name="SignerIsRegierungsrat">
  <Code>
    function main(){
      let rr = $.translations.getText("Staff.RRFunction"); // hole globale Übersetzung
      return $("HasSignerMain") && $("Forms.SignerMain.User.Function") === rr;
    }
  </Code>
</YesNo>

  • Mit $("HasSignerMain") wird zuerst geprüft, ob es einen Hauptunterzeichnenden gibt; das Feld HasSignerMain gibt hier true oder false zurück.

  • Gibt $("HasSignerMain") true zurück, wird geprüft, ob im Benutzerfeld User.Function der gleiche Wert steht, wie in der globalen Übersetzung Staff.RRFunction. Ist das der Fall, wird true ausgegeben.

  • In allen anderen Fällen, wird false ausgegeben.

Das heisst, SignerIsRegierungsrat gibt true zurück, wenn es sich beim Benutzer, der das Dokument erstellt und der Hauptunterzeichnender ist, um einen Regierungsrat handelt.

Typ Picture

Siehe technische Dokumentation: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/edit-v2/56918029#Picture

Mit Fields vom Typ Picture kann man Bilder in ein Field holen. Dabei gelingt dies auf zwei Arten:

  • über eine Referenz auf Profil- oder Organisationsdaten

  • Über eine Adresse auf eine Datei (Asset)

Beispiele

Unterschriftenbild eines Unterzeichnenden holen

<Picture Name="SignerMainSignature">
  <Code>$("Forms.SignerMain.User.Sign")</Code>
</Picture>

Logo einer Organisation holen

<Picture Name="Logo">
  <Code>$("Profile.Org.Logo")</Code>
</Picture>

Bild aus den Dateien (Asset) holen

<Picture Name="PartnerLogo" Asset="\\fileshare\PartnerLogo.png" />

Fields modifizieren

GlobalFields, die man in einer Vorlage oder einem globalen Eintrag referenziert hat, können modifiziert werden. Wir empfehlen, so oft wie nötig und so wenig wie möglich zu modifizieren.

Die technische Dokumentation führt in das Thema ein: https://primesoft-group.atlassian.net/wiki/spaces/PDT/pages/edit-v2/56918029#Fields-modifizieren

Beispiel

Globaler Eintrag Fields.Contract

Die Konfiguration des GlobalField mit Id Fields.Contract enthält mehrere Fields sowie eine Referenz auf ein anderes GlobalField:

<FieldsGlobalFields>
    
    <Text Name="Subject">
      <Code>$("Forms.Subject")</Code>
    </Text>
    
    <FormattedText Name="CityDate">
      <Code>$.translations.getFormattedText("FormattedTexts.Paragraph.BoldNormal", {
        bold: $("Profile.User.Postal.City"),
        normal: $("Date")
      })</Code>
    </FormattedText>
    
    <WordContent Name="Introduction">
      <Code>$.snippets.getWordContent("Introduction")</Code>
    </WordContent>
     
    <Date Name="Date">
      <Code>$("Forms.Date").Value</Code>
    </Date>
    
    <Picture Name="UserImage">
      <Code>$("Profile.User.ProfileImage")</Code>
    </Picture>
    
    <Text Name="IsGLMitgliedText">
      <Code>$("IsGLMitglied").toString()</Code>
    </Text>
    <YesNo Name="IsGLMitglied" Value="false" />
    
    <!-- hier wird ein YesNo-Feld 'IsPresident' mit dem Wert 'true' geholt -->
    <GlobalFields Key="Fields.IsPresident" />
    
</FieldsGlobalFields>

Field-Konfiguration in Vorlage

Der globale Eintrag ist in der Inhaltsvorlage in der Fields-Konfiguration referenziert:

<FieldsConfiguration>
  <Fields>
    <GlobalFields Key="Fields.Contract" />
  </Fields>
</FieldsConfiguration>

Zu diesem Zeitpunkt werden die Felder folgendermassen angezeigt:

image-20240729-100751.png

Modifizierung

Nun möchte man in dieser spezifischen Vorlage die Felder anders definieren. Dazu werden sie so modifiziert:

<FieldsConfiguration>
  <Fields>
    <GlobalFields Key="Fields.Contract">
      <Modifications>
        
        <!-- anderer Betreff -->
        <Text Name="Subject" Value="Vertragsnachtrag" />
        
        <!-- mit Kürzel ergänzt -->
        <FormattedText Name="CityDate">
          <Code>$.translations.getFormattedText("FormattedTexts.Paragraph.BoldNormal", {
            bold: $("Profile.User.Postal.City"),
            normal: $.joinNonEmpty(", ", $("Date"), $("Profile.User.Alias"))
          })</Code>
        </FormattedText>
        
        <!-- anderer Textbaustein -->
        <WordContent Name="Introduction">
          <Code>$.snippets.getWordContent("IntroductionAppendum")</Code>
        </WordContent>
        
        <!-- Nun definiert plus 60 Tage -->
        <Date Name="Date">
          <Code>
            function main(){
              let result = $("Forms.Date").Value;
              result.setDate(result.getDate() + 60);
              return result;
            }
          </Code>
        </Date>
        
        <!-- Nun definiert mit dem Bild aus einem Forms-Feld -->
        <Picture Name="UserImage">
          <Code>$("Forms.SignerMain.User.ProfileImage")</Code>
        </Picture>
        
        <!-- auf 'false' gestellt -->
        <YesNo Name="IsGLMitglied" Value="false" />
        <YesNo Name="IsPresident" Value="false" />
        
      </Modifications> 
    </GlobalFields>
  </Fields>
</FieldsConfiguration>

Ergebnis

Wird nun erneut ein Dokument erstellt inkludiert primedocs die neuen Definitionen und nicht die ursprünglich referenzierten.

Somit werden in einem erstellten Dokument in den gleichen Fields die neuen Werte angezeigt:

image-20240729-101040.png

  • No labels

PrimeSoft AG, Bahnhofstrasse 4, 8360 Eschlikon, Switzerland