DOIT (Workflow) Modul

Geändert am Mo, 10 Okt, 2022 um 4:07 NACHMITTAGS

Das DOIT (Workflow) Modul ist das zentrale Modul das die Durchführung von Aufgaben steuert.

Für das Modul können Aufgaben-Listen (Tasks) mit Hilfe von YAML-Konfigurations-Dateien definiert werden.
- Jedes dieser Tasks kann beliebig viele Unteraufgaben (Steps) enthalten die nacheinander abgearbeitet werden.
- Bei jedem Step wird mindestens 1 Funktion (teils automatisch oder vordefiniert) aufgerufen.

- Jeder Step kann aus vielen gleichen Funktionsaufrufen bestehen.

Z.B. führe eine Aufgabe für alle Artikel, Kategorien, Attribute, Kunden etc. durch.

Es können sehr komplexe Tasks (Workflows) für unterschiedlichste Aufgaben definiert werden die nacheinander abgearbeitet werden. Einzelne Steps können aktiviert oder deaktiviert werden. Sie können auch auf Funktionen beliebiger Klassen zugreifen.

Das DOIT Modul gibt es in einer Light und Professional Version. Die Light-Version wird für Ausführung von DOIT Modulen benötigt. Die Professional Version ermöglicht die Entwicklung eigener DOIT-Module und ist sehr leistungsfähig.

Diese Dokumentation beinhaltet hauptsächlich die Funktionsweise der Professional Version.

DOIT Tasks sind im Shop Admin-Bereich in einem DropDown (Admin-Bereich / Service / DOIT) auswähl-und aufrufbar.

DOIT Module

Mit Hilfe des DOIT Basis Moduls können die Steps unterschiedlichster DOIT Module beliebig miteinander verknüpft werden.

Zurzeit existieren die DOIT Module:

DOIT Attributes

Dieses Modul erstellt Attribute anhand vorher einer YAML-Konfiguration definierten Regeln.

DOIT Pictures

Automatische Bildoptimierung und SEO Optimierung von Bildern

DOIT Import

Sehr flexibler Datenimport

DOIT Content

Sehr umfangreiches Modul für die Generierung von Text anhand von definierbaren Bedingungen.

Beispiele:

Generiere einen Text wenn ein Artikel von Hersteller X ist.
Generiere Text wenn das Attribut Y vorhanden ist
Generiere Text wenn das Attribut X existiert und der Wert des Attributs Z ist
Gebe Text aus zu allen im Moment nicht lieferbaren Artikeln
uvm.

DOIT Sitemap (in Entwicklung)

Generiert Google Sitemaps nach individuellen Einstellungen

DOIT Urls (in Entwicklung)

Optimiert Shop Urls und Url Strukturen. Das ist z.B. wichtig für gute Crawlbarkeit, sprechende aussagekräftige Urls, Vermeidung von Duplicate Content, etc.

DOIT Google Merchant (in Entwicklung)

Generierung von optimierten Google Merchant Daten und weitere Automatisierungen.

SEO Explorer (in Entwicklung)

