A: Derived Attributes

Eine Auflistung aller Derived Attributes finden Sie im Artikel Derived Attributes.

AbstractAdresseintrag

  • AdressText: VtcString.

    Wird auf der entsprechenden Subklasse berechnet.

  • AuslagenWeiterleiten: boolean.

    Berechnet sich aufgrund von xAuslagenWeiterleiten. Ist der Wert xAuslagenWeiterleiten NULL, gilt false.

Adresseintrag

  • dokpfad: VtcString.
    • wenn xDokPfad gesetzt:
      • ist der Pfad absolut, wird er so verwendet
      • sonst: RootDokPfad (Dokumentenpfad in Systemeinstellungen) + xDokpfad.
    • wenn xDokPfad nicht gesetzt:
      • wenn Adress-Dokumentenpfad in Systemeinstellungen gesetzt:
        • ist der Pfad absolut, wird er so verwendet
        • sonst: RootDokPfad + Adress-Dokumentenpfad
      • wenn Adress-Dokumentenpfad nicht gesetzt:
        • RootDokPfad
    • Illegale Characters werden durch '-' ersetzt.

AbstractUser

  • EffRights: blob.

    Setzt die Liste der Rechte für den User zusammen.

AdressLayout

  • AdressText: VtcString.

    Setzt den Adresstext aufgrund des hinterlegten Layouts (mit den Variablen in %%) zusammen.

Aktivitaet

  • DokErstellt: DateTime.

    Wenn es eine Pfadangabe hat und dieses Dokument existiert, wird das 'FileCreated'-Datum des Dokuments genommen. Ansonsten CreationDateTime der Aktivität.

  • DokGeaendert: DateTime.

    Wenn es eine Pfadangabe hat und dieses Dokument existiert, wird das 'FileChanged '-Datum des Dokuments genommen. Ansonsten ModifiedDateTime der Aktivität.

  • dokpfad: VtcString.
    • Der Dokpfad wird in folgender Reihenfolge berechnet:
      • Falls Projekt vorhanden: Projekt.DokPfad
      • sonst: falls Adresseintrag vorhanden: Adresseintrag.DokPfad
      • sonst: Dokpfad vom ersten Objekt in Eintraege
      • sonst: inherited (geerbt) von UserEintrag.DokPfad
    • Illegale Character werden durch '-' ersetzt
  • EffPfad: VtcString.

    Berechnet sich aufgrund des Attributes Pfad.

    Wenn ein absoluter Pfad angegeben ist, wird dieser ohne Bearbeitung übernommen.

    Ist ein relativer Pfad angegeben, wird der DokPfad vorne angehängt.

    Ist kein Pfad angegeben, ist EffPfad leer.

  • pendent: boolean.

    (zustaendig <> nil) and not erledigt.AsBoolean

  • phasenlookup: ObjectList.

    Berechnet die Liste der möglichen Phasen, die ausgewählt werden können.

    Es muss ein Projekt angegeben sein. In der Phasenliste werden diejenigen Phasen dieses Projekts angezeigt, für die der Erfasser der Aktivität berechtigt ist.

    Zugriffsbeispiel via OCL:

    phasenlookup.list.oclAsType(ProjektPhase).code->listToString(',')

AktivitaetenContainer

  • orderClause: VtcString
    • bisTermin ist gesetzt: 'termin'
    • bisTermin ist nicht gesetzt: 'bold_id'
  • whereClause: VtcString
    • Formatiert die Abfrage gemäss Usereingaben.

