KubischConsulting
eGECKO / Integris · Prozess-Dokumentation

Business prozesse

🔧 15 Prozesse
🧩 9 Startobjekte
⚙️ Typ Einzelprozess
15Prozesse
15aktiv
9Startobjekte
Register

Businessprozesse im Überblick

Manuell bzw. über Aktionen ausgelöste gscript-Prozesse (Einzelprozesse). Die Beschreibungen wurden aus den Scripts abgeleitet. Klick auf die Nummer springt zum Detail.

Register — 15 Businessprozesse

Nr.TitelStartobjektTypAktiv
PC_KalendjPC Ermittlung Kalenderjahr aus BezeichnungM2002203Kommando● Ja
gbbrinfozeInfo über Zeitkontingente ab 1.1.2025M2900010Kommando● Ja
test123SendTestmailBusinessprocessKommando● Ja
INITWFWAWIINIT für wfentscheidung PYB AltdatenWawiFakturaKommando● Ja
ARCH001Archiv Dokumenten Export REB abgRechnungseingangsbuchKommando● Ja
ILVISTARCHILV nach Istwerte Archivdokumente an FakturaM3000048Kommando● Ja
ILVISTWERTILV Ist-WertermittlungM3000048Kommando● Ja
FIMP03_NACNacharbeit Import Übernahmepaket-NachbrennerFibuBelegUebernahmeKommando● Ja
Pro_003Workflow zurücksetzenM2002203Kommando● Ja
PCAdmin02User PW auf Standard setzenUserKommando● Ja
PCAdmin01User Auth. auf internUserKommando● Ja
Pro_001Workflow startenM2002203Kommando● Ja
FAKTFREIPrüf- und Freigabeprozess startenWawiFakturaKommando● Ja
DimZOsetze Zuordnung Dim an KTRM2000509Kommando● Ja
IstVertragIstVertragM3000048Kommando● Ja
Details

Prozesse

PC_Kalendj

PC Ermittlung Kalenderjahr aus Bezeichnung

EinzelprozessKommando
M2002203  ·  0 - Global  ·  0 - alle Objekte

Ermittelt aus der Bezeichnung der Katalogleistung das Kalenderjahr: enthält die Bezeichnung „Jahr“ und endet auf vier Ziffern (plausibles Jahr 1900–2100), wird der 1. Januar dieses Jahres als Datum ins Feld GBKalenderjahr geschrieben.

PC_Kalendj · M2002203
#!gscript

// Businessprozess (Projektcontrolling)
// Startobjekt: de.css.projekt.projektdefinition.Projektleistung
// Zweck: Kalenderjahr aus der Katalogleistungs-Bezeichnung nacherfassen

def kat = obj.katalogleistung
if (kat == null) {
    return
}

def bez = kat.bezeichnung
if (bez == null) {
    return
}
bez = bez.trim()

// 1) Nur wenn "Jahr" in der Bezeichnung vorkommt
if (!bez.contains("Jahr")) {
    return
}

// 2) Letzte vier Zeichen ziehen
if (bez.length() < 4) {
    return
}
def last4 = bez.substring(bez.length() - 4)

// 3) Pruefen, ob es eine plausible Jahreszahl ist (genau 4 Ziffern)
if (!last4.matches("\\d{4}")) {
    return
}
def jahr = last4.toInteger()
if (jahr < 1900 || jahr > 2100) {
    return
}

// 4) Date fuer den 1. Januar des Jahres bauen
//    GBKalenderjahr ist ein Date-Feld (Anzeige yyyy) -> echtes Date, nicht die Zahl
def cal = new java.util.GregorianCalendar(jahr, 0, 1, 0, 0, 0)
cal.set(java.util.Calendar.MILLISECOND, 0)

obj.GBKalenderjahr = cal.getTime()
gbbrinfoze

Info über Zeitkontingente ab 1.1.2025

EinzelprozessKommando
M2900010  ·  0 - Global  ·  0 - alle Objekte

Sammelt am Mitarbeiter die ab dem 01.01.2025 gültigen Zeitkontingente des aktuellen Arbeitsvertrags, sortiert sie nach Gültigkeitsbeginn und schreibt sie als zusammengefassten Text (Zeitraum = Wert; …) in das Feld gbbrinfozeitkontingente.

gbbrinfoze · M2900010
#!gscript

import java.util.Calendar;

def ma = obj;
if (ma == null) { return; }

// Stichtag 01.01.2025
def cal = Calendar.getInstance();
cal.clear();
cal.set(2025, 0, 1);
def stichtag = cal.getTime();

// 1) passende Gültigkeiten einsammeln
def treffer = [];
def av = ma.getAktuellArbeitsvertrag();
if (av != null) {
    def gueltigkeiten = av.getZeitkontingentGueltige();
    if (gueltigkeiten != null) {
        for (g in gueltigkeiten) {
            if (g != null && g.getGueltigVon() != null && g.getGueltigBis() != null
                    && g.getGueltigBis().after(stichtag)) {
                treffer << g;
            }
        }
    }
}

// 2) nach gueltigVon aufsteigend sortieren (kleinstes zuerst)
treffer.sort { it.getGueltigVon() };