Sehr umfangreiches Modul. Es enthält DOIT Funktionen. Außerdem Keywordrecherche, Keywordverwaltung, Anbindung an Google API`s uvm.

eigene DOIT Module

Sehr gerne entwickeln wir für Sie individuelle DOIT Module die dann in Tasks der anderen DOIT Module integriert werden können! Wenden Sie sich einfach an uns unter +49 89 45455580 oder per Email an info@webtools.de .

Anwendungsbeispiele

Hier ein paar fiktive Beispiele (für die Professional Version). Jedes Task besteht aus einzelnen Steps die in den YAML-Konfigurationsdateien definiert sind.

Task „Artikeldaten Optimierung“ mit den Steps:

Backup Artikeldaten / Attribute
Erstellung von Attributen
Erstellung von Keywords Anhand Artikeldaten und Attributen
Keywordrecherche
Content Backup
Content Erstellung

Task „Attribute erstellen“ mit den Steps:

Backup Attribute
Erstellen Attribute
Content Erstellung (Erweiterung anhand von Attributen)
Content Backup

Task „Datenimport“ mit den Steps:

Backup Artikel-Daten
Download Produktdaten von externer Quelle
Entpacken ZIP-Datei
Öffnen Excel-File und Erstellung von Daten1 Objekten anhand Tabellenblatt 1
Öffnen Excel-File und Erstellung von Daten2 Objekten anhand Tabellenblatt 2
Öffnen Excel-File und Erstellung von Daten3 Objekten anhand Tabellenblatt 3
Import von Artikeln anhand Daten der 3 Daten Objekte
Generierung von Attributen anhand Daten der 3 Daten Objekte
Generierung von sprechenden Artikel Urls
Generierung neuer Google Sitemap
Generierung Google Merchant Daten
Senden Google Merchant Daten
…..

Wenden Sie sich an uns um das Maximale aus Ihrem Shop heraus zu holen.

YAML-Konfigurations-Dateien

Diese Daten liegen im Verzeichnis:

„Shopverzeichnis/source/modules/webtools/doitconfig/modulname“

Für das Modul „doit“ z.B. im Verzeichnis:

„Shopverzeichnis/source/modules/webtools/doitconfig/doit“

Sprachenspezifische Einstellungen in Unterverzeichnissen im jeweiligen Modulverzeichnis:

„Shopverzeichnis/source/modules/webtools/doitconfig/doit/(de/en/..)“

DOIT YAML-Konfigurations-Dateien müssen mit dem Dateinamen-Prefix „doit“ beginnen.

Aufbau der YAML-Konfigurations-Dateien

YAML Dateien sind vergleichbar mit XML Dateien und werden dementsprechend strukturiert aufgebaut.

Jede Datei muss mit „tasks:“ als Root-Position beginnen.

Jede tasks: kann module, globals, form und steps enthalten

tasks:
	module:
	globals:
	form:
	steps:

Jeder Step eines Tasks kann auf Funktionen einer hier definierte Basisklasse zugreifen. Sollte ein Step auf eine Funktion einer anderen Klasse zugreifen sollen, so kann dies im Step definiert werden.

tasks:
  module:
    # ID des Tasks. Darf nur 1 Mal in DOIT verwendet werden
    id: TaskId 
    
    # Name des Tasks (wird in der Drop Down Auswahl angezeigt)
    name: TaskName
    
    # Name der Klasse der Funktion die im Step aufgerufen wird
    classname: Klassenname
    
    # Namespace der Klasse
    namespacename: …\...\Application\Controller\Admin 
    
    # ob Task in Dropdown auswählbar ist
    active: true/false
    
    # kann in aufzurufender Funktionen abgefragt werden
    debug: true 
    
    # generelle Größe des Step-Ticks. Kann im einzelnen Step überschrieben werden
    stepsize: 1000 
    
    # nicht ändern. Steuert den Aufruf des Tasks
    runstart: TaskFormSubmit
    
    # kann in Funktionen abgefragt werden.
    environment: mamppro 
    mysql: /Applications/MAMP/Library/bin/mysql 
    mysqldump: /Applications/MAMP/Library/bin/mysqldumpXML

globals:

Hier können beliebige globale Variablen definiert werden, die in den Steps zur Verfügung stehen.

tasks: 
  globals:
    globaleVariable1:
    globaleVariablex:XML

form:

Für jedes Task kann ein Formular definiert werden, in dem für die Durchführung des Tasks Angaben gemacht werden können.

Wenn z.B. eine Datei hochgeladen werden soll, dann kann ein Datei-Upload Feld definiert werden. Der Dateiupload steht dann in jedem Step zur Verfügung. Gleiches gilt für Checkboxen und beliebige weitere Formulardaten.

Eigene Formulare müssen als „alternative_definition:“ definiert werden.

tasks:
  form:
    # Formular aktiv, erscheint nach Task Auswahl
    active: true 
    # Pflichtfeld
    alternative_definition:
      # eindeutige Id des Formulars
      id: Form1 
      # Name des Formulars
      name: FormName
      # welche Submit Felder angezeigt werdebn sollen
      submits: 
        # eindeutige ID des Submits
        taskformsubmit: 
          # Typ des Submits
          type: submit
          # Submit Aktiv
          active: true 
          # eindeutige Id des Submits
          id: taskformsubmit 
          # Name des Submits
          name: Submit 
          # HTML Value
          value: TaskFormSubmit 
          # CSS Klasse des Submits
          css: btn btn-success mt-3
          # HTML Label
          label: Kategorienbaum Daten generieren
      # Zeilen des Forumlars    
      rows: 
        # Zeile 1 im Formular. Benennung beliebig      
        row01: 
          # Row 1 im Formular. Benennung beliebig
          id: Row1
          # Spalten im Formular
          columns:
            # Column 1 im Formular. Benennung beliebig
            column0:
              # HMTL Id
              id: col0
              # HTML Css
              css: col-md-12
              # HMTL Name
              name: Beschreibung
              # HTML Label
              label: Datenimport
              # HTML Type
              type: text
              # HTML Value
              value: Dieses Modul erzeugt die Kategorienbaum Variablen aus … und importiert sie in den Shop!
            #  
            column02: 
              id: col1
              css: col-md-12
              name: Kategorien löschen
              label: Kategorien löschen
              # HTMl Checkbox
              type: checkbox
              # HTML (checked)
              value: false
              # Daten für die Auswahlliste mit Daten aus einem Array oder 
              # einer Funktion
              data: 
              # Name der Variablen für die Abfrage im Step
              varname: dddeleteXML

Feldtypen

Es können folgende HTML Feldtypen definiert werden:

tasks:
  form:
    alternative_definition:
      rows: 
        row01: 
          columns:
            column0:
              type: input
            column01: 
              type: select
            column02: 
              type: checkbox
            column03: 
              type: file
            column04: 
              type: text
            column05: 
              type: textarea   XML

Beispiele:

HTML “select” aus Variablen Wert oder String

tasks:
  form:
    alternative_definition:
      rows:
        row03:
          id: Row3
          columns:
            column01:
              id: col31
              css: col-md-6
              name: Select Normal with Variable
              label: Select Normal
              type: select
              value: $Variable
              varname: sSelectBox1
            column02:
              id: col32
              css: col-md-6
              name: Select predefined
              label: Select predefined
              type: select
              value: TXT, CSV, EXCEL
              varname: sSelectBox2XML

HTML “checkbox”

tasks:
  form:
    alternative_definition:
      rows:
    row02:
            column02:
                id: col12
                css: col-md-6
                name: NameCheckbox
                label: Name Checkbox
                type: checkbox
                value: true
                varname: bNameCheckBox  XML

HTML “file”

tasks:
  form:
    alternative_definition:
      rows:
    rowx:
          column02:
            id: col1
            css: col-md-12
            name: stockfile
            label: CSV-Datei
            type: file
            varname: stockfile
            required: required XML

HTML “text”

tasks:
  form:
    alternative_definition:
      rows:
        row2:
          id: Row2
          columns:
            column01:
              id: col21
              css: col-md-12
              name: Textinput vordefiniert
              label: Label
              type: input
              value: Textinput vordefiniert
              varname: sTextinputXML

HTML “textarea”

tasks:
  form:
    alternative_definition:
      rows:
        row05:
          id: Row5
          columns:
            column01:
              id: col21
              css: col-md-12
              name: Textarea with FunctionInput
              label: Label
              type: textarea
              # Der Inhalt des Text Areas wird durch die Funktion sayHello() erzeugt
              value: sayHello()XML

value:

Die Inhalte von Auswahllisten und Checkboxen können mit value: vordefiniert werden. Werte können ein String, Array oder Funktionsaufruf sein.

HTML “button”s

tasks:
  form:
    alternative_definition:
      submits:
        taskformsubmit:
          type: submit
          active: true
          id: submit
          name: Submit
          value: TaskFormSubmit
          css: btn btn-success mt-3
          label: starten
        taskformcancel:
          type: button
          active:
          id: cancel1
          name: Cancel
          value: Cancel
          css: btn btn-danger mt-3
          label: cancel
        taskformreset:
          type: reset
          active: true
          id: reset
          name: reset
          value: Reset
          css: btn btn-danger mt-3
          label: resetXML

Es muss ein taskformsubmit: Button definiert sein!

TaskFormData

Die im Formular definierten Felder können über:

$TaskFormData=BaseSession::loadSessionVariable('TaskFormData');

in jedem Step geladen werden.

Beispiel Formular

tasks:
  form:
    active: true
    template:
    alternative_definition:
      id: Form1
      name: FormName
      submits:
        taskformsubmit:
          type: submit
          active: true
          id: submit
          name: Submit
          value: TaskFormSubmit
          css: btn btn-success mt-3
          label: starten
        taskformcancel:
          type: button
          active:
          id: cancel1
          name: Cancel
          value: Cancel
          css: btn btn-danger mt-3
          label: cancel
        taskformreset:
          type: reset
          active: true
          id: reset
          name: reset
          value: Reset
          css: btn btn-danger mt-3
          label: reset
      rows:
        row01:
          id: Row1
          columns:
            column0:
              id: col0
              css: col-md-12
              name: Datenimport Text
              label: Dateimport
              type: text
              value: Dieses Modul import die Daten in den Shop
              varname: sImporttext
            column01:
              id: col11
              css: col-md-6
              name: Google Search Console File
              label: Google Search Console
              type: file
              value: text
              varname: fGoogleSearchConsoleFile
            column02:
              id: col12
              css: col-md-6
              name: NameCheckbox
              label: test Checkbox
              type: checkbox
              value: true
              varname: bNameCheckBox
          row02:
            id: Row2
            columns:
              column01:
                id: col21
                css: col-md-12
                name: Textinput vordefiniert
                label: Label
                type: input
                value: Textinput vordefiniert
                varname: sTextinput
          row03:
            id: Row3
            columns:
              column01:
                id: col31
                css: col-md-6
                name: Select Normal With Variable
                label: Select Normal
                type: select
                data: $sel1
                varname: sSelectBox1
              column02:
                id: col32
                css: col-md-6
                name: Select With Predefined
                label: Select Predefined
                type: select
                data: TXT, CSV, EXCEL
                varname: sSelectBox1
          row04:
            id:
            columns:
              column01:
                id: col31
                css: col-md-12
                name: Beschreibung normal Text
                label: Beschreibung
                type: text
                value: Das ist mein toller Text
          row05:
            id: Row5
            columns:
              column01:
                id: col21
                css: col-md-12
                name: Textarea with FunctionInput
                label: Label
                type: textarea
                value: sayHello()XML

steps:

Die Definitionsmöglichkeiten in Steps sind sehr vielfältig. In einem Step müssen nur die für den Step relevanten Angaben gemacht werden.

Gesamtübersicht aller Definitionsmöglichkeiten

tasks:
  module:
     steps:
        # Step Name
        CategoriesImport:
          # eindeutige Step Id
          id: categoriesimport
          # breche den Task nach der Ausführung dieses Steps ab
          die: true / false
          # kann im Step für debug Ausgaben abgefragt werden
          debug: true / false
          # gebe debugprintvar nach der Durchführung des Steps aus
          debugprint: true / false
          # Name der Session Variable
          debugprintvar: meinevariable 
          # führe nur die ersten 10 Schritte des Steps aus (oft hilfreich 
          # bei Entwicklung)
          debugmax: 10 
          # Step active
          active: true / false
          
          # Datenimport
          # Import Datei hat Kopfzeile?
          hasheader: true 
          # Aufbau der Kopfzeile
          headerline: TREEPOSITION;CATEGORY_ID;DESCRIPTION
          # Trennzeichen in Datei
          separator: semicolon
          
          # Name des Steps
          name: Category Import
          # nicht verändern
          handling: run 
          
          # Datenbankabfrage für Daten wenn benötigt
          # kann sehr hilfreich während der Entwicklung sein.
          query: select * from … 
          
          # mode: Steuert den Aufruf der Haupt-Funktion des Steps
          # function        -> es wird eine Funktion aufgerufen
          # dbtable         -> Funktionsaufruf für jede Zeile eines Datenbank Queries 
          #                    oder einer Tabelle 
          # sessionimport   -> Funktionsaufruf für jede Zeile einer 
                               Session Variable (Array)
          # fileimport      -> Funktionsaufruf für jede Zeile einer Import-Datei
          # fileload2sessionvar -> Lädt Datei direkt in Session-Varibale 
                               OHNE Funktionsaufruf
          # fileimport2file -> Lädt Inhalt eines Excel Blatt und lädt Werte direkt 
                               in Session Varibale und / oder Output Datei
                               OHNE Funktionsaufruf
          mode: function / dbtable / fileimport ...
          # Auswahl der Datenbank Tabelle bei Funktionsausruf dbtable
          dbtable: oxarticles
          # Name der Funktion
          functionname: CategoriesImport
          # Parameter für Funktionsaufruf
          functionparams: myParams 
          # Namespace der Funktion wenn abweichend von globalem Namespace
          namespacename: …\...\meinNamespace 
          # alternative Stepgröße
          stepsize: 25 
          
          # Datenimport
          # siehe modes
          # - fileimport
          # - fileload2sessionvar
          # -fileimport2file
          # Importdatei Name
          inputfile: CATEGORIES.CSV 
          # Import-Datei Pfad
          inputpath: import/…/ 
          # im Moment ohne Funktion 
          inputtype: 
          
          # Dateiausgaben: In jedem Step können mehrere Datein erzeugt werden
          # - outputfile
          # - logfile
          
          # erstelle Datei in unten genanntem Pfad
          fileoutput: true 
          # Name der Datei
          outputfile: CategoriesImport_Result.txt
          # Pfad der Datei
          outputpath: export/…/
          # Ausgabe Typ
          # - object (Serialisierung!)  
          # - keine Angabe (speichere ohne Serialisierung)
          outputtype: object
          # erstelle neues Log-File oder ergänze vorhandenes Log-File
          # - new (erzeuge neues Logfile)
          # - keine Angabe (ergänze Datei)
          logmode: new 
          logfile: CategoriesImport.log
          logpath: log/
          
          # Session Ausgabe
          # Speichere Werte des Steps in SessionVariable (RunOutput)
          sessionoutput: Categories (Name des Variable) 
          # Ausgabe Typ
          # - object (Serialisierung!)  
          # - keine Angabe (speichere ohne Serialisierung)          
          sessionoutputtype: objectXML

Beispiele für Steps

Führe Funktion “setValue” aus.

task:
  steps:
    setValue:
      id: setValue
      active: true
      name: setValue
      handling: run
      mode: function (führe Funktion setValue aus)
      functionname: setValueXML

Datenimport aus Datei.

Importiere die Daten der Datei PRODUCER.CSV, wandle die Daten der Datei um und speichere das Ergebnis als Objekt in AllProducerImport_Result.txt
(Mode: fileimport)

task:
  steps:
    AllProducerImport:
      id: allproducerimport
      active: true
      hasheader: true
      name: all Producers Import
      handling: run
      mode: fileimport
      functionname: AllProducerImport
      namespacename:
      inputfile: PRODUCER.CSV
      inputpath:
      fileoutput: true
      outputfile: AllProducerImport_Result.txt
      outputpath: export/…/
      outputtype: object
      sessionoutput: AllProducers
      logmode: new
      logfile: AllProducerImport.log
      logpath: log/…/
      stepsize: 5000    XML

Update Article2Categories

Führe ein Update in der OXID Shop Article2Categories-Tabelle durch für jede Zeile der zuvor gesetzten SessionVariable „Article2Categories“ (Mode: sessionimport)

task:
  steps:
    updateArticle2Categories:
      id: updateArticle2Categories
      active: true
      name: update Article2Categories
      handling: run
      mode: sessionimport
      sessionvar: Article2Categories
      functionname: updateArticle2Categories

Führe Funktion aus mit dbtable aus

Führe eine Funktion für jede Zeile einer Datenbank Tabelle aus (Mode: dbtable)

task:
  steps:
    stepx:
      id: stepidx
      active: true
      name: Category Content Creator
      handling: run
      mode: dbtable
      functionname: generateCategoryContent
      functionparams: parameter
      dbtable: oxcategories

XLS Import

Lade Daten aus einem Tabellenblatt eines XLS-Files und speichere das Ergebnis in einer Datei (Mode: fileimport2file)

task:
  steps:
    importXLStoOutputFile:
      id: importXLStoOutputFile
      active: true
      name: import XLS to ...
      handling: run
      mode: fileimport2file
      importmode: XlS
      importsheets: Tabellenblatt Name
      sessionvar: ImportFile
      inputfile: Excelfile.xlsx
      inputpath: import//
      fileoutput: true
      outputfile: tabellenblattname.txt
      outputpath: export/

Modes

Jeder Step wird in einem bestimmten Mode durchgeführt. Der Mode bestimmt wie der Step ausgeführt wird.

function

Für jede Zeile des Steps wird eine Funktion aufgerufen

dbtable

Für jede Zeile einer Datenbank Tabelle wird eine Funktion aufgerufen

sessionimport

Für jede Zeile eines Session Variablen Arrays wird eine Funktion aufgerufen

fileimport

Für jede Zeile einer Import-Datei wird eine Funktion aufgerufen. Wenn Header Angaben gemacht wurden werden diese berücksichtigt.

fileload2sessionvar

Lädt Datei direkt in Session-Variable. Es wird keine Funktion aufgerufen!

fileimport2file

Es wird keine Funktion aufgerufen, sondern z.B. der Inhalt eines Blattes eines Excel Files direkt verarbeitet und z.B. in eine Output-Datei und / oder Session Variable geschrieben.

Anwendungsideen:

Um die Ausführung komplexer Tasks (je mehr Steps sie enthalten) möglichst einfach oder in Zwischenschritten zu bewerkstelligen sind ganz einfach Tricks möglich:

Beispiel: Laden großer Datenmengen, Erstellen von Objekten und speichern des Object local und gleichzeitig in Session Variable oData. Anschließend mehrfache Verarbeitung der oData Objekte an verschiedensten Steps oder unterschiedlichen Tasks

task:
  steps:
    Datenimport:
      id: datenimport
      active: true
      name: Datenimport
      handling: run
      mode: fileimport
      functionname: DatenImport
      inputfile: Daten.CSV
      outputfile: oData.txt
      outputtype: object
      sessionoutput: oData
      sessionoutputtype: object

Wenn die Daten nicht in einer Datei gespeichert werden sollen einfach die OutputFile Angaben weglassen.

Anschließend kann erzeugte Datenobject der Session Variable oData an beliebiger Stelle genutzt werden.

task:
  steps:
    updateArticle2Categories:
      id: updateArticle2Categories
      active: true
      name: update Article2Categories
      handling: run
      mode: sessionimport
      sessionvar: oData
      functionname: updateArticle2Categories

Sonderfunktionen

Base::debug

Gibt eine Variable aus:

Base::debug($meineVariable, „Überschrift für Variable“);PHP

Base::debugdie

Gibt eine Variable aus und beendet den Prozess anschließend:

Base::debugdie($meineVariable, „Überschrift für Variable“);PHP

BaseSession::loadSessionVariable

Ähnlich wie die OXID Shop Function “Session->getVariable()”. BaseSession prüft aber ob die Variable in Session vorhanden ist. Wenn nein, dann erfolgt Programm-Abbruch mit Base::debugdie().

Beispiel: load mit eingeschalteter Prüfung ob Variable vorhanden ist:

$Variable=BaseSession::loadSessionVariable('VariablenName');
$Variable=BaseSession::loadSessionVariable('VariablenName', true);PHP

Beispiel: load ohne Prüfung ob Variable vorhanden ist:

$Variable=BaseSession::loadSessionVariable('VariablenName', 'false');PHP

Die Verwendung der BaseSession Funktionen ist sehr zu empfehlen!

Wenn z.B. in einer Funktion Variablen die aus Session Daten initialisiert werden, benutzt werden, diese aber durch das Deaktivieren eines vorherigen Steps nicht initialisiert wurden, kann dies zu fehlerhaften Ergebnissen der Funktion führen da sie mit einer leeren Variable arbeitet.

BaseSession::setSessionVariable

Da DOIT viel mit Session Variablen arbeitet müssen diese auch wieder gelöscht werden, wenn ein Task erfolgreich durchgeführt wurde. Dies wird automatisch durchgeführt, wenn mit BaseSession gearbeitet wird. Andernfalls kann es vorkommen dass der Browsercache voll läuft und die Ausfürhung der DOIT Module fehlerhaft wird.

BaseSession::setSessionVariable('VariablenName', $Variable);PHP

Steptraits

DOIT arbeitet viel mit Session Variablen. Gutes Session Management ist bei der Verwendung von DOIT Modulen essentiell!

Folgende Session Variablen stehen, wenn in der eigenen Klasse mit „use Steptraits“ und die Getter / Setter Methoden in der Step Funktion eingebunden sind, zur Verfügung.

class meineDoItKlasse {
    use StepTraits;

    public function meineFunction ($array) {
        $this->getStepVariables();

  $this->setStepVariables();
  }
}PHP

StepData

Die Variable StepData enthält die Daten des jeweiligen Steps. In der Funktion des Steps kann sie mit $this->StepData ausgegeben werden.

Die Werte der Variable StepData werden beim Abbruch eines Steps durch Base::debugdie angezeigt. Es wird so ein einfacheres Debugging ermöglicht.

RunOutput

Während des Durchlaufens eines Steps können unterhalb des Fortschritts-Balken Informationen ausgegeben werden.

$this->RunOutput.=
  'Articles.CSV Line: ' . $this->StepData->getCnt()
  .' Artikel "' .$oRs->fields['OXARTNUM'] .'" - "'.$oRs->fields['OXTITLE']
  . '" done <b><br>';PHP

LogOutput

Für jeden Step kann ein Logfile erzeugt werden. Dieses wird automatisch mit den Werten der Variable $this->LogOutput gefüllt.

$this->LogOutput.=
  'Articles.CSV Line: '. $this->StepData->getCnt()
  .' Artikel "'.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
  . '" done <b>PHP_EOL;PHP

ResultOutput

Am Ende eines Tasks können die Ergebnisse ausgegeben werden, die während der Ausführung aller Steps erzeugt wurden.

$this->ResultOutput.=
  'Articles.CSV Line: ' . $this->StepData->getCnt()
  .' Artikel "'.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
  . '" done <b><br>';PHP

ResultErrorOutput

Am Ende eines Tasks können die Ergebnisse ausgegeben werden, die während der Ausführung aller Steps erzeugt wurden.

$this->ResultErrorOutput.=
  'Articles.CSV Line: '. $this->StepData->getCnt()
  .' Artikel "'.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
  . '" NOT done. Please check Step !!!<b><br>';PHP

ResultCount

Im Fortschrittsbalken werden die Anzahl der Ergebnisse eines Steps angezeigt.

$this->ResultCount++;PHP

ImportData

Alle Daten die nach dem Step gespeichtert werden sollen, müssen in die Variable ImportData geschrieben werden.

$this->ImportData=$meineErgebnisse;PHP

eigene DOIT Funktionen Beispiele

Beispiel für eine DOIT Klasse mit allen StepTraits Variablen.

class meineDoItKlasse {
    use StepTraits;

    public function myFunction ($array) {
        $this->getStepVariables();

  /* hier steht ihr Code */

  $this->RunOutput.='Articles.CSV Line: '. $this->StepData->getCnt()
    .' Artikel '.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
    . '" done <b><br>';

  $this->LogOutput.='Articles.CSV Line: '. $this->StepData->getCnt()
    .' Artikel '.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
    . '" done <b>PHP_EOL;

   $this->ResultOutput.='Articles.CSV Line: '. $this->StepData->getCnt()
        .' Artikel '.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
        . '" done <b><br>';

  $this->ResultErrorOutput.='Articles.CSV Line: '. $this->StepData->getCnt()
    .' Artikel "'.$oRs->fields['OXARTNUM'].'" - "'.$oRs->fields['OXTITLE']
    . ' NOT done. Please check Step !!!<b><br>';

  $this->ResultCount++;

  $this->ImportData=$myVariable;

  $this->setStepVariables();
  }
}PHP

Beispiel für eine DOIT Klasse mit allen StepTraits Variablen und SessionVariable die in einem Step gefüllt wird.

class meineDoItKlasse {
    use StepTraits;

    public function myFunction ($array) {
        $this->getStepVariables();

  $aMyStepVar =$this->ImportData;

  If ($blILikeDOIT='true') {
    $this->ResultCount++;  
    $ArtNum=$oRs->fields['OXARTNUM'];
    $aMyStepVar[$Artnum]= 'I like DOIT-Modules so much! ';
    
    $this->RunOutput.= $Artnum. ' done<br>';
    $this->LogOutput.= $Artnum. ' done. '. PHP_EOL;
    $this->ResultOutput.= $Artnum. ' done<br>';
  }
  else {
    $this->ResultErrorOutput.= 'somebody else likes DOIT-Modules too! ;-) ';
  }
  
  $this->ImportData= $aMyStepVar;

  $this->setStepVariables();
  }
}PHP

DOIT Module Voraussetzungen

Jedes Modul von WebTools benötigt die Installation des WebTools-Basis Moduls.

Für die Anpassung / Entwicklung von DOIT Funktion oder eigenen DOIT Klassen ist eine DOIT (Workflow) Modul Professional Lizenz erforderlich.

Alle DOIT Module sind mit IonCube verschlüsselt.

DOIT Module Preise

Die DOIT Module sind sehr komplex und kaum zu vergleichen mit “einfachen OXID Modulen”. Für uns steht die Leistungsfähigkeit der Module, die Kosten und Zeit-Ersparnis und der Mehrwert der durch die Module erzeugt wird im Vordergrund.

Deshalb haben alle DOIT Module eine einmalige Lizenzgebühr die die Nutzung des Modules für 1 Jahr includiert. Die Module werden laufend fortentwickelt und deshalb berechnen wir in jedem Folgejahr automatisch eine jährliche Gebühr von 50% der ursprünglichen Lizenzgebühr damit das Modul aktiv bleibt. Soll das Modul nicht mehr genutzt werden senden Sie uns bitte eine Kündigung für das Modul an doit@webtools.de

Fragen zu DOIT Modulen?

Wir freuen uns darauf Sie unterstützen zu dürfen. Gerne erarbeiten wir das für Ihren Shop passende Optimierungskonzept.

Sie erreichen und telefonisch unter +49 89 45455580 oder per E-Mail an doit@webtools.de .

War dieser Artikel hilfreich?