Auslage

  • AuslageTypenLookup: ObjectList.

    Gibt nur die Auslagetypen zurück, die zur angegebenen Phase passen (Lookup mit Phase).

  • AuslageTypenLookupOpen: ObjectList.

    Gibt alle Auslagetypen zurück, die zum Projekt und zu allen Phasen des Projekts passen (Lookup ohne Phase).

  • LieferAdresse: ObjectReference.
    • xLieferadresse, sonst:
    • Lieferadresse ist unsere eigene Adresse: TProperty.PropertyByName(Firma).
    • wenn bei beidem nichts angegeben: LieferAdresse.BoldObject:=nil.
  • MWSTBetrag: VtcCurrency.
    • Falls Weiterleiten gesetzt, ist externer Wert und auch MWSTBetrag = 0.
    • sonst: wie Basisklasse AuslageBase.
  • RabattNetto: VtcCurrency.
    • Ist die Auslage brutto (isBrutto = true):

      = RabattBetrag.AsCurrency / (1 + MWSTSatz.AsFloat/100).

    • Ist die Auslage netto (isBrutto = false):

      = RabattBetrag.AsCurrency;

  • Rechnungsadresse: ObjectReference.
    • xRechnungsadresse, oder:
    • Weiterleiten ist gesetzt: Rechnungsadresse ist Rechnungsadresse des Kunden. Nimmt die Rechnungadresse des Projekts dieser Auslage. Wenn es kein Projekt hat, ist die Rechnungsadresse nil.
    • Weiterverrechnen ist gesetzt: Rechnungsadresse ist unsere eigene Adresse. Nimmt die in den Systemeinstellungen gesetzte Firma (TProperty.PropertyByName(Firma)). Wenn es keine hat, ist die Rechnungsadresse nil.
  • weiterleiten: boolean.
    1. Falls Kreditor zugeordnet und weiterleiten gesetzt, diesen Wert berücksichtigen: Kreditor.xWeiterleiten.AsBoolean.
    2. xWeiterleiten berücksichtigen, falls gesetzt.
    3. Phase: Wenn es eine Phase zugeordnet hat, diesen Wert berücksichtigen: GetPhase.AuslagenWeiterleiten.AsBoolean.
    4. Projekt: Wenn ein Projekt zugeordnet ist, diesen Wert berücksichtigen: GetProjekt.AuslagenWeiterleiten.AsBoolean.
    5. Weiterleiten.AsBoolean:=false.
  • WertBudget: VtcCurrency.
    • weiterleiten ist gesetzt: Es wird der interne Wert (netto) verwendet: WertInt.asCurrency.
    • sonst: Es wird der externe Wert (netto) verwendet: WertExt.AsCurrency.