// 3) String bauen
def ergebnis = "";
for (g in treffer) {
    def wert = null;
    def zk = g.getZeitkontingente();
    if (zk != null) {
        for (k in zk) {
            if (k != null && k.getZeitkontingentwertDec() != null) {
                wert = k.getZeitkontingentwertDec();
                break;
            }
        }
    }
    def seg = g.getGueltigVon().format("d.M.yyyy") + " - " +
              g.getGueltigBis().format("d.M.yyyy") + " = " + wert;
    ergebnis = ergebnis ? ergebnis + "; " + seg : seg;
}

ma.gbbrinfozeitkontingente = "" + ergebnis;
println "gbbrinfozeitkontingente gesetzt für " + ma + ": " + ergebnis;
test123

SendTestmail

EinzelprozessKommando
Businessprocess  ·  0 - Global  ·  0 - alle Objekte

Test-Prozess: verschickt eine feste Testmail über TriggerWorkflowTools.sendMail (Absender egecko@gruen-berlin.de, Empfänger eric.karl@css.de). Dient nur zur Prüfung des Mailversands.

test123 · Businessprocess
#!gscript


   try{
                String from = "egecko@gruen-berlin.de"
                String to = "eric.karl@css.de";
                String subject = "Testmail";
                String message = "Hallo, hier ist meine Testmail";

                de.css.util.TriggerWorkflowTools.sendMail(obj,from,to,null,null,null,subject,message,null,false,false);
            } catch (Exception e){
                println e.getMessage();
            }
INITWFWAWI

INIT für wfentscheidung PYB Altdaten

EinzelprozessKommando
WawiFaktura  ·  0 - Global  ·  0 - alle Objekte

Initialisierungsprozess für Altdaten: setzt an der Ausgangsrechnung (WawiFaktura) das Workflow-Kennzeichen wfentscheidung fest auf „PYB“ (ParkYourBike).

INITWFWAWI · WawiFaktura
obj.wfentscheidung = "PYB";
ARCH001

Archiv Dokumenten Export REB abg

EinzelprozessKommando
Rechnungseingangsbuch  ·  0 - Global  ·  0 - alle Objekte

Setzt am zugehörigen FiBu-Beleg des Rechnungseingangsbuchs den Prüfstatus (gbpruefstatus) auf „2023“ – Massenkennzeichnung abgeschlossener REB-Belege für den Archiv-/Dokumentenexport.

ARCH001 · Rechnungseingangsbuch
obj.fibuBeleg.gbpruefstatus = "2023";
ILVISTARCH

ILV nach Istwerte Archivdokumente an Faktura

EinzelprozessKommando
M3000048  ·  0 - Global  ·  0 - alle Objekte

Ordnet der Ausgangsrechnung (Faktura) die Archivdokumente der zugrunde liegenden FiBu-Belege zu: liest die in ILVarchivdaten gespeicherten Belegnummern, holt die passenden FiBu-Belege, sammelt deren Dokumentenarchiv-Einträge und verknüpft sie mit dem Faktura-Beleg.

ILVISTARCH · M3000048
#!gscript

import de.cmsuc.cm.zahlung.Zahlung;
import de.css.wawi.beleg.faktura.WawiFaktura;
import de.integris.kit.bas.IArray;
import de.css.wawi.beleg.WawiBelegposition;
import de.integris.kit.bas.MutableArray;
import de.cmsuc.cm.vertrag.Vertragsobjekt;
import de.cmsuc.cm.zahlung.Zahlungsdefinition;
import de.integris.kit.ctl.AndQualifier;
import de.integris.kit.ctl.Qualifier;
import de.css.report.archiv.DokumentenarchivBinaryData;
import de.css.report.archiv.Dokumentenzuordnung;
import de.css.fibu.beleg.FibuBeleg;
import de.integris.kit.ctl.OrQualifier;
import de.integris.kit.ctl.FetchTools;
import de.integris.kit.ctl.KeyValueQualifier;
import de.integris.kit.ctl.KeyObjectQualifier;
import de.css.report.archiv.DokumentenarchivTools;
import de.css.report.archiv.ArchivTools;
import de.integris.kit.ctl.PropertyEdit;

println("go");
Zahlung zahlung = obj;
println(zahlung);
Zahlungsdefinition zahlungsdef = zahlung.getZahlungsdefinition();
println(zahlungsdef);
WawiFaktura beleg = zahlung.getFakturaBeleg();
String[] belegnummern = splitByPlus(zahlungsdef.ILVarchivdaten);
println(belegnummern);
OrQualifier belegQualifier = new OrQualifier();

for (belegnummer in belegnummern) {
    belegQualifier.addToQualifiers(new KeyValueQualifier(FibuBeleg.BELEGNR, belegnummer.trim()));
}

MutableArray<FibuBeleg> relevanteBelege = FetchTools.getOrFetchObjects(zahlung.getEditingContext(), FibuBeleg.class, belegQualifier);

if (relevanteBelege.count() > 0) {
	MutableArray<DokumentenarchivBinaryData> archive = new MutableArray<>();
	for (FibuBeleg currentBeleg : relevanteBelege) {
		MutableArray<Dokumentenzuordnung> zuordnungen =  DokumentenarchivTools.getDokumentenzuordnungenZuIObject(currentBeleg);
		for (Dokumentenzuordnung zuordnung : zuordnungen) {
			archive.addObjectsWithoutDoubles(zuordnung.getDokumentenarchivBinaryData());
		}
	}
	PropertyEdit edit = zahlung.getEditingContext().beginEdit("Dokumente zuordnen");
	//for (DokumentenarchivBinaryData archivBinary : archive) {
	//	ArchivTools.geckoObjectZuordnungZuBestehendenDokumentenarchiv(edit, beleg, archivBinary, false);
	//}
	ArchivTools.geckoObjectZuordnungZuBestehendenDokumentenarchiv(edit, beleg, archive, false);
	edit.commit();
}


