Erläuterung

Dieses Beispiel entspricht der Standard Installations-Auslieferung des EWORK Heftungsscripts FixPageCount in der Version 5.3.1.

Das Skript führt eine feste Heftung durch. Über die Parametrisierung können Sie folgende Funktionen steuern

PageCount
Page Count ist vermutlich der wichtigste Parameter. Er steuert wie viele Seiten fix zu einem Dokument bzw. zu einer Heftung gehören.
Mit andern Worten über die Angabe einer natürlichen Zahl ohne Dezimalstellen, kann angegeben werden nach wie vielen Seiten die Heftung
automatisch durchgeführt wird.

ExecuteUserexits
Der Parameter kann True oder False annehmen. Ist er True, dann werden für alle Felder die UserExits ausgeführt. Seien Sie sich aber
bewusst, dass ein Userexit auch eine Benutzerinteraktion benötigen und die automatische Heftung dadurch unterbrochen
werden kann.

HaltOnError
Der Parameter kann True oder False annehmen. Ist er True, dann wird die Verarbeitung an der Stelle unterbrochen, an der der Fehler
aufgetreten ist. Die zur Zeit des Fehlers in der Verarbeitung befindlichen Dokumente bleiben selektiert. Bei folgendem Fehlverhalten kann ein
Fehler auftreten:

1. Die Userexits haben einen Fehler produziert.
2. Die Heftung konnte nicht durchgeführt werden, weil z.B. Pflichtfelder nicht gefüllt sind.

Ist der Parameter auf False gesetzt werden nachfolgende mögliche Heftungen weiter bearbeitet.

MoveFailedDocsToReserve
Der Parameter kann True oder False annehmen. Ist er True, dann werden die Dokumente die nicht geheftet werden konnten automatisch in die Rückstellungen verschoben. Ist er False verbleiben die Dokumente im Stapel.

PageVisibility
Standardmäßig wird immer die letzte Seite der Heftung angezeigt wenn EWORK wegen einer Unterbrechung stoppt. Dieses Verhalten kann mit dem Parameter geändert werden.
Folgende Werte sind möglich:

1. Last (Default) die letzte Seite wird angezeigt.
2. First die erste Seite der Heftung wird angezeigt

RecognitionFromModus
Standardmäßig werden die Recognitionwerte immer überschrieben somit wird der letzte gültige Wert je Heftung in das zugewiesene Feld übertragen. Folgende Modi gibt es:

1. LAST (Default) Der letzte Wert wird zugewiesen
2. FIRST: Der erste gefundene Wert wird zugewiesen die andren verworfen
3. CUMMULATE: Die Werte werden hintereinander weg geschrieben und mit , voneinander abgetrennt.

Skript

// ==================================================================================
// Name.............: EWORK Heftungsscript - FixPageCount
// ----------------------------------------------------------------------------------
// Company..........: CTO Balzuweit GmbH
// ----------------------------------------------------------------------------------
// Creation.........: 18.07.2011
// Changed..........: 10.05.2019
// ==================================================================================

// ----------------------------------------------------------------------------------
// Die Funktion führt sofern konfiguriert für jedes Feld die Userexits und
// nachfolgende die Heftung aus.                                                     
// ----------------------------------------------------------------------------------
function executeUserExits(HALT_ON_ERROR,fromIndexToIndex):boolean;
var
  i    : Integer;
begin
  result := true;
  for i := 0 to ccFields.Count-1 do
  begin
    try
      ccApplication.ShowStatus('Executing userexits',ccFields.GetDisplayText(i),fromIndexToIndex[3]);
      ccApplication.ExecuteUserexit(i);
    except
      ccApplication.ShowStatus('Executing userexits','Error',fromIndexToIndex[3]);
      if HALT_ON_ERROR then
      begin
        result:=false;
      end;
      exit;
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion berechnet den Fortschritt in Prozentselectiert alle relevante Seiten
// fuer die aktuelle Heftung.
// ----------------------------------------------------------------------------------
function getExecutionStatusInProcent(position,maxCount):Integer;
begin
  if maxCount = 0 then
  begin
    result := 100;
    exit;
  end;
  result := position * 100 / maxCount;