AuslageBase

  • AufwandKonto: VtcString.
    • Wenn xAufwandKonto gesetzt ist:

      = xAufwandKonto.AsString

    • sonst:
      • wenn typ zugeordnet und typ.Aufwandkonto gesetzt ist:

        = typ.AufwandKonto.AsString

      • sonst:
        • nehme Default aus Property:
          • if self is TAuslage:

            = StringProp(AufwandkontoAuslagen)

          • if self is TSpesen:

            = StringProp(AufwandkontoSpesen)

  • HasMargin: Boolean.
    • Gibt an, ob margin NULL ist oder nicht:
      HasMargin.AsBoolean:=not margin.IsNull
    • Kann auch ohne Leserecht auf margin Attribute ausgelesen werden
  • MWSTBetrag: VtcCurrency.
    • 1. Zuerst wird die Phase berücksichtigt, falls es eine hat:
      • Ist die Phase verrechenbar?
      • Ist die Phase pauschal:

        if self is TSpesen then PauschalSpesen else PauschalAuslagen. Ist die pauschale Phase abgeschlossen? Dann:

        • lege Auslagenbudget gemäss Anteil Wertint auf einzelne Auslage um:

          WertInt.AsCurrency *
          phs.PlanAuslagenWert.AsCurrency /
          phs.SumAuslagenWertInt.AsCurrency *
          (MWSTSatz.AsCurrency / 100)

        • bzw. das selbe für Spesen:

          WertInt.AsCurrency *
          phs.PlanSpesenWert.AsCurrency /
          phs.SumSpesenWertInt.AsCurrency *
          (MWSTSatz.AsCurrency / 100)

      • Phase ist nicht pauschal:
        • wenn phs.SumSpesenWertInt <> 0:

          WertInt.AsCurrency * phs.PlanSpesenWert / phs.SumSpesenWertInt * (MWSTSatz / 100)

        • sonst: 0.
    • 2. Normaler Eintrag, berechne MWSTBetrag aus WertExtEingabe:
      • wenn isBrutto, dann:

        WertExtEingabe.AsCurrency * (1 - (1 / (1 + (MWSTSatz.AsCurrency/100))))

      • sonst:

        WertExtEingabe.AsCurrency * (MWSTSatz.AsCurrency/100)

    • Je nach runden Property (PropertyByName(SpesenMWSTRunden) wird der Betrag gerundet:
      • Wenn Ja, runden auf 5 Rappen: RundenCurrency(tempBetrag)
      • sonst: runden auf Rappen: RundenTwoDigits(tempBetrag)
  • MWSTBetragEK: VtcCurrency.

    Wird umgerechnet von MWSTBetragEKFW

    • wenn (EingabeWaehrung <> nil) and (Waehrung.BoldObject <> nil), dann wird der Wert von der EingabeWaehrung in die Waehrung umgerechnet.
    • sonst: MWSTBetragEKFW.AsCurrency
  • MWSTBetragEKFW: VtcCurrency.
    • 1. xWertIntFW oder xWertIntFWBrutto sind angegeben:
      • Beide xWerte sind angegeben, berechne MWST als Differenz::

        xWertIntFWBrutto.AsCurrency - xWertIntFW.AsCurrency

      • Nur xWertIntFW ist angegeben:

        Netto Wert ist angegeben. Berechne MWST davon ausgehend:

        xWertIntFW * (MWSTSatzEK / 100)

      • Nur xWertIntFWBrutto ist angegeben:

        Brutto Wert ist angegeben:

        xWertIntFWBrutto * (1 - (1 / (1 + (MWSTSatzEK/100))))

    • kein xWert ist angegeben. MWST Betrag aufgrund von Eingabebetrag (anzahl * einheit) berechnen:
      • Wenn IsBrutto gesetzt, dann:

        WertIntFWEingabe * (1 - (1 / (1 + (MWSTSatzEK/100))))

      • sonst:

        WertIntFWEingabe * (MWSTSatzEK/100)

    • Falls nicht beide xWerte angegeben, je nach Systemeinstellungen MWSTBetrag runden:

      Wenn Property SpesenMWSTRunden auf JA, Wert auf den Fünfer runden, sonst auf zwei Stellen.

  • MWSTCodeEK: VtcString.
    • wenn verrechnet, dann:

      = verrMWSTCodeEK.AsString

    • sonst:
      • wenn MWSTTypEK gesetzt, nehme Code von diesem:

        = TMWSTTyp(MWSTTypEK.BoldObject).Code.AsString

  • MWSTSatzEK: VtcCurrency.
    • wenn verrechnet, dann:

      = verrMWSTSatzEK.AsCurrency

    • sonst:
      • Wenn ein Typ gesetzt ist:

        = TMWSTTyp(MWSTTypEK.BoldObject).Satz.AsCurrency

  • MWSTTypEK: ObjectReference.

    Einkaufs MWSTTyp bestimmen

    • 1. xMWSTTypEK ist zugeordnet:

      = xMWSTTypEK

    • 2. wenn Typ zugeordnet ist und dieser einen MWSTTypEK zugeordnet hat:

      = TAuslageBaseTyp(Gettyp).MWSTTypEK

    • 3. sonst denselben Typ wie Verkauf nehmen:

      = MWSTTyp.BoldObject

  • RabattBetrag: VtcCurrency.

    Wird auf den Subklassen berechnet.

  • WertExtEingabe: VtcCurrency.

    Beachte die Projektphasen. Wenn Projektphase nicht verrechenbar, ist Wert 0. Spesen und Leistungen gleich.

    Falls Phase zugeordnet:

    • wenn nicht 'verrechenbar': 0.
    • wenn 'verrechenbar':

      Phase ist pauschal:

      • muss abgeschlossen sein.

        WertExt berechnet sich anteilmässig am PlanWert der Phase. Gewichtung erfolgt über WertInt. Unterscheidung zwischen Spesen und Auslagen:

        • self is TSpesen:

          Wenn SumSpesenWertInt <> 0, dann:

          WertInt * phase.PlanSpesenWert / phase.SumSpesenWertInt

          sonst: 0

        • self is TAuslage:

          Wenn SumAuslagenWertInt <> 0, dann:

          WertInt * phase.PlanAuslagenWert / phase.SumAuslagenWertInt

          sonst: 0

    Phase ist nicht pauschal, oder keine Phase ist zugeordnet: Normalfall. Wertext aus xWertExt oder über Anzahl * WertProEinheit berechnen:

    • xWertExt, falls gesetzt (ist in Projektwährung), sonst:

    Aufgrund von Anzahl mit Faktoren berechnen:

    • falls Anzahl <> 0: Berechnet WertExt aus Anzahl * WertProEinheitExt und Umrechnung von Währung:

      =Anzahl.AsFloat * WertProEinheitExt.AsCurrency.

      • Falls die EingabeWaehrung <> nil, dann wird dieser Wert noch in die waehrung umgerechnet.
      • Der Wert wird auf zwei Stellen gerundet.
      • Rabatt abziehen: result:=result - RabattBetrag.AsCurrency.
    • Anzahl = 0: Versuche es mit WertInt:
      • if ((not xWertIntFW.IsNull) or (not xWertIntFWBrutto.IsNull)) and (WertProEinheitInt.AsCurrency <> 0):

        Gehe aus von WertInt (netto, bereits in Projektwährung). Zuerst Umrechnung auf Brutto / Netto:

        Wenn isBrutto = true:

        (WertInt + MWSTBetragEK)* WertProEinheitExt / WertProeinheitInt

        sonst:

        WertInt * WertProEinheitExt / WertProeinheitInt

        Der Wert wird auf zwei Stellen gerundet.

      • Wertint = 0, versuche es mit WertKosten:
        • if (not xWertKosten.IsNull) and (WertProEinheitKosten.AsCurrency<>0):

          Brutto / Netto berücksichtigen:

          Wenn isBrutto = true:

          (xWertKosten * (1 + MWSTSatz/100))* WertProEinheitExt / WertProEinheitKosten

          sonst:

          xWertKosten * WertProEinheitExt / WertProEinheitKosten

        • Der Wert wird auf zwei Stellen gerundet.

    • Kann keinen Wert berechnen -> 0.
  • WertInt: VtcCurrency.

    Wird umgerechnet von WertIntFW:

    • if (EingabeWaehrung <> nil) and (Waehrung.BoldObject <> nil), dann wird WertIntFW genommen und von der Eingabewaehrung in die Waehrung umgerechnet.
    • sonst: WertIntFW.AsCurrency
  • WertIntFW: VtcCurrency.
    • 1. Netto Betrag direkt gesetzt:

      = xWertIntFW.AsCurrency.

    • 2. Falls Bruttowert explizit gesetzt, berechne netto aus diesem:

      = xWertIntFWBrutto.AsCurrency - MWSTBetragEKFW.AsCurrency.

    • 3. Berechne nettobetrag aus Eingabewert:
      • wenn isBrutto = true, dann:

        = WertIntFWEingabe.AsCurrency - MWSTBetragEKFW.AsCurrency.

      • sonst:

        = WertIntFWEingabe.AsCurrency.

  • WertIntFWBrutto: VtcCurrency.
    • Wenn xWertIntFWBrutto gesetzt:

      = xWertIntFWBrutto.AsCurrency

    • Sonst:
      • Wenn xWertIntFW gesetzt:

        = xWertIntFW.AsCurrency + MWSTBetragEKFW.AsCurrency

      • Sonst via eingabebetrag etc. berechnen:
        • isBrutto ist gesetzt->Eingabe ist brutto, nehme direkt eingabeWert:

          = WertIntFWEingabe.AsCurrency

        • sonst:

          = WertIntFWEingabe.AsCurrency + MWSTBetragEKFW.AsCurrency

  • WertIntFWEingabe: VtcCurrency.
    • 1. Wenn Anzahl <> NULL:

      = Anzahl.AsFloat * WertProEinheitInt.AsCurrency

    • 2. Anzahl ist null, berechne WertInt aus WertExt:
      • if (not xWertExt.IsNull) and (WertProEinheitExt.AsCurrency <> 0):

        xWertExt * WertProEinheitInt / WertProEinheitExt

        • if (EingabeWaehrung <> nil) and (Waehrung.BoldObject <> nil), wird das ganze in die Eingebewährung umgerechnet.

      • xWertExt nicht gesetzt, versuche es mit WertKosten:
        • if (not xWertKosten.IsNull) and (WertProeinheitKosten.AsCurrency <> 0):

          WertKosten ist immer Netto, muss Eingabewert entsprechend zurückrechnen:

          • isBrutto ist gesetzt:

            xWertKosten * (1 + MWSTSatzEK/100)* WertProEinheitInt / WertProEinheitKosten

          • sonst:

            xWertKosten * WertProEinheitInt / WertProEinheitKosten

          • if (EingabeWaehrung <> nil) and (Waehrung.BoldObject <> nil), wird das ganze in die Eingebewährung umgerechnet.
      • 3. Kann keinen Wert ermitteln -> 0
  • WertKosten: VtcCurrency.
    • 1. xWertKosten ist gesetzt:

      = xWertKosten.AsCurrency

    • 2. Falls Anzahl gesetzt:
      • isBrutto ist gesetzt:

        Anzahl * WertProEinheitKosten / (1 + (MWSTSatzEK / 100))

      • sonst:

        Anzahl * WertProEinheitKosten

      • Der Wert wird gerundet. Wenn MWST auf Spesen und Auslagen in den Systemeinstellungen JA, wird der Wert auf 5 Rappen gerundet, sonst auf zwei Stellen.
    • 3. Anzahl ist null, Kosten aufgrund von WertInt berechnen (falls gesetzt):
      • gehe aus von WertInt (netto, bereits in Projektwährung):
        • if ((not xWertIntFW.IsNull) or (not xWertIntFWBrutto.IsNull)) and (WertProEinheitInt.AsCurrency <> 0):

          WertInt * WertProEinheitKosten / WertProeinheitInt

        • auf zwei Stellen gerundet

      • WertInt auch nicht angegeben, berechne aufgrund von xWertExt (kann nicht WertExt nehmen, da dieser ev. manipuliert):
        • if (not xWertExt.IsNull) and (WertProEinheitExt.AsCurrency <> 0):
          • isBrutto gesetzt:

            xWertExt / (1 + MWSTSatz/100) * WertProEinheitKosten / WertProEinheitExt

          • sonst:

            xWertExt / WertProEinheitKosten / WertProEinheitExt

    • 4. Kann Wert nicht berechnen -> 0
  • WertKostenLW: VtcCurrency.

    Rechnet WertKosten in Leitwährung um. Nun muss herausgefunden werden, in welcher Währung WertKosten ist. Das wird dann umgerechnet.

    • 1. Falls EingabeWaehrung gesetzt, diese nehmen (da wertkosten in Eingabewährung vorliegt).
    • 2. Falls Waehrung gesetzt, diese nehmen.
    • 3. Sonst: 0.

AuslageBaseTyp

  • ArtikelNr: VtcString.
    • xArtikelNr, falls gesetzt.
    • sonst: PropertyByName(DefaultArtikelNrSpesen).
    • sonst: Leerstring.

AuslageBaseTypPhaseLink

  • Name: VtcString.

    Wird auf den einzelnen Subklassen berechnet.

  • SumKosten: VtcCurrency.
    • self is TAuslageTypPhaseLink:
      • hole die Liste der Auslagen (phase.Auslagen) von der zugeordneten Phase und summiere den WertKosten von allen, die denselben Typ haben.
    • sonst:

      hole die Liste der Spesen (phase.Spesen) von der zugeordneten Phase und summiere den WertKosten von allen, die denselben Typ haben.

    • wenn nichts vorhanden: 0
  • SumWertExt: VtcCurrency.
    • self is TAuslageTypPhaseLink:
      • hole die Liste der Auslagen (phase.Auslagen) von der zugeordneten Phase und summiere den WertExt von allen, die denselben Typ haben.
    • sonst:

      hole die Liste der Spesen (phase.Spesen) von der zugeordneten Phase und summiere den WertExt von allen, die denselben Typ haben.

    • wenn nichts vorhanden: 0
  • SumWertInt: VtcCurrency.
    • self is TAuslageTypPhaseLink:
      • hole die Liste der Auslagen (phase.Auslagen) von der zugeordneten Phase und summiere den WertInt von allen, die denselben Typ haben.
    • sonst:

      hole die Liste der Spesen (phase.Spesen) von der zugeordneten Phase und summiere den WertInt von allen, die denselben Typ haben.

    • wenn nichts vorhanden: 0

AuswertBase

  • DoCalculate: boolean.

    Dummy attribute zum Calculate aufrufen über OCL oder COM. Result gibt an, ob Calculate notwendig war:

  • wenn calculated = true:
    • DoCalculate = false

  • wenn calculated = false, wird die Methode Calculate aufgerufen und DoCalculate = true gesetzt.

AuswertMaster

  • Auswertungen: ObjectList.

AuswertMulti

  • Details: ObjectList.

24.11.2006 | 25.06.2007