static String[] splitByPlus(String text) { 
    text?.split(/\+/) ?: [] as String[]
}
ILVISTWERT

ILV Ist-Wertermittlung

EinzelprozessKommando
M3000048  ·  0 - Global  ·  0 - alle Objekte

Zentrale ILV-Ist-Wertermittlung an der Zahlungsdefinition: ermittelt über den Vertragsverbund den Zielvertrag, summiert die Netto-IST-Zahlungen (datenart „i“) im Zeitraum ILVvon–ILVbis in ILVbetrag und merkt sich die Belegnummern in ILVarchivdaten. Belegt Fixwerte vor (Zahlungsart 1, Leistungsbeginn heute, Rabatt-Typ „p“, 20,6 %). Berechnet die bereits gezahlten Beträge (ILVbishgezahlt aus Zahlungsdefinition.betrag, ILVbishgezahlt2 aus Zahlung.betrag) und setzt den Restbetrag (betrag = ILVbetrag − ILVbishgezahlt).

ILVISTWERT · M3000048
#!gscript

import de.cmsuc.cm.zahlung.Zahlungsdefinition;
import de.cmsuc.cm.vertrag.Vertragsobjekt;
import de.cmsuc.cm.vertrag.Einzelvertrag;
import de.cmsuc.cm.vertrag.Vertragsverbund;
import de.integris.kit.ctl.KeyObjectQualifier;
import de.integris.kit.ctl.FetchTools;
import de.integris.kit.ctl.EditingContext;
import de.integris.kit.bas.IArray;
import de.cmsuc.cm.vertrag.VertragsverbundZuordnung;
import de.integris.kit.ctl.KeyValueQualifier;
import de.integris.kit.bas.MutableArray;
import de.cmsuc.cm.zahlung.Zahlung;
import de.css.fibu.beleg.FibuBelegposition;
import de.css.fibu.beleg.FibuBeleg;

Zahlungsdefinition currentZ = obj;
EditingContext ec = currentZ.getEditingContext();

// ---------------------------------------------------------------------
// Zeitraum aus der Zahlungsdefinition lesen
// ---------------------------------------------------------------------
Date relevantVon = currentZ.ILVvon;
Date relevantBis = currentZ.ILVbis;

println "Filter VON: " + relevantVon;
println "Filter BIS: " + relevantBis;

if (relevantVon != null && relevantBis != null && relevantVon.after(relevantBis)) {
    println "FEHLER: ILVvon liegt NACH ILVbis – Zeitraum ungültig!";
    return;
}

// ---------------------------------------------------------------------
// Vertragsstruktur ermitteln
// ---------------------------------------------------------------------
Vertragsobjekt currentVo = currentZ.getVertragsobjekt();
String ursprungsNr = currentVo.getNummer();
Einzelvertrag currentEv = currentVo.getEinzelvertrag();

KeyObjectQualifier verbQ =
    new KeyObjectQualifier(Vertragsverbund.HAUPTVERTRAG, currentEv.getGlobalId());
Vertragsverbund verb =
    FetchTools.getOrFetchObject(ec, Vertragsverbund.class, verbQ);

VertragsverbundZuordnung zu = verb.getVertraege().firstObject();
Einzelvertrag zielEv = zu.getEinzelvertrag();

KeyValueQualifier vf = new KeyValueQualifier(Vertragsobjekt.NUMMER, ursprungsNr);
MutableArray zielVOs = vf.filterArray(zielEv.getVertragsobjekte());
Vertragsobjekt relevanterVertrag = zielVOs.firstObject();

// ---------------------------------------------------------------------
// IST-Zahlungen des relevanten Vertrags
// ---------------------------------------------------------------------
IArray defs = relevanterVertrag.getZahlungsdefinitionen();
KeyValueQualifier iq = new KeyValueQualifier(Zahlung.DATENART, "i");

println "Gefilterte Belege im Zeitraum:";

BigDecimal summe = BigDecimal.ZERO;
List belegNummern = [];   // Liste für Archivdaten

defs.each { defItem ->

    MutableArray istZahlungen = iq.filterArray(defItem.getIstzahlungen());

    istZahlungen.each { zahl ->

        FibuBelegposition pos = zahl.getFibuBelegposition();
        FibuBeleg beleg = pos.getBeleg();

        Date belegDatum = beleg.getBelegdatum();
        String belegNr = beleg.getBelegNr();

        BigDecimal betrag = pos.getNettobetragBelegwaehrung();

        if (relevantVon != null && belegDatum.before(relevantVon)) return;
        if (relevantBis != null && belegDatum.after(relevantBis)) return;

        println "BelegNr: " + belegNr +
        " | Datum: " + belegDatum +
        " | Betrag: " + betrag;

if (betrag != null) {
    summe = summe.add(betrag);
    belegNummern.add(belegNr);
}
    }
}