end;

// ----------------------------------------------------------------------------------
// Die Funktion selectiert alle relevante Seiten fuer die aktuelle Heftung
// ----------------------------------------------------------------------------------
function selectPages(BlobList;startIndex;endIndex,SHOW_DOCS):Integer;
var
  selectPageFirst : Boolean;
  i               : Integer;
begin
  result          := 0;
  selectPageFirst := upperCase(ccScriptEngine.GetResource('PageVisibility','Last')) = 'FIRST' ;

  if selectPageFirst = true then
  begin
    for i := endIndex downto startIndex do
    begin
     ccApplication.SelectBlob(BlobList[i],SHOW_DOCS);
     inc(result);
    end;
  end else
  begin
    for i := startIndex to endIndex do
    begin
     ccApplication.SelectBlob(BlobList[i],SHOW_DOCS);
     inc(result);
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion führt die Heftung durch
// ----------------------------------------------------------------------------------
function executeTacks(BlobList,HALT_ON_ERROR, MOVE_FAILED_DOCS_TO_RESERVE,fromIndexToIndex):boolean;
var
   TackNr      : Integer;
   i           : Integer;
   TackId      : String;
   SeparatorId : Variant;
begin
  TackNr := fromIndexToIndex[2];
  TackId := CreateId;
  
  ccApplication.ShowStatus('Creating tack',inttostr(TackNr),fromIndexToIndex[3]);
  
  //SeperatorPage bestimmen
  SeparatorId := BlobList[fromIndexToIndex[1]];
                                                            
  if ccApplication.CreateTack(TackId) = false then
  begin                                                                  
    if HALT_ON_ERROR = True then
    begin                       
      result:=False;
      exit;
    end;    
    if MOVE_FAILED_DOCS_TO_RESERVE = True then
    begin
      //Do it in the reserve area... 
      for i:= fromIndexToIndex[0] to fromIndexToIndex[1] do
        ccApplication.ChangeBlob(BlobList[i],ccQS_OnHold,'');
    end;
  end; 
  
  Result := True;      
end;

// ----------------------------------------------------------------------------------
// Die Funktion führt selektiert alle Dokumente, führt sofern gewünscht die
// Userexits aus und heftet die Dokumente. Dabei wird über den Array fromIndexToIndex
// bestimmt von welchem Dokument zu welchem Dokument geheftet werden soll.     
// ----------------------------------------------------------------------------------
procedure BuildTack(lastRecoResult;Switch_Sep_UserExit_Move_Halt;BlobList;fromIndexToIndex,SHOW_DOCS);
var
  EXECUTE_USER_EXITS           : boolean;
  MOVE_FAILED_DOCS_TO_RESERVE  : boolean;
  HALT_ON_ERROR                : boolean;
  startIndex                   : Integer;
  toIndex                      : Integer;
  countPages                   : Integer;
begin
  EXECUTE_USER_EXITS              := Switch_Sep_UserExit_Move_Halt[0];
  MOVE_FAILED_DOCS_TO_RESERVE     := Switch_Sep_UserExit_Move_Halt[1];
  HALT_ON_ERROR                   := Switch_Sep_UserExit_Move_Halt[2];

  startIndex  :=fromIndexToIndex[0];
  toIndex     :=fromIndexToIndex[1];
  countPages  :=selectPages(BlobList,startIndex, toIndex,SHOW_DOCS);
  if countPages >0 then
  begin
    ccRecognition.FillIndexMask(lastRecoResult);
    if EXECUTE_USER_EXITS = True then
    begin
      if executeUserExits(HALT_ON_ERROR,fromIndexToIndex) = False then
        raise ('exception on execution user exits');
    end;
    if executeTacks(BlobList,HALT_ON_ERROR, MOVE_FAILED_DOCS_TO_RESERVE, fromIndexToIndex) = False then
      raise ('exception on tack execution');
  end

  ccApplication.UnSelectAllBlobs(ccWS_Stack);
  ccApplication.PrepareIndexmask;