// ---------------------------------------------------------------------
// Summenausgabe
// ---------------------------------------------------------------------
println "--------------------------------------------";
println "SUMME der gefilterten IST-Zahlungen (Netto, Belegwährung): " + summe;
println "--------------------------------------------";

// ---------------------------------------------------------------------
// Archivdaten speichern
// ---------------------------------------------------------------------
String archivString = belegNummern.join("+");
currentZ.ILVarchivdaten = archivString;

println "Archivdaten gespeichert in ILVarchivdaten:";
println archivString;

// ---------------------------------------------------------------------
// SUMME im Feld 'betrag' speichern
// ---------------------------------------------------------------------
currentZ.ILVbetrag = summe;     // <--- HIER wird die Summe gespeichert

println "Summe gespeichert in Feld 'betrag': " + summe;


// ---------------------------------------------------------------------
// Fixwerte vorbelegen an der Zahlungsdefinition
// ---------------------------------------------------------------------

// Zahlungsart fix auf 1 setzen
currentZ.zahlungsart = 1;

// Leistungsbeginn = heutiges Datum
currentZ.leistungBeginn = new Date();

// Rabatt-Typ 'p' (Prozent)
currentZ.rabattTyp = "p";

// Rabatt-Prozent (Achtung: Punkt, kein Komma!)
//UKU 17.12.25 
if (currentZ.rabattProzent1 == null) {
	currentZ.rabattProzent1 =20.6;
}

println "Fixwerte gesetzt:";
println "  zahlungsart = 1";
println "  leistungBeginn = " + currentZ.leistungBeginn;
println "  rabattTyp = 'p'";
println "  rabattProzent1 = 20.6";
//==============================================ab hier Erweiterung spezial====================


// =====================================================================
// DEBUG: Zahlungsdefinitionen & Zahlungen prüfen
// =====================================================================

// =====================================================================
// ILVbishgezahlt berechnen (KORREKT: direkt am Vertragsobjekt von currentZ)
// Quelle:
//  - Zahlungsdefinitionen am Vertragsobjekt von currentZ
// Bedingungen:
//  - zahlung.datenart == 'p'
//  - zahlung.uebergabestatus == 'u'
//  - leistungBeginn der Zahlungsdefinition zwischen currentZ.ILVvon / currentZ.ILVbis
// Betrag:
//  - Summe aus zahlung.betrag
// =====================================================================

// =====================================================================
// ILVbishgezahlt berechnen
// Betrag kommt aus zahlungsdefinition.betrag (zd.betrag)
// =====================================================================

BigDecimal bishGezahlt = BigDecimal.ZERO;

Date von = currentZ.ILVvon;
Date bis = currentZ.ILVbis;

Vertragsobjekt vo = currentZ.getVertragsobjekt();

def defsVo = vo.getZahlungsdefinitionen();

defsVo.each { zd ->

    Date ld = zd.leistungBeginn;
    if (ld == null) return;
    if (von != null && ld.before(von)) return;
    if (bis != null && ld.after(bis)) return;

    // Prüfen: gibt es mind. eine passende Zahlung?
    boolean hatGueltigeZahlung = false;

    zd.getZahlungen().each { zahlung ->
        if ("p".equals(zahlung.datenart) &&
            "u".equals(zahlung.uebergabestatus)) {
            hatGueltigeZahlung = true;
        }
    };

    // Wenn ja → Betrag der Zahlungsdefinition addieren
    if (hatGueltigeZahlung) {
        BigDecimal zdBetrag = zd.betrag;
        if (zdBetrag != null) {
            bishGezahlt = bishGezahlt.add(zdBetrag);
        }
    }
}

println "ILVbishgezahlt (aus Zahlungsdefinition.betrag): " + bishGezahlt;

// Ergebnis setzen
currentZ.ILVbishgezahlt = bishGezahlt;


// Ergebnis setzen (ohne saveChanges, UI speichert automatisch)
currentZ.ILVbishgezahlt = bishGezahlt;

println "ILVbishgezahlt gesetzt.";


// =====================================================================
// Restbetrag berechnen (GANZ AM ENDE)
// betrag = ILVbetrag - ILVbishgezahlt
// =====================================================================

BigDecimal ilvGesamt = currentZ.ILVbetrag;
BigDecimal ilvGezahlt = currentZ.ILVbishgezahlt;

BigDecimal rest = BigDecimal.ZERO;

if (ilvGesamt != null) {
    if (ilvGezahlt != null) {
        rest = ilvGesamt.subtract(ilvGezahlt);
    } else {
        rest = ilvGesamt;
    }
}

currentZ.betrag = rest;

println "Restbetrag gesetzt:";
println "  ILVbetrag      = " + ilvGesamt;
println "  ILVbishgezahlt = " + ilvGezahlt;
println "  betrag (Rest)  = " + rest;


// =====================================================================
// ILVbishgezahlt2 berechnen
// Quelle:
//  - Zahlungen aller Zahlungsdefinitionen am Vertragsobjekt
// Bedingungen:
//  - zahlung.datenart == 'p'
//  - zahlung.uebergabestatus == 'u'
//  - leistungBeginn der Zahlungsdefinition zwischen ILVvon / ILVbis
// Betrag:
//  - Summe aus zahlung.betrag
// =====================================================================

BigDecimal bishGezahlt2 = BigDecimal.ZERO;