end;

// ----------------------------------------------------------------------------------
// Die Funktion geht durch alle Recowerte die erfasst worden sind und gibt beim
// ersten das valide gefüllt wurde den Wert zurück.
// ----------------------------------------------------------------------------------*
function getRecoResult(actualRecoResult):String;
var
  i : Integer;
begin
  result := '';
  for i:=0 to High(actualRecoResult) do
  begin
    if actualRecoResult[i,1] >'' then
    begin
      result := actualRecoResult[i,1];
      exit;
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion Verarbeitet je nach RecoModus der aus den Resourchen gelesen wird
// die Recognitionwerte.
// ----------------------------------------------------------------------------------
function AccumulateRecoResult(RecoModus:Integer;var LastValues, ActualValues: Variant):Variant;
var
  i : Integer;
begin
  for i:=0 to High(ActualValues) do
  begin

    case RecoModus of
    1 :  //Erster Wert
       begin
         if VarToStr(LastValues[i,1]) > '' then
         begin
           continue;
         end else
         begin
           if VarToStr(ActualValues[i,1]) > '' then
           begin
             LastValues[i,1] := ActualValues[i,1];
           end;
         end;
       end;
     2 :  //Letzter Wert
       begin
         if VarToStr(ActualValues[i,1]) > '' then
         begin
           LastValues[i,1] := ActualValues[i,1];
         end;
       end;
     else //Aufsummiert
       begin
          LastValues[i,1] := VarToStr(LastValues[i,1]) + ',' + ActualValues[i,1];
       end;
    end;
	
  end;
  
  Result := LastValues;
end;

// ----------------------------------------------------------------------------------
// Die Funktion gibt den gesetzten Recognition-Modus zurück Last ist Default
// ----------------------------------------------------------------------------------
function getRecognitionModus:Integer;
var
  Modus : String;
begin
  Modus := Uppercase(ccScriptEngine.GetResource('RecognitionFromModus','Last'));
  if Pos('CUMMULATE',Modus) > 0 then
  begin
    Result := 3;
  end else if Pos('FIRST',Modus) > 0 then
  begin
    Result := 1;
  end else
  begin
    Result := 2;
  end;
end;                     

var
  FIX_TACK_COUNT                  : Integer;
  RECOGNITION_MODUS               : Integer;
  EXECUTE_USER_EXITS              : Boolean;
  MOVE_FAILED_DOCS_TO_RESERVE     : Boolean;
  HALT_ON_ERROR                   : Boolean;
  DEBUG                           : Boolean;
  SHOW_DOCS                       : Boolean;
  LASTOBJECT                      : String;
  Switch_Sep_UserExit_Move_Halt   : Variant;
  FromIndexToIndex                : Variant;
  BlobList                        : Variant;
  actualRecoResult                : Variant;
  lastRecoResult                  : Variant;
  ListSize                        : Integer;
  tempRecoResults                 : Variant;
  tempDocCount                    : Integer;
  tempRecoResult                  : String;
  i                               : Integer;
  moveMode                        : Boolean;
  hasTempRecoResult               : Boolean;

begin
  //Anzahl Seiten nach der eine Heftung erfolgen soll
  FIX_TACK_COUNT               := ccScriptEngine.GetResource('PageCount',3);
  EXECUTE_USER_EXITS           := ccScriptEngine.GetResource('ExecuteUserexits',True);
  MOVE_FAILED_DOCS_TO_RESERVE  := ccScriptEngine.GetResource('MoveFailedDocsToReserve',False);
  HALT_ON_ERROR                := ccScriptEngine.GetResource('HaltOnError',False);
  DEBUG                        := ccScriptEngine.GetResource('Debug',True);
  LASTOBJECT                   := ccScriptEngine.GetResource('PageVisibility','Last');
  RECOGNITION_MODUS            := getRecognitionModus();
  SHOW_DOCS                    := VarToBoolean(ccScriptEngine.GetResource('Silent',False) = False);

  if DEBUG = True then
  begin
    showMessage('FixPageCount v2.0 - Parameter: PageVisibility=' + LASTOBJECT + ', ExecuteUserExits=' + VarToStr(EXECUTE_USER_EXITS) + ', MoveFailedDocs=' + VarToStr(MOVE_FAILED_DOCS_TO_RESERVE) +', FixCount='+intToStr(FIX_TACK_COUNT)+', HaltOnError='+VarToStr(HALT_ON_ERROR));
  end;

  Switch_Sep_UserExit_Move_Halt  := [ EXECUTE_USER_EXITS ,MOVE_FAILED_DOCS_TO_RESERVE ,HALT_ON_ERROR  ];
  fromIndexToIndex := [-1,-1,0,0]; //HeftungVonPage,HeftungToPage,Akt. HeftungNr, VerlaufInProzent

  try
    ccApplication.ShowStatus('Tacking','Initialize',0);
    ccApplication.UnSelectAllBlobs(ccWS_Stack);

    if ccScriptEngine.Application = 'EWORKBATCH' then
      ccApplication.PrepareIndexmask;

    //Liste aufbauen mit allen Blobs
    BlobList := ccApplication.GetBlobList(ccWS_Stack,false,'');

    //Anzahl Scans ermitteln
    ListSize := VarArrayHighBound(BlobList,1);

    //Verarbeiten nur wenn es Dokumente gibt.
    if ListSize >= 0 then
    begin
      fromIndexToIndex[0] := 0;
      tempDocCount        :=1;
      tempRecoResult      :='';
      moveMode            := false;
      hasTempRecoResult   := false;
  
      // Gehe durch alle Blobs
      for i:=0 to ListSize do
      begin
        //***************** Fortschritt ermitteln ******************
        fromIndexToIndex[3] := getExecutionStatusInProcent(i,ListSize);
  
        //***************** Führe für Seite I die Recognition durch ******************
        tempRecoResults := ccRecognition.Execute(BlobList[i]);


        tempRecoResult  := getRecoResult(tempRecoResults);

        if hasTempRecoResult = true then
        begin
          actualRecoResult:= AccumulateRecoResult(RECOGNITION_MODUS, actualRecoResult, tempRecoResults)
        end;


        if (tempRecoResult > '') and (hasTempRecoResult = false) then
        begin
          actualRecoResult := tempRecoResults;
          hasTempRecoResult:= true;
        end;


        if (moveMode = false) and (tempDocCount = FIX_TACK_COUNT) then
        begin
          fromIndexToIndex[1] := i;
          try
            if not hasTempRecoResult then
            begin
              actualRecoResult := tempRecoResults;
            end;
            fromIndexToIndex[2]:= fromIndexToIndex[2] +1; //Seitenzähler
            BuildTack(actualRecoResult,Switch_Sep_UserExit_Move_Halt,BlobList,fromIndexToIndex,SHOW_DOCS);
            hasTempRecoResult := false;
          except
            exit;
          end;
		  
          //Wenn die Anzahl bis zur letzten Seite nicht mehr der Anzahl der Heftung entspricht und in die Rückstellung verschoben werden soll
          //dann leg den Schalter um
          if ((ListSize - fromIndexToIndex[1]) < FIX_TACK_COUNT) AND (MOVE_FAILED_DOCS_TO_RESERVE = True) then
            moveMode := True;

          tempDocCount        := 0;
          fromIndexToIndex[0] := i+1;
        end
        else if moveMode = True then
        begin
          ccApplication.ChangeBlob(BlobList[i],ccQS_OnHold,'');
        end;
        inc(tempDocCount);

        // ------- Prüfung ob ESC gedrückt worden ist -------------------------------
        If ccRecognition.Stop Then
        Begin
          ccApplication.ShowStatus('User has stopped the execution (ESC)','Exit...',0);
          Exit;
        End;
      end;
      ccApplication.UnSelectAllBlobs(ccWS_Stack);
    end;
  finally
    ccApplication.CloseStatus;
  end;
end;

Browser nicht unterstützt