Date von2 = currentZ.ILVvon;
Date bis2 = currentZ.ILVbis;

Vertragsobjekt vo2 = currentZ.getVertragsobjekt();
def defsVo2 = vo2.getZahlungsdefinitionen();

defsVo2.each { zd ->

    Date ld = zd.leistungBeginn;
    if (ld == null) return;
    if (von2 != null && ld.before(von2)) return;
    if (bis2 != null && ld.after(bis2)) return;

    zd.getZahlungen().each { zahlung ->

        if ("p".equals(zahlung.datenart) &&
            "u".equals(zahlung.uebergabestatus)) {

            BigDecimal zb = zahlung.betrag;
            if (zb != null) {
                bishGezahlt2 = bishGezahlt2.add(zb);
            }
        }
    }
}

println "ILVbishgezahlt2 (aus zahlung.betrag): " + bishGezahlt2;

// Ergebnis setzen
currentZ.ILVbishgezahlt2 = bishGezahlt2;
FIMP03_NAC

Nacharbeit Import Übernahmepaket-Nachbrenner

EinzelprozessKommando
FibuBelegUebernahme  ·  0 - Global  ·  0 - alle Objekte

Nachbearbeitung importierter FiBu-Übernahmepakete: leitet anhand des Dateinamens (bei OU 10000) die Auftragsnummer ab – Grün Berlin→GB, Natur-Park→SG, Britzer Garten→B, Gärten der Welt→M, Campus→CSN – und schreibt sie in Übernahme und FiBu-Beleg.

FIMP03_NAC · FibuBelegUebernahme
#!gscript

if (obj.fibuBeleg != null)
{
if(obj.uebernahmePaket.dateiname.contains ("Grün Berl") && obj.uebernahmePaket.organisationunit.nr == 10000)  // true
{
obj.auftragsnummer = "GB";
obj.fibuBeleg.auftragsnummer = "GB";
} 
else if(obj.uebernahmePaket.dateiname.contains ("Natur-Park")&& obj.uebernahmePaket.organisationunit.nr == 10000)  // true
{
obj.auftragsnummer = "SG";
obj.fibuBeleg.auftragsnummer = "SG";
}
else if(obj.uebernahmePaket.dateiname.contains ("Britzer Ga")&& obj.uebernahmePaket.organisationunit.nr == 10000)  // true
{
obj.auftragsnummer = "B";
obj.fibuBeleg.auftragsnummer = "B";
}
else if(obj.uebernahmePaket.dateiname.contains ("Gärten der")&& obj.uebernahmePaket.organisationunit.nr == 10000)  // true
{
obj.auftragsnummer = "M";
obj.fibuBeleg.auftragsnummer = "M";
}
else if(obj.uebernahmePaket.dateiname.contains ("Campus")&& obj.uebernahmePaket.organisationunit.nr == 10000)  // true
{
obj.auftragsnummer = "CSN";
obj.fibuBeleg.auftragsnummer = "CSN";
}
}
Pro_003

Workflow zurücksetzen

EinzelprozessKommando
M2002203  ·  0 - Global  ·  0 - alle Objekte

Setzt den Freigabe-Workflow eines Arbeitspakets zurück – aber nur für berechtigte Nutzer: die Berechtigung wird über die Kostenstellen-/Bereichshierarchie (OE-Leiter und Stellvertreter bis zur VM-Ebene) geprüft. Bei Berechtigung werden offene Todos beendet, der Workprozess auf Status 6 gesetzt und der Workflow „PC_RESET“ gestartet; sonst erscheint der Hinweis „nicht berechtigt“.

Pro_003 · M2002203
#!gscript
import de.integris.kit.adm.Todo;
import de.integris.kit.bas.MutableArray;
import de.integris.kit.ctl.PropertyEdit;
import de.integris.kit.ctl.EditingContext;
import de.integris.kit.adm.Workflow;
import de.integris.kit.adm.Workprocess;
import de.integris.kit.grt.IO;
import de.integris.kit.ctl.AndQualifier;
import de.integris.kit.ctl.OrQualifier;
import de.integris.kit.ctl.KeyValueQualifier;
import de.integris.kit.ctl.Qualifier;
import de.integris.kit.ctl.FetchSpecification;
import de.css.kore.stammdaten.kostenstelle.KostenstelleHierarchie;
import de.css.kore.stammdaten.kostenstelle.KostenstelleHierarchieElement;

Object kostenstelle = obj.kostentraeger.KostenstelleWorkflow;
Object p = null;
EditingContext eContext = obj.getEditingContext();
MutableArray userArray = new MutableArray();
userArray.addObjectWithoutDoubles(fetchObject("de.integris.kit.adm.User","name","css"));


if (kostenstelle != null) {
	AndQualifier andqualifier = new AndQualifier();
	andqualifier.addToQualifiers(new KeyValueQualifier("nr",Qualifier.EQUAL,"1"));
	FetchSpecification fs = new FetchSpecification(de.css.kore.stammdaten.kostenstelle.KostenstelleHierarchie,andqualifier);
	MutableArray<KostenstelleHierarchie> ksthArray = eContext.getOrFetchObjects(fs);
	for(KostenstelleHierarchie ksth : ksthArray) {
		//System.out.println(ksth);
		KostenstelleHierarchieElement ksthe = ksth.findKostenstelleHierarchieElement(false,kostenstelle.kostenstelleNr);
		ksthe = ksthe.getParent();
			userArray.addObjectWithoutDoubles(ksthe.getBereich().OELeiter);
			userArray.addObjectWithoutDoubles(ksthe.getBereich().OELeiterSt);

			while(ksthe.getBereich().wfparametervm !="2" ){

				if(ksthe.getParent() == null || ksthe.getParent() == ksthe.getRoot() ){						
						break;
					}
				ksthe = ksthe.getParent();		

				userArray.addObjectWithoutDoubles(ksthe.getBereich().OELeiter);
				userArray.addObjectWithoutDoubles(ksthe.getBereich().OELeiterSt);
			
			}
	}
}
println(userArray);
if(userArray.contains(eContext.getUser())){
PropertyEdit edit = eContext.beginEdit("todo");
MutableArray <Todo> todos = fetchObjects("de.integris.kit.adm.Todo","objectRelations.destinationObject",obj);

for(Todo todo : todos){	
	if(todo.state !="2" && todo.getWorkstep() != null){
		edit.set(todo,"text","Freigabeworkflow wurde von "+ eContext.getUser() + " zurückgesetzt.") ;
		todo.editResult(edit,"1");
		todo.editState(edit,"1");
		todo.getWorkstep().getWorkprocess().endWorkstep( todo.getWorkstep(), "2", "2", null, false, false );
		edit.set(todo.getWorkstep().getWorkprocess(),"state","6");
	}
}

Workflow workflow = fetchObject("de.integris.kit.adm.Workflow","no","PC_RESET");
Workprocess localWorkprocess = workflow.createWorkprocess(edit,obj);
localWorkprocess.start(edit, null, null);
eContext.warning("Workflow wird zurückgesetzt.")
edit.commit()

}else{
	eContext.warning("Nicht berechtigt den Workflow zurückzusetzen.")
}
PCAdmin02

User PW auf Standard setzen

EinzelprozessKommando
User  ·  0 - Global  ·  0 - alle Objekte

Admin-Prozess am Benutzer: startet den hinterlegten Workflow (Referenz per GID) zum Zurücksetzen des Passworts auf den Standardwert.

PCAdmin02 · User
gid://de.integris.kit.adm.Workflow//Yo8yk01dcvkN08K4~MT
PCAdmin01

User Auth. auf intern

EinzelprozessKommando
User  ·  0 - Global  ·  0 - alle Objekte

Admin-Prozess am Benutzer: startet den hinterlegten Workflow (Referenz per GID), der die Authentifizierung des Users auf „intern“ umstellt.

PCAdmin01 · User
gid://de.integris.kit.adm.Workflow//k38yk01dcvkN08K4~MT
Pro_001

Workflow starten

EinzelprozessKommando
M2002203  ·  0 - Global  ·  0 - alle Objekte

Startet den passenden Bestell-/Freigabe-Workflow für ein Arbeitspaket. Erkennt aus den aktiven Projektleistungen die Leistungsart (Budget, Kostenvoranschlag, Auftrag, Nachtrag), wählt abhängig vom bisherigen Workflow-Stand den richtigen Workflow (Bestell_WF_erst/folg/verg/auf/frNa), führt eine Budgetprüfung durch (Jahrestranchen vs. verbindliche Kosten + Beantragung über die Auswertung Pro002) und startet nach Bestätigung im Dialog den gewählten Workflow.

Pro_001 · M2002203
#!gscript;
import de.integris.kit.adm.Workflow;
import de.integris.kit.adm.Workprocess;
import de.integris.kit.analysis.AnalysisTemplate;
import de.integris.kit.bas.MutableArray;
import de.integris.kit.bas.MutableDictionary;
import de.integris.kit.bas.ValueDictionary;
import de.integris.kit.grt.IO;
import de.integris.kit.ctl.EditingContext;
import de.integris.kit.ctl.PropertyEdit;
import de.integris.kit.adm.User;
import de.css.projekt.projektdefinition.Projektleistung;
import de.integris.kit.ctl.Qualifier;
import de.integris.kit.ctl.AndQualifier;
import de.integris.kit.ctl.OrQualifier;
import de.css.util.ArrayTools;
import de.integris.kit.bas.IArray;
import de.integris.kit.ctl.KeyValueQualifier;
import de.integris.kit.ctl.KeyObjectQualifier;
import de.css.projekt.projektdefinition.Arbeitspaket;
import de.integris.kit.analysis.AnalysisFetchTools;


Arbeitspaket arbeitspaket = obj;

PropertyEdit edit = arbeitspaket.getEditingContext().getCurrentEdit();
EditingContext wrkContext = arbeitspaket.getEditingContext().newNestedContext();
Boolean budget = arbeitspaket.getBezeichnung().contains("Budget");
Boolean kostenvoranschlag = false;
Boolean auftrag = false;
Boolean nachtrag = false;

for(  Projektleistung projektLeistung:arbeitspaket.getProjektLeistungen()) {
	if (projektLeistung.aktiv && projektLeistung.statusFreigabe != 2){
		if(projektLeistung.getKatalogleistung().getBezeichnung().contains("Kostenvoranschlag")	|| projektLeistung.getKatalogleistung().getBezeichnung().contains("Kostenberechnung nach VE")){
			kostenvoranschlag = true;	
		}
		if(projektLeistung.getKatalogleistung().getBezeichnung().contains("Auftrag")) {
			auftrag = true;

		}
		if(projektLeistung.getKatalogleistung().getBezeichnung().contains("Nachtrag")){
			nachtrag = true;
		}
		
	}
 }


 Integer lastWorkflow = arbeitspaket.lastWorkflow;
MutableArray<Workflow> workflowArray = new MutableArray();
Integer intWorkflow;
IO ergebnisIO = new IO(null, wrkContext);
ergebnisIO.title=("Info");
String message = "Workflow Start nicht möglich";
Integer leistungsArt;

if(budget||kostenvoranschlag|| auftrag || nachtrag){
	if((arbeitspaket.workflowActive == null || arbeitspaket.workflowActive == false) && arbeitspaket.getKostentraeger() != null && (arbeitspaket.statusWorkflow == null || arbeitspaket.statusWorkflow == 0 || arbeitspaket.statusWorkflow > 7)){
	  //Workflows für Budgetprüfung

	  if(budget){

		if((lastWorkflow == null || lastWorkflow == 0)  &&  (arbeitspaket.statusWorkflow == null || arbeitspaket.statusWorkflow == 0  || arbeitspaket.statusWorkflow > 7)){
			workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_erst"));
		}
		if(lastWorkflow >= 1  && (arbeitspaket.statusWorkflow == null || arbeitspaket.statusWorkflow == 0 || arbeitspaket.statusWorkflow > 7)){
			workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_folg"));
		}
	  }else{
		if( (lastWorkflow == null || arbeitspaket.statusWorkflow  == 0|| arbeitspaket.statusWorkflow > 7)){
		  if(lastWorkflow == null || lastWorkflow == 0){
			  workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_verg"));
			  leistungsArt = 4;
		  }else{
			if(lastWorkflow == 3 && auftrag ){
				workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_auf"));
				leistungsArt = 5;
			}else if(lastWorkflow  >= 4 ){
			
				if(auftrag){
					
					workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_auf"));
				}
			
				if(nachtrag){
					
					workflowArray.addObjectsWithoutDoubles(fetchObject("de.integris.kit.adm.Workflow","no","Bestell_WF_frNa"));	
				}
				
				leistungsArt = 5;
			}
		  }
		}
	  }
	}else{
		if(arbeitspaket.getKostentraeger() == null){
			message = "Kein Kostenträger angegeben.";
		}else{
			message = "Workflow schon gestartet.";
		 }
	}

	
	if(workflowArray.count() > 0){
		//Prüfen ob zu prüfenden Projektleistungen auf aktiv gesetzt sind
		Boolean aktiv = false
		for(Projektleistung pl : arbeitspaket.getProjektLeistungen()) {
			if(pl.aktiv  && pl.getKatalogleistung().getLeistungArt()  == leistungsArt && (pl.statusFreigabe== null || pl.statusFreigabe== 0) ){
				//&& (pl.getKatalogleistung().getBezeichnung().contains("Kostenvoranschlag") || pl.getKatalogleistung().getBezeichnung().contains("Nachtrag") || pl.getKatalogleistung().getBezeichnung().contains("Auftrag, Abruf"))){
				aktiv = true
			}
		}
		if(aktiv == false){
			message = "Es ist keine zu prüfende Projektleistung auf aktiv gesetzt." + "\n\n" + "Daher ist kein Workflowstart möglich.";
			ergebnisIO.setMessage(message);
			ergebnisIO.showModalMessage(wrkContext);
		}else{
			Boolean budgetPruefung = true;
			//Budgetprüfung bei nicht Budget Arbeitspaket durchführen
			MutableDictionary parameter = new MutableDictionary();
			parameter.setObject("arbeitspaket",arbeitspaket);
			parameter.setObject("leistungsArt",leistungsArt);
			AnalysisTemplate analysisTemplateTmp = fetchObject("de.integris.kit.analysis.AnalysisTemplate", "nr","Pro002");
			analysisTemplateTmp.setParameterValues(parameter);
			MutableArray results = AnalysisFetchTools.execute((AnalysisTemplate) analysisTemplateTmp, (boolean) true);
			BigDecimal budgetBd;
			BigDecimal kostenBd;
			BigDecimal kostenAp;

			for(int i = 0;i<results.count();i++){
				ValueDictionary vd = results[i];
				budgetBd = new BigDecimal(vd.getValue("budget"));
				kostenBd = new BigDecimal(vd.getValue("kosten"));
				kostenAp = new BigDecimal(vd.getValue("kostenAp"));
			}
			println(budgetBd);
			println(kostenBd);
			println(kostenAp);
			if(budgetBd < (kostenBd + kostenAp)){
				budgetPruefung = false;
				message = "Budgetprüfung fehlgeschlagen:";
				message += "\n";
				message += "\n";
				message += "Jahrestranchen: " + budgetBd.toString() + " || Verbindlich: "+ kostenBd.toString() + " || Beantragung: " + kostenAp.toString() ;
				message += "\n";
			}
	
			//if(budgetPruefung || leistungsArt == 4){
			if(leistungsArt == 4){
				IO.Label textbudget;
				IO.Label textfreigabe;
				IO.Label texttranche;
				IO.Label textkostenap;
				if(budgetPruefung){
					textbudget = new IO.Label("Budget ist ", "zu beachten!", String.class);
					texttranche = new IO.Label("Jahrestranchen:", budgetBd.toString() , String.class);
					textfreigabe = new IO.Label("Verbindlich:", kostenBd.toString() , String.class);
					textkostenap= new IO.Label("Beantragung:", kostenAp.toString() , String.class);
				}else{
					textbudget = new IO.Label("Budgetprüfung ", "fehlgeschlagen:", String.class);
					textmessage = new IO.Label("Jahrestranchen: ", budgetBd.toString() + " || Verbindlich: "+ kostenBd.toString() + " || Beantragung: " + kostenAp.toString(), String.class);
				}
				IO.Label leerzeile = new IO.Label(" ", "", String.class);
				IO.Label textfield = new IO.Label("Workflow ", "zum Starten auswählen", String.class);
				IO.ComboBox workflowBox = new IO.ComboBox("Workflow:", null, Workflow.class, workflowArray);
				
				Object[] fields = [];			 
				println(budgetPruefung);
				if(budgetPruefung){	
					fields=[textbudget,leerzeile,textfield,workflowBox] as Object[];
				}else{
					fields = [textbudget,textmessage,leerzeile,textfreigabe,textkostenap,textfield,workflowBox]as Object[];
				}

				IO io = new IO(fields, wrkContext);
				io.title=("Workflow starten");
				Boolean result = io.showYesNoDialog(wrkContext);
				
				if(result==true){
					Workflow nestedWorkflow = io.get("Workflow:");
					Workprocess localWorkprocess = nestedWorkflow.createWorkprocess(edit,arbeitspaket);
					//localWorkprocess.startedby = fetchObject("de.integris.kit.adm.User","name","css");
					localWorkprocess.start(edit, null, null);
					message = "Der Workflow wird gestartet.";
					message += "\n" + "\n" + "Hinweis:";
					message += "\n" + "Bitte Start- und Endtermin eintragen!"
					
					ergebnisIO.setMessage(message);
					ergebnisIO.showModalMessage(wrkContext);
					arbeitspaket.workflowActive = true;
				}	
		
			}else{
				ergebnisIO.setMessage(message);
				ergebnisIO.showModalMessage(wrkContext);
			}
			
		}
	}else{
		ergebnisIO.setMessage(message);
		ergebnisIO.showModalMessage(wrkContext);
	}
}else{
	if(kostenvoranschlag == false){
		message = "Es ist keine entsprechende Projektleistung auf aktiv gesetzt."+ "\n\n" + "Daher ist kein Workflowstart möglich."
	}else{
		message="Arbeitspaket ist nicht zu prüfen.";
	}
	ergebnisIO.setMessage(message);
	ergebnisIO.showModalMessage(wrkContext);
}
FAKTFREI

Prüf- und Freigabeprozess starten

EinzelprozessKommando
WawiFaktura  ·  0 - Global  ·  0 - alle Objekte

Startet den Prüf- und Freigabeprozess einer Ausgangsrechnung, indem die Statusart auf „PRUEFLAUF“ gesetzt wird – das löst die zugehörigen Faktura-Trigger für den Freigabe-Workflow aus.

FAKTFREI · WawiFaktura
obj.statusart = fetchObject('de.css.crm.aktivitaet.AktivitaetStatusArt', 'statusNr', 'PRUEFLAUF');
DimZO

setze Zuordnung Dim an KTR

EinzelprozessKommando
M2000509  ·  0 - Global  ·  0 - alle Objekte

Legt am Kostenträger eine universelle Zuordnung für die Dimension 02 an (Schlüssel „Dim02“) mit Gültigkeit ab 01.01.2022, sofern eine Dimension 02 gesetzt ist.

DimZO · M2000509
#!gscript
import de.css.kit.logikModule.gueltigkeit.GueltigkeitTools;
import java.text.SimpleDateFormat;

SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");

if (obj.dimension02 != null) {

	Object dimZO = createIntoObjects(obj, "universellezuordnungen");
	dimZO.schluessel = fetchObject("de.css.global.stammdaten.Schluessel", "schluessel", "Dim02");

	Object gk  = createIntoObjects(dimZO, "vargueltigkeiten");
	gk.gueltigVon = sdf.parse("01.01.2022");
	gk.zuordnungsobjekt = obj.dimension02;
}
IstVertrag

IstVertrag

EinzelprozessKommando
M3000048  ·  0 - Global  ·  0 - alle Objekte

Spaltenformel (IntegrisParser): summiert über alle Planzahlungen – liegt eine Ist-Zahlung vor, zählt deren Betrag, sonst der Planbetrag. Ergebnis (objectValue) ist der Ist-/Vertragswert.

IstVertrag · M3000048
!objectValue = 0;
for (integer i = 0; i < countObjects(planzahlungen); i++) {
                Object zahl = getObjectAt(planzahlungen, i);
		if (zahl.istZahlung != null) {
			objectValue += zahl.istZahlung.betrag
		} else {
                	objectValue += zahl.betrag;
		}
}
Erstgespräch · kostenlos · unverbindlich

Erzählen Sie mir, was Sie abtippen.

Meist ist nach zwanzig Minuten klar, ob sich das automatisieren lässt — und ob es sich lohnt. Wenn nicht, sage ich Ihnen das auch.

Kontakt aufnehmen  → info@kubisch.consulting