MSH

Text101@1101908001 : TextConst 'ENU=Do you want to move all connected
entries?';
Text102@1101908003 : TextConst 'ENU=It was not possible to plan activities.';
ServLaborApplicationGlobTmp@1101901003 : TEMPORARY Record 25006277;
ServiceLine@1101908004 : TEMPORARY Record 25006146;
ReasonCodeGlobal@1190006 : Code[20];
SplitTracking@1101908005 : 'No,Yes,Undef';
Text103@1101908007 : TextConst 'ENU=Replan all entries after this event?';
AllocationStatus@1000 : 'Pending,In Process,Finished,On Hold';
AllocationStatusAction@1101904015 : 'Pending,In Process,Finish All,Finish
Part,On Hold';
ScheduleAction@1101908043 : 'Planning,Time Registration';
DoServiceSpliting@1101908009 : Boolean;
ChangeAllocationStatus@1101908011 : Boolean;
Text106@1101908014 : TextConst 'ENU=You have to finish labor in progress: %1
%2!';
Text107@1101908015 : TextConst 'ENU=Resource %1 have to start work time
first.';
Text108@1101908016 : TextConst 'ENU=You can start only service labors.';
Text112@1101908020 : TextConst 'ENU=Wrong password.';

Text113@1101908021 : TextConst 'ENU=You are not allowed to work now.';
Text114@1101908022 : TextConst 'ENU=You cannot deallocate. One or more
connected entries has status %1.';
Text115@1101908010 : TextConst 'ENU=You can not post Service Line %1. Because
there are unfinished Service Shedule entries.';
Text116@1101908024 : TextConst 'ENU=You cannot delete this service, because
there is finished service allocation.';
Text117@1101908027 : TextConst 'ENU=Do you want delete service entries in
schedule, too?';
Text118@1101908028 : TextConst 'ENU=You cannot delete service, because there
are entris in schedule.';
Text119@1101908013 : TextConst 'ENU=Resource %1 has not started worktime.';
Text120@1101908023 : TextConst 'ENU=Resource %1 has already started
worktime.';
Text121@1101908029 : TextConst 'ENU=No Serv. Labor Allocation Entries are
selected. Please select the entry.';
Text122@1101908030 : TextConst 'ENU=Labor sequence will be wrong. Do you want
continue?';
Text123@1101908031 : TextConst 'ENU=You can not split entry which has
status : %1!';
Text124@1101908032 : TextConst 'ENU=The process is canceled.';
Text125@1101908033 : TextConst 'ENU=Resource %1 has no such skills: %2! Do
you want continue?';
Text126@1101908034 : TextConst 'ENU=Do you want to clear remaining allocation
parts?';
AlreadyAskedAboutSkills@1101908035 : Boolean;
AlreadyAskedAboutSequence@1101908041 : Boolean;
StatusChanged@1101908036 : Boolean;
AskedForAllocationSpliting@1101908037 : Boolean;
Text127@1101908038 : TextConst 'ENU=Scheduled allocation does not fit into
today''s (%1) remaining available time. Do you want to move the remaining part (%2
hours) to the next avaiable working time?';
Text128@1101908040 : TextConst 'ENU=You don''t have rights to perform this
action.';
Text129@1101908042 : TextConst 'ENU=Do You want finish all started labors?';
Text130@1101908044 : TextConst 'ENU=One or more connected entries has status
%1. Do you want continue?';
Text131@1101908045 : TextConst 'ENU=One or more line has already been
scheduled for service %1 %2. Are you sure to continue?';
Text132@1101908046 : TextConst 'ENU=Service %1 %2 has already been scheduled
as a whole. Are you sure to continue?';
Text133@1101908047 : TextConst 'ENU=You can only select lines from one
document.';
Text134@1101908048 : TextConst 'ENU=You cannot spilt this entry. This is
whole order entry.';
Text135@1101908049 : TextConst 'ENU=Working on simultaneous tasks is not
allowed.';
Text136@1190004 : TextConst 'ENU=This labor is already planed for other
resource.';
Text137@1190005 : TextConst 'ENU=This labor %1 is already planed for other
resource. Do You want to split it?';
Text138@1190007 : TextConst 'ENU=You can change only finished service
allocation entry';
GlobDontModifyServLine@1190008 : Boolean;
Text139@1190009 : TextConst 'ENU=The process is canceled. \Available
resources: %1.';
Text140@1190010 : TextConst 'ENU=No allocation found for this document.';
Text141@1190011 : TextConst 'ENU=You can not post Service Header %1. Because
there are unfinished Service Shedule entries.';
Text142@1190012 : TextConst 'ENU=You are not allow to plan this service
document allocation method.';
Text143@1190013 : TextConst 'ENU=You can register only Service Line.';
Text144@1190014 : TextConst 'ENU=Labor %1 is not Call-out labor.';
DontChangeServiceStatus@1190015 : Boolean;
LaborAllocAppType@1101904000 : ' ,Service Document,Standard Event,Service
Line';
Text145@1101904001 : TextConst 'ENU=Would you like to remove resource from
lines as well?';
Text146@1101904004 : TextConst 'ENU=Please add/remove resources in Service
Schedule.';
Text147@1101904003 : TextConst 'ENU=Would you like to remove document
allocations?';
Text148@1101904005 : TextConst 'ENU=Resources for document must be entered
via table.';
SLAEfilterDataset@1101904006 : Record 25006271;
isUserRightsChecked@1101904007 : Boolean;
isOperAllowedChecked@1101904008 : Boolean;
OperationMainCode@1101904009 : Integer;
UserRightsAllowed@1101904010 : Boolean;
OperAllowed@1101904011 : Boolean;
Text150@1101904012 : TextConst 'ENU=Operation has stoped.';
Text160@1101904013 : TextConst 'ENU=It is not allowed move entry outside from
a resource.';
LaborAllocEntryPrevStatus@1101901001 : Integer;
ErrorStatus@1002 : 'Null,Error,ErrorNeedRefresh';
ErrorMsgText@1001 : Text[1024];
Text161@1004 : TextConst 'ENU=Do You want to cancel started labor?';
Text162@1003 : TextConst 'ENU=You can only cancel labor that is in
progress!';
Text163@25006001 : TextConst 'ENU=You can''t finish working day while there
is labors on hold.';
PROCEDURE FillAllocEntryBuffer@1190003(VAR TempLaborAllocEntry@1190000 :

TEMPORARY Record 25006271;ResourceNo@1190004 : Code[20];StartingDateTime@1190001 :
Decimal;EndingDateTime@1190002 : Decimal);
VAR
LaborAllocEntry@1190003 : Record 25006271;
BEGIN
LaborAllocEntry.RESET;
LaborAllocEntry.SETCURRENTKEY("Resource No.","Start Date-Time","End Date-
Time");
LaborAllocEntry.SETRANGE("Resource No.",ResourceNo);
LaborAllocEntry.SETFILTER("Start Date-Time",'<=%1',EndingDateTime);
LaborAllocEntry.SETFILTER("End Date-Time",'>%1',StartingDateTime);
IF LaborAllocEntry.FINDFIRST THEN
REPEAT
TempLaborAllocEntry := LaborAllocEntry;
TempLaborAllocEntry.INSERT;
UNTIL LaborAllocEntry.NEXT = 0;
END;
PROCEDURE BufferContainsSelectedEntry@1190005(VAR TempLaborAllocEntry@1190000 :

TEMPORARY Record 25006271) : Boolean;
BEGIN
IF TempLaborAllocEntry.FINDFIRST THEN
REPEAT
IF TempLaborAllocEntry."Entry No." = SingleInstanceMgt.GetAllocationEntryNo
THEN
EXIT(TRUE);
UNTIL TempLaborAllocEntry.NEXT=0;
EXIT(FALSE)
END;
PROCEDURE GetMatrixCellValue@1190000(ResourceNo@1190002 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190000 :
Decimal;CellType@1190005 : 'Allocation,Capacity,Availability') CellValueText :
Text[250];
VAR
TempLaborAllocEntry@1190003 : TEMPORARY Record 25006271;
ServiceHour@1190006 : Record 25006129;
RecordCount@1190004 : Integer;
BEGIN
ServiceScheduleSetup.GET;
IF CellType IN [CellType::Allocation, CellType::Availability] THEN
FillAllocEntryBuffer(TempLaborAllocEntry,ResourceNo,StartingDateTime,EndingDateTime
);
IF CellType = CellType::Allocation THEN BEGIN

RecordCount := TempLaborAllocEntry.COUNT;
IF RecordCount > 1 THEN
CellValueText := '(' + FORMAT(RecordCount) + ') ';
IF BufferContainsSelectedEntry(TempLaborAllocEntry) THEN
CellValueText := COPYSTR(CellValueText +
GetAllocRecDescr(TempLaborAllocEntry), 1, 250)
ELSE
BEGIN
RecordCount := 0;
TempLaborAllocEntry.RESET;
REPEAT
RecordCount += 1;
IF RecordCount > 1 THEN
CellValueText := COPYSTR(CellValueText + '; ', 1, 250);
CellValueText := COPYSTR(CellValueText +
GetAllocRecDescr(TempLaborAllocEntry), 1, 250);
UNTIL (TempLaborAllocEntry.NEXT = 0) OR (RecordCount=3)
ELSE BEGIN
IF ServiceScheduleSetup."Show Unavailable Time" THEN
IF NOT GetTimeAvailable(ResourceNo, StartingDateTime,EndingDateTime)
THEN
CellValueText := Text001;
END;
END;
END;
IF CellType IN [CellType::Capacity, CellType::Availability] THEN BEGIN
IF CellType = CellType::Capacity THEN
CellValueText := FORMAT(ROUND(GetCapacity(ResourceNo, StartingDateTime,
EndingDateTime), 0.01)) + ' h'
ELSE
CellValueText := FORMAT(ROUND(GetCapacity(ResourceNo, StartingDateTime,
EndingDateTime) -
GetNotAvailabilityTime(TempLaborAllocEntry,
StartingDateTime, EndingDateTime), 0.01)) + ' h';
END;
EXIT;
END;
PROCEDURE GetMatrixGroupCellValue@1190021(VAR ResourceCodeBuffer@1190002 :

TEMPORARY Record 25006270;StartingDateTime@1190001 : Decimal;EndingDateTime@1190000
: Decimal;CellType@1190010 : 'Allocation,Capacity,Availability') CellValueText :
Text[250];
VAR
AllocatedHours@1190005 : Decimal;
StartingDateTime1@1190009 : Decimal;
EndingDateTime1@1190008 : Decimal;
GroupCode@1190006 : Code[20];
ResourceCodeBufferFilter@1190007 : TEMPORARY Record 25006270;
CapacityHours@1190011 : Decimal;
BEGIN
AllocatedHours := 0;
GroupCode := ResourceCodeBuffer.Code;
ResourceCodeBufferFilter.COPY(ResourceCodeBuffer);
ResourceCodeBuffer.RESET;
IF ResourceCodeBuffer.FINDFIRST THEN
REPEAT
IF ResourceCodeBuffer."Applies-to Code" = GroupCode THEN BEGIN
TempLaborAllocEntry.DELETEALL;
IF CellType IN [CellType::Allocation, CellType::Availability] THEN BEGIN
FillAllocEntryBuffer(TempLaborAllocEntry,ResourceCodeBuffer.Code,StartingDateTime,E
ndingDateTime);
AllocatedHours += GetNotAvailabilityTime(TempLaborAllocEntry,
StartingDateTime, EndingDateTime);
END;
IF CellType IN [CellType::Availability, CellType::Capacity] THEN
CapacityHours +=
GetCapacity(ResourceCodeBuffer.Code,StartingDateTime,EndingDateTime);
END;
UNTIL ResourceCodeBuffer.NEXT = 0;
ResourceCodeBuffer.COPY(ResourceCodeBufferFilter);
CASE CellType OF
CellType::Allocation:
BEGIN
CellValueText := FORMAT(ROUND(AllocatedHours,0.01)) + ' h';
//Temporary solution
IF AllocatedHours = 0 THEN
CellValueText := '';
END;
CellType::Capacity:
CellValueText := FORMAT(ROUND(CapacityHours, 0.01)) + ' h';
CellType::Availability:
IF CapacityHours - AllocatedHours < 0 THEN
CellValueText := FORMAT(0) + ' h'
ELSE
CellValueText := FORMAT(ROUND(CapacityHours - AllocatedHours,0.01)) + '
h';
END;
EXIT;
END;
PROCEDURE GetMatrixCellFormat@1190007(ResourceNo@1190002 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190000 : Decimal;VAR
Bold@1190005 : Boolean;VAR ForeColor@1190006 : Integer) CellValueText : Text[250];
VAR
BEGIN
);
SetCellFormat(TempLaborAllocEntry, Bold, ForeColor);

END;
PROCEDURE SetCellFormat@1101908034(VAR TempLaborAllocEntry@1101908000 :

TEMPORARY Record 25006271;VAR Bold@1101908001 : Boolean;VAR ForeColor@1101908002 :
Integer);
VAR
ColorConfig@1101908003 : Record 25006281;
ServiceHdr@1101908007 : Record 25006145;
ServCount@1101908004 : Integer;
RecCount@1101908005 : Integer;
StandardCount@1101908006 : Integer;
BEGIN
ColorConfig.RESET;
RecCount := TempLaborAllocEntry.COUNT;
IF RecCount = 0 THEN
EXIT;
IF BufferContainsSelectedEntry(TempLaborAllocEntry) THEN
ColorConfig.SETRANGE("Active Allocation", TRUE)
ELSE
ColorConfig.SETRANGE("Active Allocation", FALSE);
IF RecCount > 1 THEN BEGIN
ColorConfig.SETRANGE("Mixed Allocation", TRUE);
IF ColorConfig.FINDFIRST THEN BEGIN
Bold := ColorConfig."Font Bold";
ForeColor := ColorConfig."Font Color";
EXIT;
END;
ColorConfig.SETRANGE("Mixed Allocation", FALSE);
END ELSE
ColorConfig.SETRANGE("Mixed Allocation", FALSE);
IF NOT TempLaborAllocEntry.GET(SingleInstanceMgt.GetAllocationEntryNo) THEN

TempLaborAllocEntry.FINDFIRST;
ColorConfig.SETRANGE("Source Type", TempLaborAllocEntry."Source Type");

ColorConfig.SETRANGE("Source Subtype", TempLaborAllocEntry."Source Subtype");
IF ServiceHdr.GET(TempLaborAllocEntry."Source Subtype",
TempLaborAllocEntry."Source ID") THEN;
ColorConfig.SETFILTER("Work Status", '%1|''''', ServiceHdr."Work Status
Code");
ColorConfig.SETRANGE(Status, TempLaborAllocEntry.Status);
//DELTA BCH 27/01/2021
ColorConfig.SETRANGE(PDI, ServiceHdr.PDI);
//DELTA BCH 27/01/2021
IF ColorConfig.FINDLAST THEN BEGIN
Bold := ColorConfig."Font Bold";
END;
END;
PROCEDURE SetCellFormatRTC@1101904002(VAR LaborAllocEntry@1101904002 : Record

25006271;VAR ForeColor@1101908002 : Integer;VAR BackColor@1101904001 : Integer);
VAR
ServiceHeader@1101908007 : Record 25006145;
ServLaborAllocationApplication@25006000 : Record 25006277;
PostedServiceHeader@25006001 : Record 25006149;
PostedServRetOrderHeader@25006002 : Record 25006154;
CurrDateTime@25006003 : Decimal;
BEGIN
IF LaborAllocEntry."Allocation Status" = LaborAllocEntry."Allocation
Status"::Unavailability THEN BEGIN
ForeColor := 0; //Black
BackColor := 16777215; //White
EXIT;
END;
ColorConfig.RESET;
//ColorConfig.SETRANGE("Active Allocation", FALSE);
//ColorConfig.SETRANGE("Mixed Allocation", FALSE);
ColorConfig.SETRANGE("Source Type", LaborAllocEntry."Source Type");

ColorConfig.SETRANGE("Source Subtype", LaborAllocEntry."Source Subtype");
IF LaborAllocEntry."Source Type" = LaborAllocEntry."Source Type"::"Service
Document" THEN BEGIN
IF (NOT ServiceHeader.GET(LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID")) AND
(NOT PostedServiceHeader.GET(LaborAllocEntry."Source ID"))THEN
EXIT;
IF LaborAllocEntry."Source Subtype" = LaborAllocEntry."Source
Subtype"::Order THEN BEGIN
//ServLaborAllocationApplication.RESET;
//ServLaborAllocationApplication.SETRANGE("Document
Type",ServLaborAllocationApplication."Document Type"::Order);
//ServLaborAllocationApplication.SETRANGE(Posted,TRUE);
//IF ServLaborAllocationApplication.FINDFIRST THEN
// ColorConfig.SETRANGE("Source Subtype", ColorConfig."Source
Subtype"::"Posted Order");
IF PostedServiceHeader.GET(LaborAllocEntry."Source ID") THEN
ColorConfig.SETRANGE("Source Subtype", ColorConfig."Source
Subtype"::"Posted Order");
END;
IF LaborAllocEntry."Source Subtype" = LaborAllocEntry."Source
Subtype"::"Return Order" THEN BEGIN
IF PostedServRetOrderHeader.GET(LaborAllocEntry."Source ID") THEN
Subtype"::"Posted Return Order");
END;
END;
ColorConfig.SETFILTER("Work Status", '%1|''''', ServiceHeader."Work Status

Code");
//DELTA BCH 27/01/2021
ColorConfig.SETRANGE(PDI, ServiceHeader.PDI);
//DELTA BCH 27/01/2021
ColorConfig.SETRANGE(Status, LaborAllocEntry.Status);

BackColor := ColorConfig."Background Color";
END;
CurrDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

IF (LaborAllocEntry."Start Date-Time" < CurrDateTime) AND
((LaborAllocEntry.Status = LaborAllocEntry.Status::Pending) OR
(LaborAllocEntry.Status = LaborAllocEntry.Status::"On Hold")) THEN
IF ColorConfig."Allocation Delay Color" <> 0 THEN
BackColor := ColorConfig."Allocation Delay Color";
IF (CurrDateTime > LaborAllocEntry."End Date-Time") AND

(LaborAllocEntry.Status = LaborAllocEntry.Status::"In Progress") THEN
IF ColorConfig."Allocation Delay Color" <> 0 THEN
BackColor := ColorConfig."Allocation Delay Color";
END;
PROCEDURE SetCellFormatRTCRent@10(VAR RentAvailabilityBufferTmp@1000 : Record

25006631;VAR ForeColor@1101908002 : Integer;VAR BackColor@1101904001 : Integer);
VAR
ServLaborAllocationApplication@25006000 : Record 25006277;
PostedServiceHeader@25006001 : Record 25006149;
PostedServRetOrderHeader@25006002 : Record 25006154;
BEGIN
ColorConfig.RESET;
ColorConfig.SETRANGE("Source Type", ColorConfig."Source Type"::Rent);

IF RentAvailabilityBufferTmp."Rent Document No." <> '' THEN BEGIN
CASE RentAvailabilityBufferTmp."Rent Document Type" OF
RentAvailabilityBufferTmp."Rent Document Type"::Order:
BEGIN
Subtype"::Order);
//Add subtype
CASE RentAvailabilityBufferTmp.Type OF
RentAvailabilityBufferTmp.Type::Reserved:
ColorConfig.SETRANGE("Rent Order Subtype",ColorConfig."Rent Order
Subtype"::Planned);
RentAvailabilityBufferTmp.Type::Rented:
Subtype"::Shipped);
RentAvailabilityBufferTmp.Type::Recieved:
Subtype"::Received);
END;
END;
RentAvailabilityBufferTmp."Rent Document Type"::Quote:
Subtype"::Quote);
RentAvailabilityBufferTmp."Rent Document Type"::"Return Order":
Subtype"::"Return Order");
END;
END;
IF RentAvailabilityBufferTmp."Service Order No." <> '' THEN BEGIN
Subtype"::Service);
END;

BackColor := ColorConfig."Background Color";
END;
END;
PROCEDURE SetResourceColor@1101908033(ResourceNo@1101908001 : Code[20];VAR

ForeColor@1101908002 : Integer);
VAR
WorkTimeEntry@1101908003 : Record 25006276;
BEGIN
WorkTimeEntry.RESET;
WorkTimeEntry.SETCURRENTKEY("Resource No.",Closed);
WorkTimeEntry.SETRANGE("Resource No.", ResourceNo);
WorkTimeEntry.SETRANGE(Closed,FALSE);
IF WorkTimeEntry.FINDFIRST THEN
ForeColor := ServiceScheduleSetup."Working Resource Color"
ELSE
ForeColor := ServiceScheduleSetup."Non-Working Resource Color";
END;
PROCEDURE SetDateColor@1190001(DateFilter@1101908001 : Date;VAR

ForeColor@1101908002 : Integer;VAR UpdateBold@1190001 : Boolean);
VAR
CheckDescription@1190000 : Text[50];
Day@1101901000 : Integer;
BEGIN
Day := DATE2DWY(DateFilter,1) - 1;
ServiceHour.RESET;
ServiceHour.SETRANGE(Day,Day);
IF NOT ServiceHour.FINDFIRST THEN BEGIN
//ForeColor := ServiceScheduleSetup."Nonworking Day Color";
UpdateBold := TRUE;
END;
END;
PROCEDURE GetAllocRecDescr@1190018(VAR LaborAllocEntry@1190000 : Record

25006271) RecordDesr : Text[250];
BEGIN
IF LaborAllocEntry."Entry No." <> 0 THEN
RecordDesr := COPYSTR(CreateFieldText(LaborAllocEntry."Entry No."), 1,
250);
IF RecordDesr = '' THEN

RecordDesr := LaborAllocEntry."Source ID";
END;
PROCEDURE SelectAllocation@1190004(ResourceNo@1190002 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190000 : Decimal);
VAR
BEGIN
IF NOT CheckUserRightsAdv(1, TempLaborAllocEntry) THEN EXIT;
ScheduleAction := ScheduleAction::Planning;
);
RecordCount := TempLaborAllocEntry.COUNT;
IF RecordCount = 0 THEN
EXIT;
IF RecordCount = 1 THEN BEGIN

TempLaborAllocEntry.FINDFIRST;
SelectAllocationEntry(TempLaborAllocEntry."Entry No.")
END ELSE //RecordCount > 1
IF PAGE.RUNMODAL(PAGE::"Serv. Labor Allocation
Entries",TempLaborAllocEntry) = ACTION::LookupOK THEN
SelectAllocationEntry(TempLaborAllocEntry."Entry No.");
END;
PROCEDURE Deallocate@1190006(EntryNo@1101904000 : Integer);

VAR
LaborAllocEntryLoc@1101908001 : Record 25006271;
BEGIN
//EntryNo := SingleInstanceMgt.GetAllocationEntryNo;
IF NOT LaborAllocEntryLoc.GET(EntryNo) THEN BEGIN

MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(2, LaborAllocEntryLoc) THEN EXIT;
IF LaborAllocEntryLoc.Status IN [LaborAllocEntryLoc.Status::"In Progress",

LaborAllocEntryLoc.Status::Finished] THEN
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,EntryNo, 11111)
ELSE BEGIN
IF SplitAllocTracking(EntryNo, 1) THEN
DeallocateIncSplit(EntryNo, TRUE)
ELSE
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,EntryNo, 11111)
END;
END;
PROCEDURE DeallocateIncSplit@1101908009(EntryNo@1101908000 :
Integer;DeleteAll@1101908004 : Boolean);
VAR
LaborAllocEntryTemp@1101908001 : TEMPORARY Record 25006271;
LaborEntry@1101908003 : Integer;
ReplanOtherEntries@1101908002 : Boolean;
ProceedMode@1101904000 : Integer;
BEGIN
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 0); //15.08.2013 EDMS P8
LaborAllocEntryTemp.RESET;
LaborAllocEntryTemp.SETCURRENTKEY("Resource No.", "End Date-Time");
IF LaborAllocEntryTemp.FINDFIRST THEN BEGIN

REPEAT
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,
LaborAllocEntryTemp."Entry No.", 10000)
UNTIL LaborAllocEntryTemp.NEXT =0;
LaborAllocEntryTemp.FINDLAST;
REPEAT
ProceedMode := 1110;
IF LaborAllocEntryTemp.COUNT = 1 THEN
ProceedMode := 1111;
IF DeleteAll THEN BEGIN
LaborAllocEntryTemp."Entry No.", ProceedMode)
END ELSE
IF LaborAllocEntryTemp."Entry No." <> EntryNo THEN
LaborAllocEntryTemp."Entry No.", ProceedMode);
UNTIL LaborAllocEntryTemp.NEXT(-1) =0;
END;
END;
PROCEDURE MoveAllocation@1190014(EntryNo@1101904000 :
Integer;NewResourceNo@1190003 : Code[20];NewStartingDateTime@1190002 : Decimal);
VAR
ServiceLine@1101908000 : TEMPORARY Record 25006146;
ServiceLine2@1190001 : Record 25006146;
LaborAllocAppTemp@1190004 : TEMPORARY Record 25006277;
AllocationForm@1000 : Page 25006369;
BEGIN
CLEAR(AllocationForm);
IF NOT LaborAllocEntry.GET(EntryNo) THEN BEGIN
MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(300, LaborAllocEntry) THEN EXIT;
AllocationForm.SetParam(EntryNo,NewResourceNo,NewStartingDateTime,LaborAllocEntry."
Quantity (Hours)",
LaborAllocEntry."Source Type",LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID",1, ServiceLine,0);
AllocationForm.LOOKUPMODE(TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
AllocationForm.RUNMODAL;
END;
PROCEDURE StartEndAllocation@1101908002(AllocationStatus1@1101908002 :
'Pending,In Progress,Finish All,Finish Part,On Hold');
VAR
HoldHours@1101908003 : Decimal;
StartFinishAllocation@1000 : Page 25006355;
BEGIN
CLEAR(StartFinishAllocation);
IF NOT LaborAllocEntry.GET(SingleInstanceMgt.GetAllocationEntryNo) THEN BEGIN
MESSAGE(Text121);
EXIT;
END;
IF AllocationStatus1 = AllocationStatus1::"In Progress" THEN BEGIN

IF LaborAllocEntry.Status = LaborAllocEntry.Status::Finished THEN
ERROR(Text109);
IF LaborAllocEntry.Status = LaborAllocEntry.Status::"In Progress" THEN
ERROR(Text110);
END;
IF AllocationStatus1 IN [AllocationStatus1::"Finish All",

AllocationStatus1::"Finish Part", AllocationStatus1::"On Hold"] THEN
BEGIN
IF LaborAllocEntry.Status <> LaborAllocEntry.Status::"In Progress" THEN
ERROR(Text111);
END;
StartFinishAllocation.SetParam(LaborAllocEntry."Resource
No.",CurrDateTime,LaborAllocEntry."Quantity (Hours)",
LaborAllocEntry."Source
Type",LaborAllocEntry."Source Subtype",LaborAllocEntry."Source ID",
AllocationStatus1, HoldHours);
StartFinishAllocation.LOOKUPMODE(TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
//BABEIGT, notesteet ==>

IF StartFinishAllocation.RUNMODAL = ACTION::LookupOK THEN BEGIN
ResourceTimeRegMgt.AddTimeRegEntries('START',LaborAllocEntry,LaborAllocEntry."Resou
rce No.",WORKDATE,TIME);
END;
END;
PROCEDURE StartEndWorktime@1101908046(ResourceNo@1101908000 :
Code[20];Status@1101908001 : 'Start,End');
VAR
WorktimeRegistration@1000 : Page 25006353;
PageAction@1000000000 : Action;
BEGIN

CLEAR(WorktimeRegistration);
WorktimeRegistration.SetParam(ResourceNo, CurrDateTime, Status);
WorktimeRegistration.LOOKUPMODE(TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
WorktimeRegistration.RUNMODAL;
END;
PROCEDURE CalcEndDTOnlyWorktime@1000000000(StartDT@1000000001 :
Decimal;EndDT@1000000000 : Decimal;NewResNo@1000000007 : Code[20]) RetValue :
Decimal;
VAR
DateRec@1000000003 : Record 2000000007;
UnavailAllocEntry@1000000002 : TEMPORARY Record 25006271;
DateTimeMgt@1000000004 : Codeunit 25006012;
CurrDT@1000000005 : Decimal;
NewCurrDT@1000000006 : Decimal;
UnavailAllocEntryCount@1000000008 : Integer;
CurrRecIndex@1000000009 : Integer;
BEGIN
UnavailAllocEntry.RESET;
UnavailAllocEntry.DELETEALL;
RetValue := EndDT;
IF ServiceScheduleSetup."Show Unavailable Time" THEN BEGIN
DateRec.RESET;
DateRec.SETRANGE("Period Type",DateRec."Period Type"::Date);
DateRec.SETRANGE("Period
Start",DateTimeMgt.Datetime2Date(StartDT),DateTimeMgt.Datetime2Date(EndDT));
IF DateRec.FINDFIRST THEN REPEAT
FillUnavailableTimeEntries(UnavailAllocEntry,NewResNo,
DateRec."Period Start");
UNTIL DateRec.NEXT=0;
CurrDT := StartDT;
UnavailAllocEntryCount := UnavailAllocEntry.COUNT;
IF UnavailAllocEntryCount > 1 THEN BEGIN
CurrRecIndex := 1;
UnavailAllocEntry.FINDFIRST;
WHILE ((CurrDT<EndDT) AND (CurrRecIndex<=UnavailAllocEntryCount)) DO
BEGIN
IF (UnavailAllocEntry."Start Date-Time" <= CurrDT) AND (CurrDT <=
UnavailAllocEntry."End Date-Time") THEN BEGIN
IF (UnavailAllocEntry."End Date-Time" > EndDT) THEN BEGIN
NewCurrDT := EndDT;
END ELSE BEGIN
NewCurrDT := UnavailAllocEntry."End Date-Time";
END;
RetValue -= (NewCurrDT - CurrDT);
RetValue -= DateTimeMgt.Datetime(0D, 000000.001T); //minus one
millisecond
END ELSE BEGIN
IF (UnavailAllocEntry."Start Date-Time" >= CurrDT) AND (CurrDT <=
UnavailAllocEntry."End Date-Time") THEN BEGIN
IF (UnavailAllocEntry."Start Date-Time" >= EndDT) THEN BEGIN
NewCurrDT := EndDT;
END ELSE BEGIN
CurrDT := UnavailAllocEntry."Start Date-Time";
IF (UnavailAllocEntry."End Date-Time" > EndDT) THEN
NewCurrDT := EndDT
ELSE
NewCurrDT := UnavailAllocEntry."End Date-Time";
RetValue -= (NewCurrDT - CurrDT);
RetValue -= DateTimeMgt.Datetime(0D, 000000.001T); //minus one
millisecond
END;
END ELSE BEGIN
NewCurrDT := CurrDT;
RetValue -= 0;
END;
END;
CurrDT := NewCurrDT;
CurrRecIndex += 1;
UnavailAllocEntry.NEXT;
END;
END;
END;
EXIT(RetValue);
END;
PROCEDURE BreakAllocation@1101908043();
VAR
BEGIN

MESSAGE(Text121);
EXIT;
END;
AllocationForm.SetParam(LaborAllocEntry."Entry No.",
LaborAllocEntry."Resource No.", CurrDateTime,
LaborAllocEntry."Quantity (Hours)",
COMMIT; //28.06.2013 EDMS P8
//END;//30.10.2012 EDMS
END;
PROCEDURE ProcessMovement@1190017(EntryNo@1101904000 :
Integer;NewResourceNo@1190005 : Code[20];NewStartingDateTime@1190004 :
Decimal;NewQtyToAllocate@1190003 : Decimal;SplitTracking1@1101908000 :
'No,Yes';NewStatus@1000 : 'Pending,In Process,Finished,On Hold';Operation@1001 :
Integer;Travel@25006000 : Boolean);
VAR
OldResourceNo@1101908002 : Code[20];
OldStartingDateTime@1101908001 : Decimal;
OldEndingDateTime@1101908003 : Decimal;
OldHours@1101908004 : Decimal;
DoReplan@1190001 : Boolean;
MainAllocEntrNo@1101904001 : Integer;
BEGIN
// Operation codes:
// -1 UNDEFINED
// 0 view; 1 - time registration; 2 - Planning; 3 - Reallocate (manager); 4 -
BREAK; 100 - allocate lines; 110 - allocate header; 120 - ALLOCATE standart event
// 200 - spliting
// 300 - move; 310 - change end time of finished
// 400 - delete entry
SplitTracking := SplitTracking1;
LaborAllocEntry.GET(EntryNo);
IF Operation < 0 THEN
Operation := 300;
IF NOT CheckUserRightsAdv(Operation, LaborAllocEntry) THEN EXIT;
OldResourceNo := LaborAllocEntry."Resource No.";

IF NOT (Resource.GET(NewResourceNo)) THEN BEGIN
NewResourceNo := OldResourceNo;
IF NOT (Resource.GET(NewResourceNo)) THEN
ERROR(Text160);
END;
OldStartingDateTime := LaborAllocEntry."Start Date-Time";
OldEndingDateTime := LaborAllocEntry."End Date-Time";
OldHours := LaborAllocEntry."Quantity (Hours)";
DoReplan := TRUE;
IF SplitAllocTracking(EntryNo, 0) THEN BEGIN
MainAllocEntrNo := GetMainAllocEntrNo(LaborAllocEntry."Entry No.", 1011);
//MESSAGE('msg in processmovement 01');
MovementIncSplit(EntryNo, NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, NewStatus);
// in routine MovementIncSplit is deleted EntryNo, then need continue with
MainAllocEntrNo
EntryNo := MainAllocEntrNo;
END ELSE BEGIN
WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
NewQtyToAllocate,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 1, EntryNo, DoReplan,
NewStatus, FALSE,Travel);
IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);
IF NewResourceNo <> OldResourceNo THEN BEGIN //replan old resource entries

ReplanEntries(OldResourceNo, OldEndingDateTime, -OldHours, FALSE, 0, '');

JoinAllocationEntries(OldResourceNo, OldStartingDateTime);
END;
END;
//Adjust Related entries
SynchroniseRelatedEntries(EntryNo);
END;
PROCEDURE ProcessMovementApp@1101904025(VAR
ServLaborAllocApplicationPar@1101904001 : Record 25006277;EntryNo@1101904000 :
Decimal;NewQtyToAllocate@1190003 : Decimal;SplitTracking1@1101908000 : 'No,Yes')
MainAllocEntrNo : Integer;
VAR
OldEndingDateTime@1101908003 : Decimal;
ResourceTmp@1101904002 : TEMPORARY Record 156;
Resource@1101904003 : Record 156;
ServLaborAllocEntryTmp@1101904007 : TEMPORARY Record 25006271;
PreviousAllocEntryNo@1101904006 : Integer;
BEGIN
// at first create new entries
ResourceTmp.RESET;
ResourceTmp.DELETEALL;
WITH ServLaborAllocApplicationPar DO BEGIN
IF FINDFIRST THEN
REPEAT
//�eit vai nu ar setrange atrast vai t�ds jau exist�, vai pirms tam jau
padot ar� exist�jo�as rindas ar pareizu LineNo.
LaborAllocApp.RESET;
LaborAllocApp.SETRANGE("Allocation Entry No.","Allocation Entry No.");
LaborAllocApp.SETRANGE("Document Type","Document Type");
LaborAllocApp.SETRANGE("Document No.","Document No.");
LaborAllocApp.SETRANGE("Document Line No.","Document Line No.");
LaborAllocApp.SETRANGE("Resource No.","Resource No.");
//IF NOT LaborAllocApp.GET("Allocation Entry No.", "Document Type",
"Document No.", "Document Line No.","Line No.") THEN BEGIN
IF NOT LaborAllocApp.FINDFIRST THEN BEGIN
IF NOT ResourceTmp.GET("Resource No.") THEN BEGIN
IF Resource.GET("Resource No.") THEN BEGIN
ResourceTmp := Resource;
ResourceTmp.INSERT;
END;
END;
END;
UNTIL NEXT = 0;
//'NewStartingDateTime:'+FORMAT(NewStartingDateTime)+',
NewQtyToAllocate:'+FORMAT(NewQtyToAllocate)); //
IF ResourceTmp.FINDFIRST THEN BEGIN
FindSplitEntries(MainAllocEntrNo, ServLaborAllocEntryTmp, 0, 1111);
PreviousAllocEntryNo := 0;
REPEAT
ServLaborAllocEntryTmp.FINDFIRST;
REPEAT
PreviousAllocEntryNo :=
AddResourceToAllocEntry(ServLaborAllocEntryTmp, LaborAllocApp,
ResourceTmp."No.", PreviousAllocEntryNo, LaborAllocEntry,
LaborAllocApp);
UNTIL ServLaborAllocEntryTmp.NEXT = 0;
UNTIL ResourceTmp.NEXT = 0;
END;
END;
ProcessMovement(EntryNo, NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, SplitTracking1, LaborAllocEntry.Status,
-1,LaborAllocEntry.Travel);
EXIT(MainAllocEntrNo);
END;
PROCEDURE MovementIncSplit@1101908011(EntryNo@1101908000 :
Decimal;NewQtyToAllocate@1101908003 : Decimal;NewStatus@1101904005 : Integer);
VAR
ServLaborAllocApplication@1101904001 : Record 25006277;
ServiceLineLoc@1101908009 : TEMPORARY Record 25006146;
NewSourceID@1101908007 : Code[20];
NewSourceType@1101908005 : ',Service Document,Standard Event';
NewSourceSubType@1101908006 : 'Qoute,Order';
NewTotalHours@1101908008 : Decimal;
RecalcQtyToAllocate@1101904000 : Decimal;
QtyToMove@1101904002 : Decimal;
MainAllocEntrNo@1101904004 : Integer;
Travel@25006000 : Boolean;
BEGIN
Travel := LaborAllocEntry.Travel;
NewSourceType := LaborAllocEntry."Source Type";
NewSourceSubType := LaborAllocEntry."Source Subtype";
NewSourceID := LaborAllocEntry."Source ID";
//NewStatus := LaborAllocEntry.Status;
DoReplan := FALSE;
ServiceLineLoc.DELETEALL;
LaborAllocApp.SETRANGE("Allocation Entry No.", LaborAllocEntry."Entry
No.");
IF LaborAllocApp.FINDFIRST THEN
REPEAT
FillServiceLine2(ServiceLineLoc, LaborAllocApp."Document Type",
LaborAllocApp."Document No.",
LaborAllocApp."Document Line No.");
UNTIL LaborAllocApp.NEXT = 0;
END;
RecalcQtyToAllocate := 0;
FindSplitEntries(EntryNo, ServLaborAllocEntryTmp, 0, 0); //15.08.2013 EDMS
P8
IF ServLaborAllocEntryTmp.FINDFIRST THEN BEGIN
REPEAT
IF ServLaborAllocEntryTmp."Entry No." = EntryNo THEN
RecalcQtyToAllocate += NewQtyToAllocate
ELSE
RecalcQtyToAllocate += ServLaborAllocEntryTmp."Quantity (Hours)";
END;
OldStartingDateTime := LaborAllocEntry."Start Date-Time";

QtyToMove := NewStartingDateTime - OldStartingDateTime;
//lets first split part will be as start point
EntryNo := MainAllocEntrNo;
NewStartingDateTime := LaborAllocEntry."Start Date-Time" + QtyToMove;
//MESSAGE('msg in movement 0');
DeallocateIncSplit(EntryNo, FALSE);

ClearAllocationEntry(EntryNo, FALSE);

ServiceLineLoc.RESET;
IF ServiceLineLoc.FINDFIRST THEN
REPEAT
FillServiceLine2(ServiceLine, ServiceLineLoc."Document Type",
ServiceLineLoc."Document No.", ServiceLineLoc."Line No.");
UNTIL ServiceLineLoc.NEXT = 0;
RecalcQtyToAllocate,
NewSourceType, NewSourceSubType, NewSourceID, 1,
EntryNo, DoReplan, NewStatus, FALSE,Travel);

END;
PROCEDURE AllocateStandardEvent@1190008(ResourceNo@1190002 :
VAR
StandardEvents@1190003 : Page 25006357;
StandardEvent@1190004 : Record 25006272;
ServLine@1190005 : Record 25006146;
CurrQtyToAllocate@1000 : Decimal;
ServiceScheduleMgt@1001 : Codeunit 25006201;
RoundMs@1002 : Integer;
BEGIN
//IF ServiceScheduleSetup."Allocation Time Step (Minutes)" > 0 THEN
// RoundMs := ServiceScheduleSetup."Allocation Time Step (Minutes)"
//ELSE
RoundMs := 60000;
IF RoundMs > 0 THEN BEGIN

StartingDateTime := DateTimeRound(StartingDateTime, RoundMs);
EndingDateTime := DateTimeRound(EndingDateTime, RoundMs);
END;
CurrQtyToAllocate := ServiceScheduleMgt.CalcWorkHourDifference(ResourceNo,
CurrQtyToAllocate := ServiceScheduleMgt.RoundQtyHours(CurrQtyToAllocate, 0);
CLEAR(StandardEvents);
StandardEvents.LOOKUPMODE(TRUE);
IF StandardEvents.RUNMODAL = ACTION::LookupOK THEN

BEGIN
StandardEvents.GETRECORD(StandardEvent);
//Allocate(ResourceNo,StartingDateTime,0,2,0,StandardEvent.Code,ServLine,0);
Allocate(ResourceNo,StartingDateTime,CurrQtyToAllocate,2,0,StandardEvent.Code,ServL
ine,0);
END
ELSE
EXIT;
END;
PROCEDURE AllocateServiceLines@1190009(ResourceNo@1190004 :
VAR
ServiceLinesAllocation@1190000 : Page 25006354;
ServiceLine@1190001 : Record 25006146;
WhatAllocation@1101908001 : 'Header,Line';
NewLineNo@1190005 : Integer;
BEGIN
CLEAR(ServiceLinesAllocation);
ServiceLinesAllocation.LOOKUPMODE(TRUE);
IF ServiceLinesAllocation.RUNMODAL = ACTION::LookupOK THEN

BEGIN
ServiceLinesAllocation.SetSelectionFilter1(ServiceLine);
CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Line);
ServiceLine2.CLEARMARKS;
IF ServiceLine.FINDFIRST THEN
REPEAT
NewLineNo := ServiceLine."Line No.";
IF NOT CheckServiceLineResource(ServiceLine."Document Type",
ServiceLine."Document No.",
ServiceLine.Type, ServiceLine."Line No.", 1, ResourceNo) THEN BEGIN
IF CONFIRM(STRSUBSTNO(Text137, ServiceLine."No.")) THEN
NewLineNo := SplitServiceLine(ServiceLine."Document Type",
ServiceLine."Document No.", ServiceLine."Line No.");
END;
ServiceLine2.GET(ServiceLine."Document Type", ServiceLine."Document
No.", NewLineNo);
ServiceLine2.MARK(TRUE);
UNTIL ServiceLine.NEXT = 0;
COMMIT;
ServiceLine2.MARKEDONLY(TRUE);
IF ServiceLine2.FINDFIRST THEN
//Allocate(ResourceNo,StartingDateTime,0,1,ServiceLine2."Document
Type",ServiceLine2."Document No.",ServiceLine2,0);
Allocate(ResourceNo,StartingDateTime,CurrQtyToAllocate,1,ServiceLine2."Document
Type",ServiceLine2."Document No.",ServiceLine2,0);
END
ELSE
EXIT;
END;
PROCEDURE AllocateServiceOrder@1101908060(ResourceNo@1101908002 :
Decimal);
VAR
ServiceHdrsAllocation@1101908004 : Page 25006356;
BEGIN
CLEAR(ServiceHdrsAllocation);
ServiceHdrsAllocation.LOOKUPMODE(TRUE);
IF ServiceHdrsAllocation.RUNMODAL = ACTION::LookupOK THEN

BEGIN
ServiceHdrsAllocation.GETRECORD(ServiceHdr);
WhatAllocation::Header);
ServiceLine.SETRANGE("Document Type", ServiceHdr."Document Type");
ServiceLine.SETRANGE("Document No.", ServiceHdr."No.");
ServiceLine.SETRANGE("Line No.", 0);
//Allocate(ResourceNo,StartingDateTime,0,1,ServiceHdr."Document
Type",ServiceHdr."No.",ServiceLine,0);
Allocate(ResourceNo,StartingDateTime,CurrQtyToAllocate,1,ServiceHdr."Document
END
ELSE
EXIT;
END;
PROCEDURE AllocateEventAndStart@1190035(ResourceNo@1190002 : Code[20]);

VAR
StandardEvents@1190003 : Page 25006357;
ServLine@1190005 : Record 25006146;
StartingDateTime@1190000 : Decimal;
BEGIN
StartingDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

CLEAR(StandardEvents);
StandardEvents.LOOKUPMODE(TRUE);
IF StandardEvents.RUNMODAL = ACTION::LookupOK THEN

BEGIN
StandardEvents.GETRECORD(StandardEvent);
AllocationForm.SetParam(ResourceNo,StartingDateTime,2,0,StandardEvent.Code);
AllocationForm.LOOKUPMODE(TRUE);
COMMIT; //28.06.2013 EDMS P8
END
ELSE
EXIT;
END;
PROCEDURE Allocate@1190015(ResourceNo@1190000 :
Code[20];StartingDateTime@1190001 : Decimal;QtyToAllocate@1190002 :
Decimal;SourceType@1190003 : ',Service Document,Standard
Event';SourceSubType@1190004 : 'Qoute,Order';SourceID@1190005 : Code[20];VAR
ServiceLine1@1190007 : Record 25006146;ForceStatus@25006000 : Integer) : Boolean;
VAR
BEGIN
AllocationForm.SetParam(0,ResourceNo,StartingDateTime,QtyToAllocate,SourceType,Sour
ceSubType,SourceID,0, ServiceLine1,ForceStatus);
AllocationForm.SETTABLEVIEW := LaborAllocAppTemp;
COMMIT; //28.06.2013 EDMS P8
END;
PROCEDURE AllocateNewVisitQuote@1101904042(ResourceNo@1101908002 :
Decimal);
VAR
DocumentNo@1101904001 : Code[20];
DocumentType@1101904000 : 'Quote,Order,Return Order';
BEGIN
WITH ServiceHdr DO BEGIN

DocumentNo := CreateNewServiceDocument("Document Type"::Quote);
SETRANGE("Document Type", "Document Type"::Quote);
SETRANGE("No.", DocumentNo);
IF FINDFIRST THEN BEGIN
Allocate(ResourceNo,StartingDateTime,0,1,ServiceHdr."Document
END ELSE
EXIT;
END;
END;
PROCEDURE AllocateNewVisitOrder@1101904037(ResourceNo@1101908002 :
Decimal);
VAR
ServiceLineLoc@1101908005 : Record 25006146;
DocumentType@1101904000 : 'Quote,Order,Return Order';
BEGIN
WITH ServiceHdr DO BEGIN

DocumentNo := CreateNewServiceDocument("Document Type"::Order);
SETRANGE("Document Type", "Document Type"::Order);
SETRANGE("No.", DocumentNo);
//22.03.2014 Elva Baltic P1 #X01 MMG7.00 >>
//CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
ServiceLineLoc.SETRANGE("Document Type",ServiceLineLoc."Document
Type"::Order);
ServiceLineLoc.SETRANGE("Document No.",DocumentNo);
ServiceLineLoc.SETRANGE(Type,ServiceLineLoc.Type::Labor); //06.04.2014
Elva Baltic P1 #X01 MMG7.00
//CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Line); //09.04.2014 Elva Baltic P1 #X01 MMG7.00
CheckForCorrectServHeaderLine(ServiceHdr, ServiceLineLoc,
WhatAllocation::Line); //09.04.2014 Elva Baltic P1 #X01 MMG7.00
//22.03.2014 Elva Baltic P1 #X01 MMG7.00 <<
Allocate(ResourceNo,StartingDateTime,0,1,ServiceHdr."Document
Type",ServiceHdr."No.",ServiceLineLoc,0);
END ELSE
EXIT;
END;
END;
PROCEDURE ProcessAllocation@1190016(ResourceNo@1190005 :
Decimal;SourceType@1190002 : ' ,Service Document,Standard
ServiceLine1@1101908011 : Record 25006146;DivideIntoLines@1101908001 :
Boolean;ForceStatus1@25006000 : 'Pending,In Progress,Finished,On
Hold,Cancelled';TravelPar@25006001 : Boolean);
VAR
ServiceLine2@1101908003 : TEMPORARY Record 25006146;
ServiceHours@1101908002 : Decimal;
QtyToAllocate2@1101908004 : Decimal;
JoinStartingDateTime@1101908006 : Decimal;
RecCount@1101908000 : Integer;
EntryNo@1101908005 : Integer;
BEGIN
//21.11.2013 EDMS P8
CASE SourceType OF
SourceType::"Service Document":
BEGIN
IF ServiceLine1."Line No." > 0 THEN BEGIN
END ELSE
END;
SourceType::"Standard Event":
ELSE
END;
DoReplan := TRUE;
JoinStartingDateTime := StartingDateTime;
IF NOT DivideIntoLines THEN BEGIN
FillServiceLine(ServiceLine1);
WriteAllocationEntries(ResourceNo, StartingDateTime, QtyToAllocate,
SourceType, SourceSubType, SourceID, 0, 0, DoReplan, ForceStatus1,
FALSE,TravelPar);
END ELSE BEGIN
RecCount := ServiceLine1.COUNT;
REPEAT
ServiceHours += ServiceLine1.GetTimeQty;
UNTIL ServiceLine1.NEXT = 0;
EntryNo := 0;
REPEAT
ServiceLine2.RESET;
ServiceLine2.DELETEALL;
IF ServiceLine1.Quantity <> 0 THEN BEGIN
ServiceLine2 := ServiceLine1;
ServiceLine2.INSERT;
FillServiceLine(ServiceLine2);
QtyToAllocate2 := ROUND((ServiceLine2.GetTimeQty / ServiceHours) *
QtyToAllocate, 0.001);
WriteAllocationEntries(ResourceNo, StartingDateTime, QtyToAllocate2,
SourceType, ServiceLine2."Document Type",
ServiceLine2."Document No.", 0, 0, DoReplan,
ForceStatus1, FALSE,TravelPar);
StartingDateTime := LaborAllocEntry."End Date-Time";
EntryNo := LaborAllocEntry."Entry No.";
END;
END;

JoinAllocationEntries(ResourceNo, JoinStartingDateTime);
END;
PROCEDURE ProcessAllocationResources@1101904019(VAR ResourceTmp@1190005 :

TEMPORARY Record 156;StartingDateTime@1190004 : Decimal;QtyToAllocate@1190003 :
Decimal;SourceType@1190002 : ' ,Service Document,Standard
ServiceLine1@1101908011 : Record 25006146;DivideIntoLines@1101908001 :
Boolean;ForceStatus1@25006001 : 'Pending,In Progress,Finished,On
Hold,Cancelled';TravelPar@25006000 : Boolean) MainAllocEntrNo : Integer;
VAR
PreviousAllocEntryNo@1101904000 : Integer;
TextNoRecords@1101904001 : TextConst 'ENU=No Resource to process, so no entry
is generated.';
BEGIN
IF ResourceTmp.FINDFIRST THEN BEGIN
ProcessAllocation(ResourceTmp."No.", StartingDateTime, QtyToAllocate,
SourceType, SourceSubType,
SourceID, ServiceLine1, DivideIntoLines, ForceStatus1,TravelPar);
FindSplitEntries(MainAllocEntrNo, ServLaborAllocEntryTmp, 0, 1111);
PreviousAllocEntryNo := 0;
IF ResourceTmp.NEXT <> 0 THEN
REPEAT
ServLaborAllocEntryTmp.FINDFIRST;
REPEAT
PreviousAllocEntryNo := AddResourceToAllocEntry(ServLaborAllocEntryTmp,
LaborAllocApp,
ResourceTmp."No.", PreviousAllocEntryNo, LaborAllocEntry,
LaborAllocApp);
UNTIL ResourceTmp.NEXT = 0;
END ELSE
ERROR(TextNoRecords);
EXIT(MainAllocEntrNo);
END;
PROCEDURE AllocationSpliting@1101908020(NewResourceNo@1101908001 :
Code[20];NewStartingDateTime@1101908000 : Decimal);
VAR
BEGIN
MESSAGE(Text121);
EXIT;
END;
AllocationForm.SetIsTravel(LaborAllocEntry.Travel);
AllocationForm.SetParam(0,NewResourceNo,NewStartingDateTime,LaborAllocEntry."Quanti
ty (Hours)",
COMMIT; //28.06.2013 EDMS P8
END;
PROCEDURE ProcessSpliting@1101908021(NewResourceNo@1101908003 :
Code[20];NewStartingDateTime@1101908002 : Decimal;NewQtyToAllocate@1101908001 :
Decimal;SplitTracking1@1101908000 : 'No,Yes');
VAR
TotalHours@1101908007 : Decimal;
StartDateTime@1101908008 : Decimal;
DifferentStatus@1101908009 : Boolean;
BEGIN
IF NewQtyToAllocate <= 0 THEN
EXIT;
DoReplan := TRUE;
SplitTracking := SplitTracking1;
EntryNo := SingleInstanceMgt.GetAllocationEntryNo;
AllocationStatus := LaborAllocEntry.Status;
ChangeAllocationStatus := TRUE;
TotalHours := CalculateTotalHours(EntryNo);
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
LaborAllocEntryTemp.SETCURRENTKEY("Resource No.", "Start Date-Time");
IF LaborAllocEntryTemp.FINDFIRST THEN
StartDateTime := LaborAllocEntryTemp."Start Date-Time";
IF SplitAllocTracking(EntryNo, 0) THEN BEGIN

IF NewQtyToAllocate >= TotalHours THEN
MovementIncSplit(EntryNo, NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, LaborAllocEntry.Status) //do only moving
ELSE BEGIN
MovementIncSplit(EntryNo, LaborAllocEntry."Resource No.", StartDateTime,
TotalHours - NewQtyToAllocate,
LaborAllocEntry.Status); //correct old entry
DoServiceSpliting := (NewResourceNo <> LaborAllocEntry."Resource No.");
LaborAllocApp.SETRANGE("Allocation Entry No.", EntryNo);
REPEAT
FillServiceLine2(ServiceLine, LaborAllocApp."Document Type",
NewQtyToAllocate, //insert new entry
LaborAllocEntry."Source ID", 0, 0, DoReplan,
LaborAllocEntry.Status, FALSE,FALSE);

END;
END ELSE BEGIN
IF NewQtyToAllocate >= LaborAllocEntry."Quantity (Hours)" THEN BEGIN
DifferentStatus := CheckLaborStatus(LaborAllocEntryTemp);
IF DifferentStatus AND DoServiceSpliting THEN BEGIN
REPEAT
NewQtyToAllocate,

DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp, EntryNo, 11111);
REPEAT
StatusChanged := FALSE;
IF LaborAllocEntryTemp."Entry No." <> EntryNo THEN BEGIN
ChangeServiceLineStatus(LaborAllocEntryTemp."Entry No.", FALSE);
StatusChanged := TRUE;
END;
UNTIL (LaborAllocEntryTemp.NEXT = 0) OR StatusChanged;
END ELSE BEGIN

NewQtyToAllocate,
LaborAllocEntry."Source ID", 1, EntryNo,
DoReplan, LaborAllocEntry.Status, FALSE,FALSE);

END;
END ELSE BEGIN
WriteAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time",
LaborAllocEntry."Quantity (Hours)" -
NewQtyToAllocate,

JoinAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time");
REPEAT
NewQtyToAllocate,

END;
END;
END;
PROCEDURE SelectAllocationEntry@1190010(EntryNo@1190000 : Integer);

BEGIN
SingleInstanceMgt.SetCurrAllocation(EntryNo);
END;
PROCEDURE DeleteAllocationEntry@1190011(VAR LaborAllocEntry@1190002 : Record

25006271;VAR LaborAllocApp@1190001 : Record 25006277;EntryNo@1190000 :
Integer;RunModeFlags@1101904000 : Integer);
VAR
ResourceNo@1101908001 : Code[20];
SourceID@1101908005 : Code[20];
SourceSubType@1101908004 : 'Qoute,Order';
StartingDateTime@1101908003 : Decimal;
EndingDateTime@1101908002 : Decimal;
HourQty@1101908000 : Decimal;
ApplyToEntryNo@1101908007 : Integer;
DoOneServiceMoving@1101908006 : Boolean;
isNeedCheck@1101904001 : Boolean;
isNeedChangeLineStatus@1101904003 : Boolean;
isGoingToAct@1101904004 : Boolean;
isGoingToReplan@1101904005 : Boolean;
isGoingToJoin@1101904002 : Boolean;
BEGIN
// RunModeFlags = 11111, THE first from left is isGoingToJoin
IF NOT LaborAllocEntry.GET(EntryNo) THEN

EXIT;
isNeedCheck := (CutNextDigit(RunModeFlags) > 0);
isNeedChangeLineStatus := (CutNextDigit(RunModeFlags) > 0);
isGoingToAct := (CutNextDigit(RunModeFlags) > 0);
isGoingToReplan := (CutNextDigit(RunModeFlags) > 0);
isGoingToJoin := (CutNextDigit(RunModeFlags) > 0);
IF isNeedCheck THEN BEGIN

END;
ResourceNo := LaborAllocEntry."Resource No.";

StartingDateTime := LaborAllocEntry."Start Date-Time";
EndingDateTime := LaborAllocEntry."End Date-Time";
HourQty := LaborAllocEntry."Quantity (Hours)";
SourceSubType := LaborAllocEntry."Source Subtype";
SourceID := LaborAllocEntry."Source ID";
//correct service line status >>

IF isNeedChangeLineStatus THEN
ChangeServiceLineStatus(LaborAllocEntry."Entry No.", TRUE);
//correct service line status <<
IF isGoingToAct THEN BEGIN

ChangeApplyTo(EntryNo, LaborAllocEntry."Applies-to Entry No.");
LaborAllocEntry.DELETE(TRUE);
END;
IF isGoingToReplan THEN
ReplanEntries(ResourceNo, EndingDateTime, -HourQty,
ServiceScheduleSetup."Replan Document", SourceSubType, SourceID);
IF isGoingToJoin THEN
JoinAllocationEntries(ResourceNo, StartingDateTime);
END;
PROCEDURE InsertAllocationEntry@1190012(VAR LaborAllocEntryPar@1190008 : Record

25006271;VAR LaborAllocAppPar@1190007 : Record 25006277;ResourceNo@1190005 :
Decimal;SourceType@1190002 : ',Service Document,Standard
Event';SourceSubType@1190001 : 'Qoute,Order';SourceID@1190000 :
Code[20];ApplyToEntry@1101908000 : Integer;DoChangeServLineResource@1101908005 :
Boolean;TravelPar@25006001 : Boolean);
VAR
LaborAllocApp1@1101908002 : Record 25006277;
RetStartDateTime@1101908003 : Decimal;
LineNo@1101908004 : Integer;
SingleInstanceManagment@25006000 : Codeunit 25006001;
BEGIN
//LaborAllocEntry.RESET;
//IF LaborAllocEntry.FINDLAST THEN
//EntryNo := LaborAllocEntry."Entry No.";
IF LaborAllocEntry.FINDLAST THEN
IF LaborAllocEntryPar.FINDLAST THEN
IF LaborAllocEntryPar."Entry No." > EntryNo THEN
EntryNo := LaborAllocEntryPar."Entry No.";
EntryNo += 1;
//12.12.2014 EB.P8 >>

WITH LaborAllocEntryPar DO BEGIN
INIT;
"Entry No." := EntryNo;
"Source Type" := SourceType;
"Source Subtype" := SourceSubType;
"Source ID" := SourceID;
"Start Date-Time" := StartingDateTime;
"End Date-Time" := StartingDateTime + QtyToAllocate*3.6;
"Quantity (Hours)" := QtyToAllocate;
"Resource No." := ResourceNo;
"User ID" := SingleInstanceManagment.GetCurrentUserId;
Travel := TravelPar;
VALIDATE("Applies-to Entry No.", ApplyToEntry); //14.03.2014 Elva Baltic
P8 #S0003 MMG7.00
CASE SourceType OF
SourceType::"Standard Event":
"Planning Policy" := ServiceScheduleSetup."Planning Policy";
SourceType::"Service Document": BEGIN
IF "Source Subtype" = "Source Subtype"::Order THEN BEGIN
ServiceHeader.GET(ServiceHeader."Document Type"::Order, SourceID);
"Planning Policy" := ServiceHeader."Planning Policy";
END;
IF "Source Subtype" = "Source Subtype"::Quote THEN BEGIN
ServiceHeader.GET(ServiceHeader."Document Type"::Quote, SourceID);
"Planning Policy" := ServiceHeader."Planning Policy";
END;
END;
END;
INSERT;
//LaborAllocEntryPar := LaborAllocEntry;
//IF NOT LaborAllocEntryPar.INSERT THEN; //IT catch situations when
LaborAllocEntryPar is temporaral Record
END;
//12.12.2014 EB.P8 <<
IF (SourceType = SourceType::"Service Document") THEN

IF DoChangeServLineResource THEN BEGIN //09.07.2013 EDMS P8
IF ServiceLine.FINDFIRST AND (ApplyToEntry = 0) THEN BEGIN //17.04.2008.
EDMS P2
REPEAT
LineNo := ServiceLine."Line No.";
IF DoServiceSpliting THEN
LineNo := SplitServiceLine(ServiceLine."Document Type",
ControlLaborSequence(ServiceLine."Document Type",
ServiceLine."Document No.", LineNo, StartingDateTime);
ControlSkills(ServiceLine."Document Type", ServiceLine."Document
No.", LineNo, ResourceNo);
InsertAllocApplication(LaborAllocAppPar, EntryNo,
ServiceLine."Document Type", ServiceLine."Document No.",
LineNo, ResourceNo,
DoChangeServLineResource,TravelPar);
DoServiceSpliting := FALSE;
ServiceLine.RESET;
ServiceLine.DELETEALL;
END ELSE BEGIN
LaborAllocApp1.RESET;
LaborAllocApp1.SETRANGE("Allocation Entry No.",
LaborAllocEntryPar."Applies-to Entry No.");
IF LaborAllocApp1.FINDFIRST THEN
REPEAT
LineNo := LaborAllocApp1."Document Line No.";
ControlLaborSequence(LaborAllocApp1."Document Type",
LaborAllocApp1."Document No.", LineNo, StartingDateTime);
ControlSkills(LaborAllocApp1."Document Type",
LaborAllocApp1."Document No.", LineNo, ResourceNo);
LaborAllocApp1."Document Type", LaborAllocApp1."Document No.",
LineNo, ResourceNo,
UNTIL LaborAllocApp1.NEXT = 0;
END;
END ELSE BEGIN //09.04.2013 EDMS P8
//09.07.2013 EDMS P8 >>
IF ServiceLine.FINDFIRST AND (ApplyToEntry = 0) THEN BEGIN
REPEAT
LineNo := ServiceLine."Line No.";
IF DoServiceSpliting THEN
LineNo := SplitServiceLine(ServiceLine."Document Type",
ControlLaborSequence(ServiceLine."Document Type",
ServiceLine."Document No.", LineNo, StartingDateTime);
ControlSkills(ServiceLine."Document Type", ServiceLine."Document
No.", LineNo, ResourceNo);
ServiceLine."Document Type", ServiceLine."Document No.",
LineNo, ResourceNo,
DoServiceSpliting := FALSE;
ServiceLine.RESET;
ServiceLine.DELETEALL;
END ELSE BEGIN
//20.07.2013 EDMS P8 >>
IF ApplyToEntry = 0 THEN BEGIN
//InsertAllocApplication(LaborAllocApp, EntryNo, ServiceLine."Document
Type", ServiceLine."Document No.",
// LineNo, ResourceNo, DoChangeServLineResource);
InsertAllocApplication(LaborAllocAppPar, EntryNo, SourceSubType,
SourceID,
LineNo, ResourceNo,
END ELSE BEGIN
LaborAllocApp1.SETRANGE("Allocation Entry No.",
LaborAllocEntryPar."Applies-to Entry No.");
REPEAT
LineNo := LaborAllocApp1."Document Line No.";
ControlLaborSequence(LaborAllocApp1."Document Type",
LaborAllocApp1."Document No.", LineNo, StartingDateTime);
ControlSkills(LaborAllocApp1."Document Type",
LaborAllocApp1."Document No.", LineNo, ResourceNo);
LaborAllocApp1."Document Type", LaborAllocApp1."Document No.",
LineNo, ResourceNo,
END;
//20.07.2013 EDMS P8 <<
END;
//09.07.2013 EDMS P8 <<
END;
END;
PROCEDURE ModifyAllocationEntry@1190013(VAR LaborAllocEntry@1190002 : Record

25006271;VAR LaborAllocApp@1190001 : Record 25006277;EntryNo@1190000 :
Decimal;NewQtyToAllocate@1190003 : Decimal;DoChangeServLineResource@1101908000 :
Boolean;Status@1101904000 : Integer;AppliesToEntryNo@1101904001 :
Integer;Travel@25006000 : Boolean);
VAR
LaborAllocAppLoc@1101908001 : Record 25006277;
BEGIN
OldResourceNo := LaborAllocEntry."Resource No.";
LaborAllocEntry."Resource No." := NewResourceNo;
LaborAllocEntry."Start Date-Time" := NewStartingDateTime;
LaborAllocEntry."End Date-Time" := NewStartingDateTime +
NewQtyToAllocate*3.6;
LaborAllocEntry."Quantity (Hours)" := NewQtyToAllocate;
LaborAllocEntry.Travel := Travel;
IF AppliesToEntryNo > 0 THEN //10.12.2013 EDMS P8
LaborAllocEntry.VALIDATE("Applies-to Entry No.",
AppliesToEntryNo); //14.03.2014 Elva Baltic P8 #S0003 MMG7.00
IF Status >= 0 THEN
LaborAllocEntry.Status := Status;
LaborAllocEntry.MODIFY;
IF (ServiceScheduleSetup."Control Labor Sequence") OR

(ServiceScheduleSetup."Control Skills" <> ServiceScheduleSetup."Control
Skills"::No)
THEN BEGIN
LaborAllocAppLoc.RESET;
LaborAllocAppLoc.SETRANGE("Allocation Entry No.", EntryNo);
IF LaborAllocAppLoc.FINDFIRST THEN
REPEAT
ControlLaborSequence(LaborAllocAppLoc."Document Type",
LaborAllocAppLoc."Document No.", LaborAllocAppLoc."Document Line No.",
NewStartingDateTime);
IF OldResourceNo <> NewResourceNo THEN
ControlSkills(LaborAllocAppLoc."Document Type",
LaborAllocAppLoc."Document No.", LaborAllocAppLoc."Document Line No.",
NewResourceNo);
UNTIL LaborAllocAppLoc.NEXT = 0;
END;

Document" THEN
ModifyAllocApplication(LaborAllocApp, EntryNo, NewResourceNo,
DoChangeServLineResource,Travel);
END;
PROCEDURE DeleteAllocApplication@1101908014(VAR LaborAllocApp@1101908001 :

Record 25006277;AllocationEntryNo@1101908000 : Integer);
VAR
DocumentType@1101908003 : 'Quote,Order,Invoice,Credit Memo,Blanket
Order,Return Order';
LineNo@1101908005 : Integer;
BEGIN
LaborAllocApp.SETRANGE("Allocation Entry No.", AllocationEntryNo);
REPEAT
DocumentType := LaborAllocApp."Document Type";
DocumentNo := LaborAllocApp."Document No.";
ResourceNo := LaborAllocApp."Resource No.";
LineNo := LaborAllocApp."Document Line No.";
LaborAllocApp.DELETE(TRUE);
LaborAllocAppLoc.SETRANGE("Document Type", DocumentType);
LaborAllocAppLoc.SETRANGE("Document No.", DocumentNo);
LaborAllocAppLoc.SETRANGE("Document Line No.", LineNo);
// IF NOT LaborAllocAppLoc.FINDFIRST THEN BEGIN // P8
// IF LineNo = 0 THEN
// IF CONFIRM(Text145) THEN
// DocAllocAdjustDocLinesResource(DocumentType, DocumentNo, '');
//END;
END;
PROCEDURE InsertAllocApplication@1101908015(VAR LaborAllocApp@1101908001 :

Record 25006277;AllocationEntry@1101908000 : Integer;DocumentType@1101908002 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
Order';DocumentNo@1101908004 : Code[20];LineNo@1101908003 :
Integer;ResourceNo@1101908006 : Code[20];DoChangeServLineResource@1101908007 :
Boolean;Travel@25006001 : Boolean);
VAR
LaborAllocEntryLocal@1101908009 : Record 25006271;
IsTimeLine@1101908008 : Boolean;
ResourceCost@25006000 : Record 156;
BEGIN
IsTimeLine := FALSE;
LaborAllocApp.SETRANGE("Allocation Entry No.", AllocationEntry);
LaborAllocApp.SETRANGE("Time Line", TRUE);
IF NOT LaborAllocApp.FINDFIRST THEN
IsTimeLine := TRUE;
IF NOT LaborAllocEntryLocal.GET(AllocationEntry) THEN EXIT; //28.06.2013

EDMS P8
IF LaborAllocApp.FINDLAST THEN
EntryNo := LaborAllocApp."Allocation Entry No.";
EntryNo += 1;
LaborAllocApp.INIT;
LaborAllocApp."Allocation Entry No." := AllocationEntry;
LaborAllocApp."Document Type" := DocumentType;
LaborAllocApp."Document No." := DocumentNo;
LaborAllocApp."Document Line No." := LineNo;
LaborAllocApp."Resource No." := ResourceNo;
LaborAllocApp.Travel := Travel;
IF IsTimeLine THEN BEGIN
LaborAllocApp."Time Line" := IsTimeLine;
LaborAllocApp."Remaining Quantity (Hours)" :=
LaborAllocEntryLocal."Quantity (Hours)";
END;
IF ResourceCost.GET(ResourceNo)
THEN //12.05.2015 EB.P30 #T030
LaborAllocApp.VALIDATE("Unit Cost", ResourceCost."Unit
Cost"); //12.05.2015 EB.P30 #T030
LaborAllocApp.INSERT(TRUE);
IF DoChangeServLineResource THEN BEGIN

DocAllocAdjustDocLinesResource(DocumentType, DocumentNo, ResourceNo); //
P8
END;
END;
PROCEDURE ModifyAllocApplication@1101908016(VAR LaborAllocApp@1101908003 :

Record 25006277;EntryNo@1101908000 : Integer;ResourceNo@1101908001 :
Code[20];DoChangeServLineResource@1101908002 : Boolean;Travel@25006003 : Boolean);
VAR
LaborAllocEntryLocal@1101908004 : Record 25006271;
ResourceCost@25006000 : Record 156;
IsResourceChanged@25006001 : Boolean;
TotalTimeSpent@25006002 : Decimal;
BEGIN
LaborAllocEntryLocal.GET(EntryNo);
LaborAllocEntryLocal.CALCFIELDS("Total Time Spent","Total Time Spent
Travel");
REPEAT
//12.05.2015 EB.P30 #T030 >>
IsResourceChanged := FALSE;
IF LaborAllocApp."Resource No." <> ResourceNo THEN
IsResourceChanged := TRUE;
//12.05.2015 EB.P30 #T030 <<
LaborAllocApp."Resource No." := ResourceNo;
LaborAllocApp.Travel := Travel;
IF Travel THEN
TotalTimeSpent := LaborAllocEntryLocal."Total Time Spent Travel"
ELSE
TotalTimeSpent := LaborAllocEntryLocal."Total Time Spent";
LaborAllocApp.VALIDATE("Finished Quantity (Hours)", TotalTimeSpent);

LaborAllocApp.VALIDATE("Remaining Quantity (Hours)",
LaborAllocEntryLocal."Quantity (Hours)"-TotalTimeSpent);
//12.05.2015 EB.P30 #T030 >>

IF IsResourceChanged THEN BEGIN
IF ResourceCost.GET(ResourceNo) THEN
LaborAllocApp.VALIDATE("Unit Cost", ResourceCost."Unit Cost");
END;
//12.05.2015 EB.P30 #T030
LaborAllocApp.MODIFY;
IF DoChangeServLineResource THEN BEGIN
DocAllocAdjustDocLinesResource(LaborAllocApp."Document Type",
LaborAllocApp."Document No.", ResourceNo); // P8
END;
END;
PROCEDURE IsTimeAvailable@1101908005(VAR ServLaborAlloc@1101908003 : Record

25006271;ResourceNo@1101908002 : Code[20];CurrentDay@1101908001 :
Date;ModifyEntryNo@1101908013 : Integer) : Boolean;
VAR
ResourceCalendarChange@1101908008 : Record 25006279;
ServLaborAlloc2@1101908010 : Record 25006271;
LaborAllocApp@1101908011 : TEMPORARY Record 25006277;
ResourceLoc@1190000 : Record 156;
Starting@1101908006 : Decimal;
Finishing@1101908005 : Decimal;
QtyToAllocate@1101908012 : Decimal;
HourEntry@1190001 : Integer;
WhichEntry@1190003 : Integer;
PeriodStart@1190002 : Time;
OwnWorkTime@1101908014 : Boolean;
DoChangeServLineResource@1101908015 : Boolean;
BEGIN
//EDMS P2
DoChangeServLineResource := FALSE;
//check for busy time in Base Calendar and in Resource Calendar Change >>
OwnWorkTime := FALSE;
IF ResourceCalendarChange.GET(ResourceNo, CurrentDay) THEN BEGIN
IF ResourceCalendarChange."Change Type" = ResourceCalendarChange."Change
Type"::Nonworking THEN
EXIT(FALSE)
ELSE BEGIN
IF NOT (ResourceCalendarChange."Starting Time" = 000000T) THEN BEGIN
QtyToAllocate := CalcHourDifference(DateTimeMgt.Datetime(CurrentDay,
000000T),
DateTimeMgt.Datetime(CurrentDay,
ResourceCalendarChange."Starting Time"));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
DateTimeMgt.Datetime(CurrentDay, 000000T), QtyToAllocate,
0, 0, 'Err1', 0, DoChangeServLineResource,FALSE);
OwnWorkTime := TRUE;
END ELSE BEGIN
DateTimeMgt.Datetime(CurrentDay, 000000T), 0,
0, 0, 'Err1', 0, DoChangeServLineResource,FALSE);
END;
IF NOT (ResourceCalendarChange."Ending Time" > 235959T) THEN BEGIN

ResourceCalendarChange."Ending Time"),
235959.999T));
ResourceCalendarChange."Ending Time"), QtyToAllocate, 0, 0, 'Err2',0,
DoChangeServLineResource,FALSE);
END ELSE BEGIN
ResourceCalendarChange."Ending Time"), 0, 0, 0, 'Err2',0,
END;
END;
END;
//write busy time from Service Hour EDMS >>

IF NOT OwnWorkTime THEN BEGIN
ServiceHour.RESET;
//AB >>
//ResourceLoc.GET(ResourceNo);
IF ResourceLoc.GET(ResourceNo) THEN BEGIN
ServiceHour.SETRANGE("Service Work Group Code", ResourceLoc."Service Work
Group Code");
ServiceHour.SETFILTER("Starting Date", '''''|<=%1', CurrentDay);
ServiceHour.SETFILTER("Ending Date", '''''|>=%1', CurrentDay);
ServiceHour.SETRANGE(Day, DATE2DWY(CurrentDay, 1) - 1);
//21.02.2010 EDMSB P2 >>
HourEntry := ServiceHour.COUNT;
IF ServiceHour.FINDFIRST THEN BEGIN
PeriodStart := 000000T;
REPEAT
WhichEntry += 1;
IF NOT (ServiceHour."Starting Time" = PeriodStart) THEN BEGIN
PeriodStart),
ServiceHour."Starting Time"));
DateTimeMgt.Datetime(CurrentDay, PeriodStart),
QtyToAllocate, 0, 0, 'Err4', 0,
END ELSE BEGIN
DateTimeMgt.Datetime(CurrentDay, PeriodStart), 0,
0, 0, 'Err4', 0,
END;
PeriodStart := ServiceHour."Ending Time";
IF HourEntry = WhichEntry THEN BEGIN
IF NOT (ServiceHour."Ending Time" > 235959T) THEN BEGIN
QtyToAllocate :=
CalcHourDifference(DateTimeMgt.Datetime(CurrentDay, ServiceHour."Ending Time"),
DateTimeMgt.Datetime(CurrentDay, 235959.999T));
ServiceHour."Ending Time"), QtyToAllocate, 0, 0, 'Err5', 0,
END ELSE BEGIN
ServiceHour."Ending Time"), 0, 0, 0, 'Err5', 0,
END;
END;
UNTIL ServiceHour.NEXT = 0;
END ELSE
EXIT(FALSE)
//21.02.2010 EDMSB P2 <<
END;
//AB <<
END;
// <<
EXIT(TRUE);
END;
PROCEDURE GetTimeAvailable@1190002(ResourceNo@1190000 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190002 : Decimal) :
Boolean;
VAR
CurrentDay@1190006 : Date;
BEGIN
CurrentDay := DateTimeMgt.Datetime2Date(StartingDateTime);
IF ResourceCalendarChange.GET(ResourceNo, CurrentDay) THEN BEGIN

EXIT(FALSE)
ELSE BEGIN
IF (DateTimeMgt.Datetime2Time(StartingDateTime) <=
ResourceCalendarChange."Ending Time") AND
(DateTimeMgt.Datetime2Time(EndingDateTime) >=
ResourceCalendarChange."Starting Time")
THEN
EXIT(TRUE)
ELSE
EXIT(FALSE)
END;
END;
ServiceHour.RESET;
Group Code");
ServiceHour.SETFILTER("Starting Date", '''''|<=%1', CurrentDay);
ServiceHour.SETFILTER("Ending Date", '''''|>=%1', CurrentDay);
ServiceHour.SETRANGE(Day, DATE2DWY(CurrentDay, 1) - 1);
//18.01.2012 EDMS P8 >>
REPEAT
IF (DateTimeMgt.Datetime2Time(StartingDateTime) <= ServiceHour."Ending
Time") AND
(DateTimeMgt.Datetime2Time(EndingDateTime) >= ServiceHour."Starting
Time")
THEN
EXIT(TRUE);
EXIT(FALSE);
//18.01.2012 EDMS P8 <<
END;
EXIT(FALSE);
END;
PROCEDURE IsStarttimeAvailable@1101908036(VAR ServLaborAllocPar@1101908002 :

Record 25006271;ResourceNo@1101908001 : Code[20];CurrentDay@1101908000 :
Date;StartTime@1101908003 : Time);
VAR
BEGIN
//busy time from date start till starttime >>
IF NOT (StartTime = 000000T) THEN BEGIN
000000T),
StartTime));
InsertAllocationEntry(ServLaborAllocPar, LaborAllocApp, ResourceNo,
DateTimeMgt.Datetime(CurrentDay, 000000T), QtyToAllocate,
0, 0, 'Err3', 0, FALSE,FALSE); //12.12.2014 EB.P8
END;
// <<
END;
PROCEDURE IsStarttimeAvailableBackward@1101908037(VAR ServLaborAlloc@1101908002

: Record 25006271;ResourceNo@1101908001 : Code[20];CurrentDay@1101908000 :
Date;StartTime@1101908003 : Time);
VAR
BEGIN
//busy time from date start till starttime >>
IF NOT (StartTime = 000000T) THEN BEGIN
StartTime),
235959.999T));
DateTimeMgt.Datetime(CurrentDay, StartTime), QtyToAllocate,
0, 0, 'Err3', 0, FALSE,FALSE);
END;
// <<
END;
PROCEDURE WriteAllocationEntries@1101908000(ResourceNo@1101908011 :
Decimal;SourceType@1101908014 : 'Service Document,,Standard
Event';SourceSubType@1101908015 : 'Qoute,Order';SourceID@1101908016 :
Code[20];FunctionMode@1101908017 : 'Insert,Modify';ModifyEntryNo@1101908018 :
Integer;DoReplan@1101908000 : Boolean;Status@1101904000 :
Integer;FirstRowMustTakeFromModify@1000 : Boolean;Travel@25006000 : Boolean);
VAR
ServLaborAlloc@1101908005 : Record 25006271;
ServLaborAllocTemp@1101908010 : TEMPORARY Record 25006271;
RepairStatus@1101908006 : Record 25006166;
StartTime@1101908003 : Time;
RetStartDateTime@1101908001 : Decimal;
ReplanHours@1101908002 : Decimal;
QtyToAllocate2@1101908022 : Decimal;
ApplyToEntry@1101908020 : Integer;
FirstEntry@1101908019 : Boolean;
ChangeAllocationStatusLocal@1101908009 : Boolean;
Allocations@25006001 : Page 25006362;
BEGIN
StartTime := DateTimeMgt.Datetime2Time(StartingDateTime);
ChangeAllocationStatusLocal := ChangeAllocationStatus;
ChangeAllocationStatus := FALSE;
QtyToAllocate2 := QtyToAllocate;
AllocationStatus := Status; //20.07.2013 EDMS P8
ReturnAvailableTimes(ServLaborAllocTemp, QtyToAllocate, ResourceNo,

CurrentDay, StartTime, ModifyEntryNo);
DoChangeServLineResource := FALSE; //09.04.2013 EDMS P8

//DoChangeServLineResource := TRUE;
FirstEntry := TRUE;
ApplyToEntry := ModifyEntryNo;
ServLaborAllocTemp.RESET;
//MESSAGE('AllocationStatus:'+FORMAT(AllocationStatus)+'
AllocationStatusAction: '+FORMAT(AllocationStatusAction)+' ScheduleAction:
'+FORMAT(ScheduleAction));
IF ServLaborAllocTemp.FINDFIRST THEN
REPEAT
//MESSAGE('msg in writeAlloc, 1');
IF FirstEntry AND (FunctionMode = FunctionMode::Modify) THEN BEGIN
IF ServLaborAlloc.GET(ModifyEntryNo) THEN;
IF LaborAllocEntry.GET(ModifyEntryNo) THEN;
IF DoReplan THEN BEGIN
ReplanHours := CheckForTime(ResourceNo, ServLaborAllocTemp."Start
Date-Time",
ServLaborAllocTemp."End Date-Time",
ModifyEntryNo, ServiceScheduleSetup."Replan Document",
SourceSubType, SourceID);
IF ReplanHours > 0 THEN
ReplanEntries(ResourceNo, ServLaborAllocTemp."Start Date-Time",
ReplanHours, ServiceScheduleSetup."Replan Document",
SourceSubType, SourceID)
ELSE BEGIN
ReplanHours := CalculateReplanHours(QtyToAllocate2,
ServLaborAlloc."Quantity (Hours)",
ServLaborAllocTemp."Start Date-
Time", ServLaborAlloc."Start Date-Time",
ServLaborAllocTemp."Resource
No.");
IF ReplanHours <> 0 THEN
ReplanEntries(ResourceNo, ServLaborAlloc."End Date-Time",
END;
END;
ModifyAllocationEntry(LaborAllocEntry, LaborAllocApp, ModifyEntryNo,
ServLaborAllocTemp."Resource No.",
ServLaborAllocTemp."Start Date-Time",
ServLaborAllocTemp."Quantity (Hours)",
DoChangeServLineResource, Status,
ServLaborAllocTemp."Applies-to Entry No.",Travel);
END ELSE BEGIN
IF (NOT FirstEntry) THEN BEGIN
IF (ServiceScheduleSetup."Min. Notability (Hours)" >
ServLaborAllocTemp."Quantity (Hours)") THEN
EXIT;
IF GUIALLOWED THEN BEGIN // 11.12.2018 EB.P7
IF NOT CONFIRM(STRSUBSTNO(Text127, CurrentDay,
ServLaborAllocTemp."Quantity (Hours)")) THEN
EXIT; //Task: 004 25.09.2018 EB.P7
END;
//EXIT;
END;
IF DoReplan <> DoReplan::No THEN BEGIN

ReplanHours := CheckForTime(ResourceNo, ServLaborAllocTemp."Start
Date-Time",
ServLaborAllocTemp."End Date-Time",0,
ServiceScheduleSetup."Replan Document",
ReplanEntries(ResourceNo, ServLaborAllocTemp."Start Date-Time",
END;
//lll
IF FirstEntry THEN BEGIN
IF FirstRowMustTakeFromModify THEN
ApplyToEntry := ModifyEntryNo
ELSE
ApplyToEntry := 0
END ELSE
IF ApplyToEntry = 0 THEN //20.07.2013 EDMS P8
ApplyToEntry := ModifyEntryNo;
// THERE COULD BE FOR ONE ALLOCATION both applications: document and

lines
InsertAllocationEntry(LaborAllocEntry, LaborAllocApp,
ServLaborAllocTemp."Resource No.",
ServLaborAllocTemp."Start Date-Time",
ServLaborAllocTemp."Quantity (Hours)",
SourceType, SourceSubType, SourceID,
ApplyToEntry, DoChangeServLineResource,Travel);
END;
IF ApplyToEntry <> 0 THEN

ChangeApplyTo(ApplyToEntry, LaborAllocEntry."Entry No.");
//Update Forced status.

AllocationStatus := Status;
ChangeStatus(LaborAllocEntry);
ChangeServiceLineStatus(LaborAllocEntry."Entry No.", FALSE);
FirstEntry := FALSE;
ApplyToEntry := LaborAllocEntry."Entry No.";
UNTIL ServLaborAllocTemp.NEXT = 0;
END;
PROCEDURE CalculateReplanHours@1101908039(NewQty@1101908000 :
Decimal;OldQty@1101908001 : Decimal;NewStartDateTime@1101908002 :
Decimal;OldStartDateTime@1101908003 : Decimal;ResourceNo@1101908005 : Code[20]) :
Decimal;
VAR
BEGIN
ReplanHours := 0;
ReplanHours := NewQty - OldQty;
IF NewStartDateTime <> OldStartDateTime THEN
ReplanHours += CalcWorkHourDifference(ResourceNo, OldStartDateTime,
NewStartDateTime);
EXIT(ReplanHours)
END;
PROCEDURE WriteAllocationEntryEnd@1101908029(EntryNo@1101908001 :
Integer;EndingDateTime@1101908007 : Decimal;DoReplan@1101908000 :
Boolean;ReasonCode@1101908004 : Code[10];Travel@25006000 : Boolean);
VAR
BEGIN
IF DoReplan THEN BEGIN

ReplanHours := CheckForTime(LaborAllocEntry."Resource No.",
EndingDateTime, EntryNo,
LaborAllocEntry."Source ID");
ReplanEntries(LaborAllocEntry."Resource No.", LaborAllocEntry."End Date-
Time", ReplanHours,
LaborAllocEntry."Source Subtype", LaborAllocEntry."Source ID")
ELSE BEGIN
ReplanHours := CalcHourDifference(LaborAllocEntry."Start Date-Time",
EndingDateTime) - LaborAllocEntry."Quantity (Hours)";
IF ReplanHours < 0 THEN
ReplanEntries(LaborAllocEntry."Resource No.", LaborAllocEntry."End
Date-Time", ReplanHours,
LaborAllocEntry."Source Subtype", LaborAllocEntry."Source ID")
END;
END;
ModifyAllocationEntry(LaborAllocEntry, LaborAllocApp, LaborAllocEntry."Entry
No.", LaborAllocEntry."Resource No.",
CalcHourDifference(LaborAllocEntry."Start Date-Time",
EndingDateTime),
FALSE, -1, LaborAllocEntry."Applies-to Entry
No.",Travel);
IF ReasonCode <> '' THEN

ModifyReason(LaborAllocEntry, ReasonCode);
SynchroniseRelatedEntries(LaborAllocEntry."Entry No.");
END;
PROCEDURE ReturnAvailableTimes@1101908018(VAR ServLaborAllocTemp@1101908001 :

Record 25006271;VAR QtyToAllocate@1101908007 : Decimal;ResourceNo@1101908002 :
Code[20];CurrentDay@1101908003 : Date;StartTime@1101908004 :
Time;ModifyEntryNo@1101908005 : Integer);
VAR
ServLaborAllocTemp2@1101908000 : TEMPORARY Record 25006271;
LastTime@1101908006 : Decimal;
AllocateCurrentQty@1101908008 : Decimal;
AllocateStartDateTime@1101908010 : Decimal;
DayQty@1101908011 : Integer;
BEGIN
//IF ServiceScheduleSetup."Disable Unavail. Time Control" THEN BEGIN
InsertAllocationEntry(ServLaborAllocTemp, LaborAllocAppTemp, ResourceNo,
DateTimeMgt.Datetime(CurrentDay, StartTime), QtyToAllocate,
0, 0, 'Err6', 0,
EXIT;
//END;
{
DayQty := 0;
REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
ModifyEntryNo) THEN BEGIN
IsStarttimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
ServLaborAllocTemp2.RESET;
ServLaborAllocTemp2.SETCURRENTKEY("Resource No.", "Start Date-Time");
LastTime := 0;
IF ServLaborAllocTemp2.FINDFIRST THEN
REPEAT
IF (LastTime <> 0) AND (LastTime < ServLaborAllocTemp2."Start Date-
Time") AND (QtyToAllocate > 0) THEN BEGIN
IF QtyToAllocate > CalcHourDifference(LastTime,
ServLaborAllocTemp2."Start Date-Time") THEN
AllocateCurrentQty := CalcHourDifference(LastTime,
ServLaborAllocTemp2."Start Date-Time")
ELSE
AllocateCurrentQty := QtyToAllocate;
AllocateStartDateTime := LastTime;
InsertAllocationEntry(ServLaborAllocTemp, LaborAllocAppTemp,
ResourceNo, AllocateStartDateTime, AllocateCurrentQty,
0, 0, 'Err6', 0,
QtyToAllocate -= AllocateCurrentQty;
END;
ServLaborAllocTemp2.SETFILTER("End Date-Time", '>%1',

ServLaborAllocTemp2."End Date-Time");
LastTime := ServLaborAllocTemp2."End Date-Time";
UNTIL ServLaborAllocTemp2.NEXT = 0;
END;
ServLaborAllocTemp2.DELETEALL;
CurrentDay := CurrentDay + 1;
StartTime := 000000T;
DayQty += 1;
QtyToAllocate := ROUND(QtyToAllocate, 0.00001);
UNTIL (QtyToAllocate <= 0) OR (DayQty > 1000); //12.12.2014 EB.P8
IF DayQty > 1000 THEN

MESSAGE(Text102);
}
END;
PROCEDURE ReturnAvailableTimesBackward@1101908013(VAR
ServLaborAllocTemp@1101908001 : TEMPORARY Record 25006271;VAR
QtyToAllocate@1101908007 : Decimal;ResourceNo@1101908002 :
Code[20];CurrentDay@1101908003 : Date;StartTime@1101908004 :
Time;ModifyEntryNo@1101908005 : Integer);
VAR
DayQty@1101908011 : Integer;
BEGIN
DayQty := 0;
REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
ModifyEntryNo) THEN BEGIN
IsStarttimeAvailableBackward(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
ServLaborAllocTemp2.SETCURRENTKEY("Resource No.", "End Date-Time");
LastTime := 0;
IF ServLaborAllocTemp2.FINDLAST THEN
REPEAT
IF (LastTime <> 0) AND (LastTime > ServLaborAllocTemp2."End Date-
Time") AND (QtyToAllocate > 0) THEN BEGIN
IF QtyToAllocate > CalcHourDifference(ServLaborAllocTemp2."End
Date-Time", LastTime) THEN BEGIN
AllocateCurrentQty := CalcHourDifference(ServLaborAllocTemp2."End
Date-Time", LastTime);
AllocateStartDateTime := ServLaborAllocTemp2."End Date-Time";
END ELSE BEGIN
AllocateCurrentQty := QtyToAllocate;
AllocateStartDateTime := LastTime - QtyToAllocate*3.6;
END;
0, 0, 'Err7', 0,
QtyToAllocate -= AllocateCurrentQty;
END;
LastTime := ServLaborAllocTemp2."Start Date-Time";

ServLaborAllocTemp2.SETFILTER("Start Date-Time", '<%1',
ServLaborAllocTemp2."Start Date-Time");
UNTIL ServLaborAllocTemp2.NEXT(-1) = 0;
END;
CurrentDay := CurrentDay - 1;
DayQty += 1;
UNTIL (QtyToAllocate <= 0) OR (DayQty > 1000); //12.12.2014 EB.P8
IF DayQty > 1000 THEN

MESSAGE(Text102);
END;
PROCEDURE CalcHourDifference@1101907009(StartDateTime@1101907000 :
Decimal;EndDateTime@1101907001 : Decimal) : Decimal;
BEGIN
//Returns difference in hours
EXIT((EndDateTime - StartDateTime) / 3.6);
END;
PROCEDURE ChangeApplyTo@1101908019(ChangeFromEntry@1101908001 :
Integer;ChangeToEntry@1101908000 : Integer);
VAR
BEGIN
ServLaborAlloc.RESET;
ServLaborAlloc.SETCURRENTKEY("Applies-to Entry No.");
ServLaborAlloc.SETRANGE("Applies-to Entry No.", ChangeFromEntry);
ServLaborAlloc.SETFILTER("Entry No.", '<>%1', ChangeToEntry);
IF ServLaborAlloc.FINDFIRST THEN
REPEAT
ServLaborAlloc.VALIDATE("Applies-to Entry No.",
ChangeToEntry); //14.03.2014 Elva Baltic P8 #S0003 MMG7.00
ServLaborAlloc.MODIFY;
UNTIL ServLaborAlloc.NEXT = 0;
END;
PROCEDURE SplitAllocTracking@1101908008(EntryNo@1101908000 :
Integer;Mode@1101908001 : 'Move,Delete') : Boolean;
VAR
QuestionText@1101908003 : Text[200];
BEGIN
IF ServiceScheduleSetup."Handle Linked Entries" =
EXIT(FALSE);

ServiceScheduleSetup."Handle Linked Entries"::Yes THEN
EXIT(TRUE);
IF Mode = Mode::Delete THEN

QuestionText := Text100;

ServiceScheduleSetup."Handle Linked Entries"::Prompt THEN BEGIN
IF LaborAllocEntryTemp.COUNT > 1 THEN
IF CONFIRM(QuestionText) THEN
EXIT(TRUE);
END;
EXIT(FALSE);
END;
PROCEDURE FillServiceLine@1101908017(VAR ServiceLine1@1101908000 : Record

25006146);
BEGIN
REPEAT
ServiceLine := ServiceLine1;
IF ServiceLine.INSERT THEN;
END;
PROCEDURE FillServiceLine2@1101908051(VAR ServiceLineLoc@1101908003 : Record

25006146;DocumentType@1101908000 : Integer;DocumentNo@1101908001 :
Code[20];LineNo@1101908002 : Integer);
BEGIN
ServiceLineLoc."Document Type" := DocumentType;
ServiceLineLoc."Document No." := DocumentNo;
ServiceLineLoc."Line No." := LineNo;
IF ServiceLineLoc.INSERT THEN;
END;
PROCEDURE CalculateTotalHours@1101908010(EntryNo@1101908000 : Integer) :

Decimal;
VAR
BEGIN
REPEAT
TotalHours += LaborAllocEntryTemp."Quantity (Hours)";
UNTIL LaborAllocEntryTemp.NEXT = 0;
EXIT(TotalHours);
END;
PROCEDURE CalcLaborRemainHours@1101904012(EntryNo@1101908000 : Integer) :

Decimal;
VAR
BEGIN
LaborAllocEntryTemp.SETFILTER(Status, '%1|%2',
LaborAllocEntryTemp.Status::Pending, LaborAllocEntryTemp.Status::"On Hold");
REPEAT
TotalHours += LaborAllocEntryTemp."Quantity (Hours)";
EXIT(TotalHours);
END;
PROCEDURE ReplanEntries@1101908012(ResourceNo@1101908000 :
Code[20];StartingDateTime@1101908001 : Decimal;ChangeHours@1101908011 :
Decimal;DoOneServiceMoving@1101908018 : Boolean;SourceSubType@1101908019 :
'Qoute,Order';SourceID@1101908020 : Code[20]);
VAR
LaborAllocEntry2@1101908005 : Record 25006271;
ServiceLineTemp@1101908008 : TEMPORARY Record 25006146;
ApplyToEntry@1101908007 : Integer;
NewStartingDateTime@1101908012 : Decimal;
NewEndingDateTime@1101908014 : Decimal;
OldEndingTime@1101908013 : Decimal;
WorkHours@1101908015 : Decimal;
BEGIN
OldEndingTime := 0;
DoReplan := FALSE;
LaborAllocEntry2.RESET;
LaborAllocEntry2.SETRANGE("Resource No.", ResourceNo);
LaborAllocEntry2.SETFILTER("Start Date-Time", '>=%1', StartingDateTime);
LaborAllocEntry2.SETFILTER(Status, '%1|%2', LaborAllocEntry2.Status::Pending,
LaborAllocEntry2.Status::"On Hold");
LaborAllocEntry2.SETRANGE("Planning Policy", LaborAllocEntry2."Planning
Policy"::Queue);
IF LaborAllocEntry2.FINDFIRST THEN
REPEAT
LaborAllocEntryTemp := LaborAllocEntry2;
LaborAllocEntryTemp.INSERT;
UNTIL LaborAllocEntry2.NEXT = 0;
IF DoOneServiceMoving THEN BEGIN

LaborAllocEntry2.SETRANGE("Planning Policy");
LaborAllocEntry2.SETRANGE("Source Type", LaborAllocEntry2."Source
Type"::"Service Document");
LaborAllocEntry2.SETRANGE("Source Subtype", SourceSubType);
LaborAllocEntry2.SETRANGE("Source ID", SourceID);
REPEAT
LaborAllocEntryTemp := LaborAllocEntry2;
IF LaborAllocEntryTemp.INSERT THEN;
UNTIL LaborAllocEntry2.NEXT = 0;
END;
REPEAT
IF OldEndingTime <> 0 THEN BEGIN
WorkHours := CalcWorkHourDifference(ResourceNo, OldEndingTime,
LaborAllocEntryTemp."Start Date-Time");
IF WorkHours <> 0 THEN
NewStartingDateTime := CalculateNewStartDateTime(ResourceNo,
NewEndingDateTime, WorkHours)
ELSE
NewStartingDateTime := NewEndingDateTime;
END ELSE BEGIN
NewStartingDateTime := LaborAllocEntryTemp."Start Date-Time" +
ChangeHours * 3.6;
IF ChangeHours < 0 THEN BEGIN
WorkHours := CalcWorkHourDifference(ResourceNo, StartingDateTime,
LaborAllocEntryTemp."Start Date-Time");
NewStartingDateTime := StartingDateTime + (WorkHours + ChangeHours)*
3.6;
END;
END;
OldEndingTime := LaborAllocEntryTemp."End Date-Time";

WriteAllocationEntries(ResourceNo, NewStartingDateTime,
LaborAllocEntryTemp."Quantity (Hours)",
LaborAllocEntryTemp."Source Type",
LaborAllocEntryTemp."Source Subtype",
LaborAllocEntryTemp."Source ID", 1,
LaborAllocEntryTemp."Entry No.", DoReplan,
LaborAllocEntryTemp.Status, FALSE,FALSE);
NewEndingDateTime := LaborAllocEntry."End Date-Time";
END;
PROCEDURE CalcWorkHourDifference@1101908022(ResourceNo@1101908000 :
Code[20];FromDateTime@1101908001 : Decimal;ToDateTime@1101908002 : Decimal) :
Decimal;
VAR
AllocateCurrentEndDateTime@1101908003 : Decimal;
WorkHours@1101908010 : Decimal;
FromDateTime2@1101908015 : Decimal;
CycleEnd@1101908011 : Boolean;
IsReverse@1101908014 : Boolean;
BEGIN
IsReverse := FALSE;
IF FromDateTime > ToDateTime THEN BEGIN
FromDateTime2 := FromDateTime;
FromDateTime := ToDateTime;
ToDateTime := FromDateTime2;
IsReverse := TRUE;
END;
CurrentDay := DateTimeMgt.Datetime2Date(FromDateTime);
StartTime := DateTimeMgt.Datetime2Time(FromDateTime);
CycleEnd := FALSE;
REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay, 0) THEN
BEGIN
IsStarttimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
ServLaborAllocTemp2.SETCURRENTKEY("Resource No.", "Start Date-Time");
LastTime := 0;
IF ServLaborAllocTemp2.FINDFIRST THEN
REPEAT
IF (LastTime <> 0) AND (LastTime < ServLaborAllocTemp2."Start Date-
Time") THEN BEGIN
IF ToDateTime <= ServLaborAllocTemp2."Start Date-Time" THEN BEGIN
AllocateCurrentEndDateTime := ToDateTime;
CycleEnd := TRUE;
END ELSE
AllocateCurrentEndDateTime := ServLaborAllocTemp2."Start Date-
Time";
AllocateStartDateTime := LastTime;
AllocateCurrentQty := CalcHourDifference(AllocateStartDateTime,
AllocateCurrentEndDateTime);
0, 0, 'Err8', 0,
END;
ServLaborAllocTemp2.SETFILTER("End Date-Time", '>%1',
ServLaborAllocTemp2."End Date-Time");
LastTime := ServLaborAllocTemp2."End Date-Time";
UNTIL (ServLaborAllocTemp2.NEXT = 0) OR CycleEnd;
END;
CurrentDay := CurrentDay + 1;
UNTIL CycleEnd OR (DateTimeMgt.Datetime(CurrentDay, StartTime) > ToDateTime);
WorkHours := 0;
IF ServLaborAllocTemp.FINDFIRST THEN
REPEAT
WorkHours += ServLaborAllocTemp."Quantity (Hours)";
UNTIL ServLaborAllocTemp.NEXT = 0;
IF IsReverse THEN
EXIT(-WorkHours);
EXIT(WorkHours);
END;
PROCEDURE CalculateNewStartDateTime@1101908023(ResourceNo@1101908007 :
Decimal) : Decimal;
VAR
BEGIN
StartTime := DateTimeMgt.Datetime2Time(StartingDateTime);
IF QtyToAllocate > 0 THEN

ReturnAvailableTimes(ServLaborAllocTemp, QtyToAllocate, ResourceNo,
CurrentDay, StartTime, 0)
ELSE BEGIN
QtyToAllocate *= -1;
ReturnAvailableTimesBackward(ServLaborAllocTemp, QtyToAllocate, ResourceNo,
CurrentDay, StartTime, 0);
END;
IF ServLaborAllocTemp.FINDLAST THEN
EXIT(ServLaborAllocTemp."End Date-Time")
ELSE
EXIT(0);
END;
PROCEDURE CheckForTime@1101908007(ResourceNo@1101908000 :
Code[20];StartingDateTime@1101908001 : Decimal;FinishingDateTime@1101908002 :
Decimal;EntryNo@1101908005 : Integer;DoOneServiceMoving@1101908008 :
Boolean;SourceSubType@1101908006 : 'Qoute,Order';SourceID@1101908007 : Code[20]) :
Decimal;
VAR
ContinueStartingDateTime@1101908004 : Decimal;
BEGIN
ContinueStartingDateTime := FinishingDateTime;
ServLaborAlloc.RESET;
ServLaborAlloc.SETRANGE("Resource No.", ResourceNo);
ServLaborAlloc.SETRANGE("Start Date-Time", StartingDateTime,
FinishingDateTime - 0.00001);
IF EntryNo <> 0 THEN
ServLaborAlloc.SETFILTER("Entry No.", '<>%1', EntryNo);
ServLaborAlloc.SETCURRENTKEY("Resource No.", "Start Date-Time");
IF DoOneServiceMoving THEN BEGIN

ServLaborAlloc.SETRANGE("Source Type", ServLaborAlloc."Source
ServLaborAlloc.SETRANGE("Source Subtype", SourceSubType);
ServLaborAlloc.SETRANGE("Source ID", SourceID);
END;
IF ServLaborAlloc.FINDFIRST THEN
ContinueStartingDateTime := ServLaborAlloc."Start Date-Time";
EXIT(CalcHourDifference(ContinueStartingDateTime, FinishingDateTime));
END;
PROCEDURE SplitServiceLine@1101908024(DocumentType@1101908007 :
Order';DocumentNo@1101908006 : Code[20];LineNo@1101908005 : Integer) : Integer;
VAR
BEGIN
IF ServiceLineLoc.GET(DocumentType, DocumentNo, LineNo) THEN
NewLineNo := DocumentMgt.ServiceSplitLine(ServiceLineLoc, 2)
ELSE
NewLineNo := LineNo;
EXIT(NewLineNo)
END;
PROCEDURE FindServiceEntries@1101908001(VAR LaborAllocEntry@1101908000 : Record

25006271;DocumentType@1101908002 : 'Quote,Order,Invoice,Credit Memo,Blanket
Order,Return Order';DocumentNo@1101908001 : Code[20];ResourceNo@1101908004 :
Code[20]);
VAR
BEGIN
LaborAllocApp.SETRANGE("Document Type", DocumentType);
LaborAllocApp.SETRANGE("Document No.", DocumentNo);
LaborAllocApp.SETRANGE("Resource No.", ResourceNo);
REPEAT
IF (LaborAllocEntryLoc.GET(LaborAllocApp."Allocation Entry No.")) AND
NOT(LaborAllocEntry.GET(LaborAllocApp."Allocation Entry No."))
THEN BEGIN
LaborAllocEntry := LaborAllocEntryLoc;
LaborAllocEntry.INSERT;
END;
UNTIL LaborAllocApp.NEXT = 0 ;
END;
PROCEDURE ProcessStartLabor@1101908004(StartingDateTime@1101908000 : Decimal);

VAR
Hours@1101908002 : Decimal;
OnDate@25006000 : Date;
OnTime@25006001 : Time;
BEGIN
ScheduleAction := ScheduleAction::"Time Registration";
//P8 >>
//Hours := CalcLaborRemainHours(LaborAllocEntry."Entry No.");
//Hours := LaborAllocEntry."Quantity (Hours)"; //20.07.2013 EDMS P8
//P8 <<
//Hours := CalcHourDifference(StartingDateTime,LaborAllocEntry."End Date-

Time");
Hours := LaborAllocEntry."Quantity (Hours)";
//IF Hours <= 0 THEN
// Hours := LaborAllocEntry."Quantity (Hours)";
ReasonCodeGlobal := LaborAllocEntry."Reason Code";
AllocationStatus := AllocationStatus::"In Process";
AskedForAllocationSpliting := TRUE;
//DoReplan := FALSE; // P8 old
DoReplan := TRUE; // P8 new version
//P8 >>
IF Resource."No." <> '' THEN
//THAT COLD BE FILLED IN CompareSchedulePassword from P25006355
ResourceNo := Resource."No." //17.10.2013 EDMS P8
ELSE
SingleInstanceMgt.SetDateFilter(DateTimeMgt.Datetime2Date(StartingDateTime));
OnDate := DateTimeMgt.Datetime2Date(StartingDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartingDateTime);
ResourceTimeRegMgt.FinishDefaultIdleTask(ResourceNo,OnDate,OnTime);
IF (LaborAllocEntry."Start Date-Time" <> StartingDateTime) OR

(LaborAllocEntry."Quantity (Hours)" <> Hours) THEN BEGIN
ProcessMovement(LaborAllocEntry."Entry No.", ResourceNo,
StartingDateTime, Hours, 1, AllocationStatus, 1,Travel);
END ELSE BEGIN
WriteAllocationEntries(ResourceNo, StartingDateTime, Hours,
LaborAllocEntry."Source Type", LaborAllocEntry."Source
Subtype",
AllocationStatus, FALSE,Travel); //20.07.2013 EDMS P8
END;
//P8 <<
//Check for Hold/Complete other tasks.

FinishOtherTasks(ResourceNo,EntryNo,StartingDateTime);
END;
PROCEDURE ProcessFinishLabor@1101908003(EndingDateTime@1101908000 :
Decimal;AllocationStatus1@1101908001 : 'Pending,In Process,Finish All,Finish
Part,On Hold';HoldHours@1101908003 : Decimal;ReasonCode@1101908006 : Code[10]);
VAR
FinishedHours@1101908002 : Decimal;
BEGIN
AllocationStatusAction := AllocationStatus1;
CASE AllocationStatus1 OF
AllocationStatus1::Pending:
AllocationStatus := AllocationStatus::Pending;
AllocationStatus1::"In Process":
AllocationStatus := AllocationStatus::"In Process";
AllocationStatus1::"Finish All", AllocationStatus1::"Finish Part":
AllocationStatus := AllocationStatus::Finished;
AllocationStatus1::"On Hold":
AllocationStatus := AllocationStatus::"On Hold";
END;
//IF AllocationStatus IN [AllocationStatus::Finished] THEN

// DoReplan := TRUE
//ELSE
DoReplan := FALSE;
IF AllocationStatus1 = AllocationStatus1::"Finish All" THEN BEGIN

WriteAllocationEntryEnd(EntryNo, EndingDateTime, DoReplan,
ReasonCode,Travel);
CheckRemainingLinkedAllocation(EntryNo); //Possibly bug inside function.
END;
IF AllocationStatus1 = AllocationStatus1::"Finish Part" THEN

ReasonCode,Travel);
IF AllocationStatus = AllocationStatus::"On Hold" THEN BEGIN

//AllocationStatus := AllocationStatus::Finished;
//AllocationStatus := AllocationStatus::"On Hold";
ReasonCode,Travel);
HoldHours += CheckRemainingLinkedAllocation(EntryNo); //15.08.2013 EDMS P8
LaborAllocEntry.GET(EntryNo); //20.07.2013 EDMS P8
ReasonCodeGlobal := ReasonCode;
IF HoldHours > 0 THEN
WriteAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."End Date-Time", HoldHours,
// LaborAllocEntry."Source ID", 0, 0, DoReplan,
AllocationStatus, TRUE); //20.07.2013 EDMS P8
// LaborAllocEntry."Source ID", 0,
LaborAllocEntry."Entry No.", DoReplan, AllocationStatus, FALSE); //20.07.2013 EDMS
P8
LaborAllocEntry."Source ID", 0,
LaborAllocEntry."Entry No.", DoReplan, AllocationStatus,
TRUE,Travel); //15.08.2013 EDMS P8
END;
OnDate := DateTimeMgt.Datetime2Date(EndingDateTime);
OnTime := DateTimeMgt.Datetime2Time(EndingDateTime);
IF NOT ResourceTimeRegMgt.HasTasksInProgress(LaborAllocEntry."Resource No.")
THEN
ResourceTimeRegMgt.StartDefaultIdleTask(LaborAllocEntry."Resource
No.",OnDate,OnTime);
END;
PROCEDURE ProcessBreak@1101908041(StandardCode@1101908004 :
Code[20];ReasonCode@1101908006 : Code[10];BreakHours@1101908005 : Decimal);
VAR
ServStandardEvent@1000 : Record 25006272;
FinishedHours@1101908001 : Decimal;
HoldHours@1101908002 : Decimal;
BEGIN
ServStandardEvent.GET(StandardCode); //12.08.2013 EDMS P8

LaborAllocEntry2.GET(SingleInstanceMgt.GetAllocationEntryNo);
FinishedHours := CalcHourDifference(LaborAllocEntry2."Start Date-Time",
CurrDateTime);
HoldHours := LaborAllocEntry2."Quantity (Hours)" - FinishedHours;
DoReplan := TRUE;
Travel := LaborAllocEntry2.Travel;
WriteAllocationEntryEnd(SingleInstanceMgt.GetAllocationEntryNo, CurrDateTime,
DoReplan, ReasonCode,Travel);
WriteAllocationEntries(LaborAllocEntry2."Resource No.", CurrDateTime,
BreakHours, 2, 0, StandardCode, 0, 0, DoReplan, 0, FALSE,Travel);
WriteAllocationEntries(LaborAllocEntry2."Resource No.", LaborAllocEntry."End
Date-Time", HoldHours,
LaborAllocEntry2."Source Type",
LaborAllocEntry2."Source Subtype",
LaborAllocEntry2."Source ID", 0,
SingleInstanceMgt.GetAllocationEntryNo, DoReplan, -1, FALSE,Travel);
END;
PROCEDURE ProcessHoldLabor@25006002(CurrentDateTime@25006002 : Decimal);

VAR
LaborAllocEntryTmp@25006000 : TEMPORARY Record 25006271;
BEGIN
{
FindSplitEntries(EntryNo, LaborAllocEntryTmp, 0, 1111);
IF LaborAllocEntryTmp.FINDFIRST THEN
REPEAT
IF LaborAllocEntry.GET(LaborAllocEntryTmp."Entry No.") THEN BEGIN
END;
UNTIL LaborAllocEntryTmp.NEXT = 0;
ChangeServiceLineStatus(EntryNo,FALSE);
OnDate := DateTimeMgt.Datetime2Date(CurrentDateTime);
OnTime := DateTimeMgt.Datetime2Time(CurrentDateTime);
IF NOT ResourceTimeRegMgt.HasTasksInProgress(LaborAllocEntryTmp."Resource
No.") THEN
ResourceTimeRegMgt.StartDefaultIdleTask(LaborAllocEntryTmp."Resource
No.",OnDate,OnTime);
}
Hours := CalcHourDifference(CurrentDateTime,LaborAllocEntry."End Date-Time");

IF Hours <= 0 THEN
AskedForAllocationSpliting := TRUE;
DoReplan := TRUE;
IF Resource."No." <> '' THEN
ResourceNo := Resource."No."
ELSE
SingleInstanceMgt.SetDateFilter(DateTimeMgt.Datetime2Date(CurrentDateTime));
OnDate := DateTimeMgt.Datetime2Date(CurrentDateTime);
OnTime := DateTimeMgt.Datetime2Time(CurrentDateTime);
//ResourceTimeRegMgt.FinishDefaultIdleTask(ResourceNo,OnDate,OnTime);
IF (LaborAllocEntry."Start Date-Time" <> CurrentDateTime) OR

(LaborAllocEntry."Quantity (Hours)" <> Hours) THEN BEGIN
ProcessMovement(LaborAllocEntry."Entry No.", ResourceNo,
CurrentDateTime, Hours, 1, AllocationStatus, 1,Travel);
END ELSE BEGIN
WriteAllocationEntries(ResourceNo, CurrentDateTime, Hours,
LaborAllocEntry."Source Type", LaborAllocEntry."Source
Subtype",
AllocationStatus, FALSE,Travel);
END;
IF NOT ResourceTimeRegMgt.HasTasksInProgress(ResourceNo) THEN

ResourceTimeRegMgt.StartDefaultIdleTask(ResourceNo,OnDate,OnTime);
END;
PROCEDURE ChangeStatus@1101908025(VAR LaborAllocEntry@1101908000 : Record

25006271);
BEGIN
LaborAllocEntry.VALIDATE(Status, AllocationStatus);
LaborAllocEntry.VALIDATE("Reason Code", ReasonCodeGlobal);
END;
PROCEDURE ChangeServiceLineStatus@1101908026(EntryNo@1101908001 :
Integer;Remove@1190000 : Boolean);
VAR
ServiceLineTemp@1190007 : TEMPORARY Record 25006146;
PostedServiceHdr@1190003 : Record 25006149;
PostedServiceLine@1190004 : Record 25006150;
PostedServRetHdr@1190005 : Record 25006154;
PostedServRetLine@1190006 : Record 25006155;
LaborAllocApp@1101908002 : Record 25006277;
WorkStatus@1101908006 : Record 25006166;
CurrStatus@1101908005 : Integer;
WorkStatusCode@1190001 : Code[10];
BEGIN
IF LaborAllocEntry."Source Type" <> LaborAllocEntry."Source Type"::"Service
Document" THEN
EXIT;
IF DontChangeServiceStatus THEN
EXIT;
REPEAT
CurrStatus := 999999;
WorkStatusCode := '';
LaborAllocApp2.SETRANGE("Document Type", LaborAllocApp."Document Type");
LaborAllocApp2.SETRANGE("Document No.", LaborAllocApp."Document No.");
IF LaborAllocApp."Document Line No." <> 0 THEN BEGIN
LaborAllocApp2.SETRANGE("Document Line No.", LaborAllocApp."Document
Line No.");
IF Remove THEN
LaborAllocApp2.SETFILTER("Allocation Entry No.", '<>%1', EntryNo);
REPEAT
Resource.GET(LaborAllocApp2."Resource No.");
IF NOT (ServiceScheduleSetup."Only Pers. Affect Doc. Status" AND
(Resource.Type = Resource.Type::Machine)) THEN BEGIN
IF LaborAllocEntry.GET(LaborAllocApp2."Allocation Entry No.")
THEN BEGIN
WorkStatus.RESET;
WorkStatus.SETRANGE("Service Order Status",
LaborAllocEntry.Status);
IF WorkStatus.FINDFIRST THEN;
IF CurrStatus > WorkStatus.Priority THEN BEGIN

CurrStatus := WorkStatus.Priority;
WorkStatusCode := WorkStatus.Code;
END;
END;
END;
IF NOT LaborAllocApp.Posted THEN BEGIN

//Preparing temp variable to be used as parameter
ServiceLineTemp.RESET;
ServiceLineTemp.DELETEALL;
ServiceLine.RESET;
ServiceLine.SETRANGE("Document Type",LaborAllocApp."Document Type");
ServiceLine.SETRANGE("Document No.",LaborAllocApp."Document No.");
REPEAT
ServiceLineTemp.INIT;
ServiceLineTemp := ServiceLine;
ServiceLineTemp.INSERT;
//Updating service line status

ServiceLine.RESET;
ServiceLine.GET(LaborAllocApp."Document Type",
LaborAllocApp."Document No.", LaborAllocApp."Document Line No.");
ServiceLine.Status := WorkStatusCode;
IF NOT GlobDontModifyServLine THEN
ServiceLine.MODIFY(TRUE);
//Updating service line status in temp variable

ServiceLineTemp.GET(LaborAllocApp."Document Type",
LaborAllocApp."Document No.", LaborAllocApp."Document Line No.");
ServiceLineTemp.Status := WorkStatusCode;
ServiceLineTemp.MODIFY(TRUE);
ServiceHdr.GET(ServiceLine."Document Type", ServiceLine."Document
No.");
ChangeServiceHeaderStatus(ServiceHdr,ServiceLineTemp);
END;
END ELSE BEGIN
WorkStatus.RESET;
WorkStatus.SETRANGE("Service Order Status", LaborAllocEntry.Status);
IF WorkStatus.FINDFIRST THEN;
IF NOT LaborAllocApp.Posted THEN BEGIN
ServiceHdr.GET(LaborAllocApp."Document Type", LaborAllocApp."Document
No.");
IF Remove THEN
ServiceHdr.VALIDATE("Work Status Code", '')
ELSE
ServiceHdr.VALIDATE("Work Status Code", WorkStatus.Code);
ServiceHdr.MODIFY(TRUE);
END;
END;
END;
PROCEDURE ChangeServiceHeaderStatusOld@1190019(ServiceHeader@1190000 : Record

25006145;VAR ServiceLine@1190005 : Record 25006146);
VAR
ServiceWorkStatus@1190002 : Record 25006166;
LowestStatus@1190003 : Integer;
StatusCode@1190004 : Code[20];
BEGIN
LowestStatus := 999999;
StatusCode := '';
ServiceLine.RESET;
ServiceLine.SETRANGE("Document Type", ServiceLine."Document Type"::Order);
ServiceLine.SETRANGE("Document No.", ServiceHeader."No.");
ServiceLine.SETRANGE(Type, ServiceLine.Type::Labor);
REPEAT
IF ServiceWorkStatus.GET(ServiceLine.Status) THEN BEGIN
IF ServiceWorkStatus.Priority < LowestStatus THEN BEGIN
LowestStatus := ServiceWorkStatus.Priority;
StatusCode := ServiceWorkStatus.Code;
END;
END;
ServiceHeader.VALIDATE("Work Status Code", StatusCode);

ServiceHeader.MODIFY(TRUE);
END;
PROCEDURE ChangeServiceHeaderStatus@1101904043(ServiceHeader@1190000 : Record

25006145;VAR ServiceLine@1190005 : Record 25006146);
VAR
ServiceWorkStatus@1190002 : Record 25006166;
LowestStatus@1190003 : Integer;
StatusCode@1190004 : Code[20];
BEGIN
LowestStatus := 999999;
StatusCode := '';
WITH LaborAllocApp DO BEGIN

RESET;
SETRANGE("Document Type", ServiceHeader."Document Type");
SETRANGE("Document No.", ServiceHeader."No.");
SETRANGE("Document Line No.", 0);
IF FINDFIRST THEN
REPEAT
Resource.GET("Resource No.");
IF NOT (ServiceScheduleSetup."Only Pers. Affect Doc. Status" AND
(Resource.Type = Resource.Type::Machine)) THEN BEGIN
IF LaborAllocEntry.GET("Allocation Entry No.") THEN BEGIN
ServiceWorkStatus.RESET;
ServiceWorkStatus.SETRANGE("Service Order Status",
LaborAllocEntry.Status);
IF ServiceWorkStatus.FINDFIRST THEN BEGIN
END;
END;
END;
END;
UNTIL NEXT = 0;
END;
ServiceLine.RESET;
ServiceLine.SETRANGE("Document Type", ServiceHeader."Document Type");
ServiceLine.SETRANGE("Document No.", ServiceHeader."No.");
ServiceLine.SETRANGE(Type, ServiceLine.Type::Labor);
REPEAT
IF ServiceWorkStatus.GET(ServiceLine.Status) THEN BEGIN
END;
END;
ServiceHeader.VALIDATE("Work Status Code", StatusCode);

ServiceHeader.MODIFY(TRUE);
END;
PROCEDURE ProcessStartWorkday@1101908030(ResourceNo@1101908002 :
Code[20];StartDateTime@1101908003 : Decimal);
VAR
ServLaborAllocationEntry@25006000 : Record 25006271;
BEGIN
WorkTimeEntry.SETRANGE(Closed, FALSE);
IF WorkTimeEntry.FINDFIRST THEN BEGIN
MESSAGE(STRSUBSTNO(Text120, ResourceNo));
EXIT;
END;
IF WorkTimeEntry.FINDLAST THEN
EntryNo := WorkTimeEntry."Entry No." + 1
ELSE
EntryNo := 1;
WorkTimeEntry.INIT;
WorkTimeEntry."Entry No." := EntryNo;
WorkTimeEntry.VALIDATE("Resource No.", ResourceNo);
WorkTimeEntry.VALIDATE("Worktime Begin", StartDateTime);
WorkTimeEntry.INSERT(TRUE);
OnDate := DateTimeMgt.Datetime2Date(StartDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartDateTime);
ResourceTimeRegMgt.AddWorkTimeRegEntries('STARTWORKTIME',ResourceNo,OnDate,OnTime);
ResourceTimeRegMgt.StartDefaultIdleTask(ResourceNo,OnDate,OnTime);
END;
PROCEDURE ProcessEndWorkday@1101908031(ResourceNo@1101908004 :
Code[20];EndDateTime@1101908000 : Decimal);
VAR
ServLaborAllocationEntryL@1000 : Record 25006271;
ResourceTimeRegMgt@25006000 : Codeunit 25006290;
ServiceSetup@25006001 : Record 25006120;
ServStandardEvent@25006002 : Record 25006272;
BEGIN
ServiceSetup.GET;
DoReplan := FALSE;
OnDate := DateTimeMgt.Datetime2Date(EndDateTime);
OnTime := DateTimeMgt.Datetime2Time(EndDateTime);
//Check for holded labors.

WITH ServLaborAllocationEntryL DO BEGIN //20.07.2013 EDMS P8
RESET;
SETRANGE("Resource No.", ResourceNo);
SETRANGE(Status, Status::"In Progress");
SETRANGE(Status, Status::"On Hold");
IF FINDFIRST THEN
ERROR(Text163);
END;
WITH ServLaborAllocationEntryL DO BEGIN //20.07.2013 EDMS P8

RESET;
SETRANGE("Resource No.", ResourceNo);
SETRANGE(Status, Status::"In Progress");
//SETFILTER(Status,'%1|%2', Status::"In Progress",Status::"On Hold");
SETFILTER("Source ID",'<>%1',ServiceSetup."Default Idle Event");
IF GUIALLOWED THEN BEGIN //11.12.2018 EB.P7
IF CONFIRM(Text129) THEN
REPEAT
WriteAllocationEntryEnd("Entry No.", EndDateTime, DoReplan,
'',ServLaborAllocationEntryL.Travel);
ResourceTimeRegMgt.AddTimeRegEntries('Complete',ServLaborAllocationEntryL,ServLabor
AllocationEntryL."Resource No.",OnDate,OnTime);
UNTIL NEXT = 0
ELSE
ERROR(STRSUBSTNO(Text106, "Source Subtype", "Source ID"));
END ELSE
ERROR(STRSUBSTNO(Text106, "Source Subtype", "Source ID"));
END;
END;
WorkTimeEntry.SETRANGE("Resource No.",ResourceNo);
IF NOT WorkTimeEntry.FINDLAST THEN BEGIN
MESSAGE(STRSUBSTNO(Text119, ResourceNo));
EXIT;
END;
WorkTimeEntry.VALIDATE("Worktime End", EndDateTime);

WorkTimeEntry.VALIDATE("Worked Hours",
CalcHourDifference(WorkTimeEntry."Worktime Begin", EndDateTime));
WorkTimeEntry.VALIDATE(Closed, TRUE);
WorkTimeEntry.MODIFY(TRUE);
ResourceTimeRegMgt.FinishDefaultIdleTask(ResourceNo,OnDate,OnTime);
ResourceTimeRegMgt.AddWorkTimeRegEntries('FINISHWORKTIME',ResourceNo,OnDate,OnTime)
;
END;
PROCEDURE ProcessStartWorkdaySilent@25006003(ResourceNo@1101908002 :
Code[20];StartDateTime@1101908003 : Decimal);
VAR
BEGIN
OnDate := DateTimeMgt.Datetime2Date(StartDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartDateTime);

WorkTimeEntry.SETRANGE(Closed, FALSE);
IF NOT WorkTimeEntry.FINDFIRST THEN BEGIN
IF WorkTimeEntry.FINDLAST THEN
EntryNo := WorkTimeEntry."Entry No." + 1
ELSE
EntryNo := 1;
WorkTimeEntry.INIT;
WorkTimeEntry."Entry No." := EntryNo;
WorkTimeEntry.VALIDATE("Resource No.", ResourceNo);
WorkTimeEntry.VALIDATE("Worktime Begin", StartDateTime);
WorkTimeEntry.INSERT(TRUE);
ResourceTimeRegMgt.AddWorkTimeRegEntries('STARTWORKTIME',ResourceNo,OnDate,OnTime);
END;
END;
PROCEDURE CompareSchedulePassword@1101908028(ResourceNo@1101908001 :
Code[20];SchedulePassword@1101908002 : Text[20]);
BEGIN
IF Resource.GET(ResourceNo) THEN
IF Resource."Serv. Schedule Password" = SchedulePassword THEN
EXIT;
ERROR(Text112);
END;
PROCEDURE CreateFieldText@1101908032(EntryNo@1101908000 : Integer) : Text[250];

VAR
ScheduleCellConfig@1101908003 : Record 25006280;
ServHdr@1101908004 : Record 25006145;
ServLine@1101908005 : Record 25006146;
PostedServHdr@1101908014 : Record 25006149;
PostedServLine@1101908015 : Record 25006150;
ServLaborAllocationDetailLoc@1000 : Record 25006268;
RecordRef@1101908008 : RecordRef;
FieldRef@1101908007 : FieldRef;
EndText@1101908009 : Text[250];
FieldValue@1101908010 : Text[250];
FieldCaption@1101908011 : Text[250];
FieldOption@1101908012 : Text[250];
OptionNumber@1101908013 : Integer;
SourceTypeFilter@1001 : Text;
FieldRefClass@1002 : 'Normal,FlowFilter,FlowField';
BEGIN
ScheduleCellConfig.SETCURRENTKEY(Sequence);
EndText := '';
IF LaborAllocApp.FINDFIRST THEN;
IF ServHdr.GET(LaborAllocApp."Document Type", LaborAllocApp."Document No.")
THEN BEGIN
ServLine.GET(LaborAllocApp."Document Type", LaborAllocApp."Document
No.", LaborAllocApp."Document Line No.");
SourceTypeFilter := FORMAT(DATABASE::"Service Header EDMS")+ '|'+
FORMAT(DATABASE::"Service Line EDMS");
END ELSE
SourceTypeFilter := FORMAT(DATABASE::"Service Header EDMS");
END ELSE
IF PostedServHdr.GET(LaborAllocApp."Document No.") THEN BEGIN
PostedServLine.GET( LaborAllocApp."Document No.",
SourceTypeFilter := FORMAT(DATABASE::"Posted Serv. Order Header")+
'|'+ FORMAT(DATABASE::"Posted Serv. Order Line");
END ELSE
SourceTypeFilter := FORMAT(DATABASE::"Posted Serv. Order Header");
END ELSE
EXIT(LaborAllocEntry."Source ID");
END ELSE BEGIN
StandardEvent.GET(LaborAllocEntry."Source ID");
SourceTypeFilter := FORMAT(DATABASE::"Serv. Standard Event");
END;
//24.10.2013 EDMS P8 >>
IF LaborAllocEntry."Detail Entry No." > 0 THEN
IF ServLaborAllocationDetailLoc.GET(LaborAllocEntry."Detail Entry No.")
THEN BEGIN
IF SourceTypeFilter <> '' THEN
SourceTypeFilter += '|';
SourceTypeFilter += FORMAT(DATABASE::"Serv. Allocation Description");;
END;
ScheduleCellConfig.SETFILTER("Source Type", SourceTypeFilter);
//24.10.2013 EDMS P8 <<
IF ScheduleCellConfig.FINDFIRST THEN
REPEAT
CASE ScheduleCellConfig."Source Type" OF
DATABASE::"Service Header EDMS" :
BEGIN
RecordRef.OPEN(DATABASE::"Service Header EDMS");
RecordRef.GETTABLE(ServHdr);
END;
DATABASE::"Service Line EDMS" :
BEGIN
RecordRef.OPEN(DATABASE::"Service Line EDMS");
RecordRef.GETTABLE(ServLine);
END;
DATABASE::"Posted Serv. Order Header" :
BEGIN
RecordRef.OPEN(DATABASE::"Service Header EDMS");
RecordRef.GETTABLE(PostedServHdr);
END;
DATABASE::"Posted Serv. Order Line" :
BEGIN
RecordRef.OPEN(DATABASE::"Service Line EDMS");
RecordRef.GETTABLE(PostedServLine);
END;
DATABASE::"Serv. Standard Event" :
BEGIN
RecordRef.OPEN(DATABASE::"Serv. Standard Event");
RecordRef.GETTABLE(StandardEvent);
END;
//24.10.2013 EDMS P8 >>
DATABASE::"Serv. Allocation Description" :
BEGIN
RecordRef.OPEN(DATABASE::"Serv. Allocation Description");
RecordRef.GETTABLE(ServLaborAllocationDetailLoc);
END;
//24.10.2013 EDMS P8 <<
END;
FieldRef := RecordRef.FIELD(ScheduleCellConfig."Source Ref. No.");
// 14.05.2014 Elva Baltic P21 #S0102 MMG7.00 >>

EVALUATE(FieldRefClass,FORMAT(FieldRef.CLASS));
IF FieldRefClass = FieldRefClass::FlowField THEN
FieldRef.CALCFIELD;
// 14.05.2014 Elva Baltic P21 #S0102 MMG7.00 <<
FieldValue := FORMAT(FieldRef.VALUE);
FieldOption := FieldRef.OPTIONCAPTION;
IF FieldOption <> '' THEN BEGIN

EVALUATE(OptionNumber, FieldValue);
FieldValue := SELECTSTR(OptionNumber + 1, FieldOption);
END;
IF ScheduleCellConfig.Prefix <> '' THEN

FieldCaption := ScheduleCellConfig.Prefix + ': '
ELSE
FieldCaption := '';
IF FieldValue <> '' THEN BEGIN

IF EndText = '' THEN
EndText := COPYSTR(FieldCaption + FieldValue, 1, 250)
ELSE
EndText := COPYSTR(EndText + '; ' + FieldCaption + FieldValue, 1,
250);
END;
RecordRef.CLOSE;
UNTIL ScheduleCellConfig.NEXT = 0;
EXIT(EndText);
END;
PROCEDURE CreateNewServiceDocument@1101908038(DocumentType@1190000 :
'Quote,Order,Return Order') : Code[20];
VAR
ServHeader@1101908000 : Record 25006145;
BEGIN
CLEAR(ServHeader);
ServHeader.INIT;
ServHeader."Document Type" := DocumentType;
ServHeader.INSERT(TRUE);
COMMIT;
CASE DocumentType OF
DocumentType::Quote:
PAGE.RUNMODAL(PAGE::"Service Quote EDMS", ServHeader);
DocumentType::Order:
PAGE.RUNMODAL(PAGE::"Service Order EDMS", ServHeader);
END;
EXIT(ServHeader."No.");
END;
PROCEDURE DeleteAllocationFromServLines@1101908040(ServLine@1101908000 : Record

25006146);
VAR
BEGIN
// 18.12.2014 Elva Baltic P21 #E0003 >>
LaborAllocApp.SETRANGE("Document Type", ServLine."Document Type");
LaborAllocApp.SETRANGE("Document No.", ServLine."Document No.");
LaborAllocApp.SETRANGE("Document Line No.", ServLine."Line No.");
IF LaborAllocApp.FINDSET THEN
REPEAT
// 18.12.2014 Elva Baltic P21 #E0003 <<
LaborAllocApp.SETRANGE("Document Type", ServLine."Document Type");
LaborAllocApp.SETRANGE("Document No.", ServLine."Document No.");
LaborAllocApp.SETRANGE("Document Line No.", ServLine."Line No.");
IF LaborAllocApp.FINDFIRST THEN BEGIN
IF GUIALLOWED THEN
IF NOT CONFIRM(Text117) THEN
ERROR(Text118);
REPEAT
IF LaborAllocEntry.GET(LaborAllocApp."Allocation Entry No.") THEN
ERROR(Text116);
LaborAllocAppTemp := LaborAllocApp;
LaborAllocAppTemp.INSERT;
END;
IF LaborAllocAppTemp.FINDFIRST THEN //tempp2

REPEAT
DeleteAllocationEntry(LaborAllocEntry2, LaborAllocApp2,
LaborAllocAppTemp."Allocation Entry No.", 11111);
UNTIL LaborAllocAppTemp.NEXT = 0;
END;
PROCEDURE DeleteAllocationFromServHdr@1190037(ServHdr@1101908000 : Record

25006145);
VAR
BEGIN
LaborAllocApp.SETRANGE("Document Type", ServHdr."Document Type");
LaborAllocApp.SETRANGE("Document No.", ServHdr."No.");
LaborAllocApp.SETRANGE("Document Line No.", 0);
ERROR(Text118);
REPEAT
IF LaborAllocEntry.GET(LaborAllocApp."Allocation Entry No.") THEN
ERROR(Text116);
END;
IF LaborAllocAppTemp.FINDFIRST THEN //tempp2

REPEAT
DeleteAllocationEntry(LaborAllocEntry2, LaborAllocApp2,
LaborAllocAppTemp."Allocation Entry No.", 11111);
END;
PROCEDURE ModifyReason@1101908042(VAR LaborAllocEntry@1101908000 : Record

25006271;ReasonCode@1101908001 : Code[10]);
BEGIN
LaborAllocEntry."Reason Code" := ReasonCode;
END;
PROCEDURE PostingServLine@1101908044(ServiceLine@1101908000 : Record

25006146;NewOrderNo@1101908001 : Code[20]);
VAR
BEGIN
IF ServiceLine.Type <> ServiceLine.Type::Labor THEN
EXIT;
LaborAllocApp.LOCKTABLE;
LaborAllocEntry.LOCKTABLE;
LaborAllocApp.SETRANGE("Document Type", ServiceLine."Document Type");
LaborAllocApp.SETRANGE("Document No.", ServiceLine."Document No.");
LaborAllocApp.SETRANGE("Document Line No.", ServiceLine."Line No.");
EXIT
ELSE
REPEAT
IF LaborAllocEntry.GET(LaborAllocApp."Allocation Entry No.") THEN BEGIN
IF (LaborAllocEntry.Status <> LaborAllocEntry.Status::Finished) AND
ServiceScheduleSetup."Post Only When Finished" THEN
ERROR(STRSUBSTNO(Text115, ServiceLine."Line No."));
LaborAllocEntryTemp := LaborAllocEntry;
END;
IF LaborAllocAppTemp.FINDFIRST THEN
REPEAT
LaborAllocApp.GET(LaborAllocAppTemp."Allocation Entry No.",
LaborAllocAppTemp."Document Type",
LaborAllocAppTemp."Document No.",
LaborAllocAppTemp."Document Line No.", LaborAllocAppTemp."Line No.");
REPEAT
IF LaborAllocEntry.GET(LaborAllocEntryTemp."Entry No.") THEN
LaborAllocEntry.DELETE;
REPEAT
LaborAllocEntry.TRANSFERFIELDS(LaborAllocEntryTemp);
LaborAllocEntry."Source ID" := NewOrderNo;
REPEAT
LaborAllocApp.TRANSFERFIELDS(LaborAllocAppTemp);
LaborAllocApp."Document No." := NewOrderNo;
LaborAllocApp.Posted := TRUE;
END;
PROCEDURE PostingServHdr@1190036(ServiceHdr@1101908000 : Record

25006145;NewOrderNo@1101908001 : Code[20]);
VAR
BEGIN
ServiceSetup.GET;
LaborAllocApp.LOCKTABLE;
LaborAllocEntry.LOCKTABLE;
LaborAllocApp.SETRANGE("Document Type", ServiceHdr."Document Type");
LaborAllocApp.SETRANGE("Document No.", ServiceHdr."No.");
EXIT
ELSE
REPEAT
IF LaborAllocEntry.GET(LaborAllocApp."Allocation Entry No.") THEN BEGIN
IF (LaborAllocEntry.Status <> LaborAllocEntry.Status::Finished) AND
ServiceScheduleSetup."Post Only When Finished" THEN
ERROR(STRSUBSTNO(Text141, ServiceHdr."No."));
LaborAllocEntryTemp := LaborAllocEntry;
END;
REPEAT
LaborAllocApp.GET(LaborAllocAppTemp."Allocation Entry No.",
LaborAllocAppTemp."Document Type",
LaborAllocAppTemp."Document No.",
LaborAllocAppTemp."Document Line No.",
LaborAllocAppTemp."Line No.");
REPEAT
IF LaborAllocEntry.GET(LaborAllocEntryTemp."Entry No.") THEN
LaborAllocEntry.DELETE;
REPEAT
LaborAllocEntry := LaborAllocEntryTemp;
LaborAllocEntry."Source ID" := NewOrderNo;
REPEAT
LaborAllocApp := LaborAllocAppTemp;
LaborAllocApp."Document No." := NewOrderNo;
LaborAllocApp.Posted := TRUE;
END;
PROCEDURE ClearAllocationEntry@1101908045(EntryNo@1101908000 :
Integer;TimeCompensateByMoveOtherAlloc@1000000000 : Boolean);
VAR
BEGIN
EXIT;
IF TimeCompensateByMoveOtherAlloc THEN //15.04.2013 EDMS P8

ReplanEntries(LaborAllocEntry."Resource No.", LaborAllocEntry."End Date-
Time",
-LaborAllocEntry."Quantity (Hours)",
LaborAllocEntry."Source Subtype", LaborAllocEntry."Source ID");
LaborAllocEntry."Quantity (Hours)" := 0;
LaborAllocEntry."End Date-Time" := LaborAllocEntry."Start Date-Time";
LaborAllocEntry."Resource No." := '';
LaborAllocEntry."User ID" := USERID;
LaborAllocEntry.VALIDATE("Applies-to Entry No.", 0); //14.03.2014 Elva
Baltic P8 #S0003 MMG7.00
LaborAllocEntry.Status := LaborAllocEntry.Status::Pending;
LaborAllocEntry."Reason Code" := '';
END;
PROCEDURE ControlLaborSequence@1101908047(SourceSubtype@1101908000 :
'Quote,Order';SourceID@1101908001 : Code[20];LineNo@1101908003 :
Integer;StartingDateTime@1101908002 : Decimal) : Boolean;
VAR
BEGIN
IF NOT ServiceScheduleSetup."Control Labor Sequence" THEN
EXIT;
LaborAllocAppLoc.SETRANGE("Document Type", SourceSubtype);
LaborAllocAppLoc.SETRANGE("Document No.", SourceID);
LaborAllocAppLoc.SETFILTER("Document Line No.", '<%1', LineNo);
REPEAT
IF LaborAllocEntryLoc.GET(LaborAllocAppLoc."Allocation Entry No.") THEN
IF (StartingDateTime < LaborAllocEntryLoc."Start Date-Time") AND NOT
(AlreadyAskedAboutSequence) THEN BEGIN
IF CONFIRM(Text122) THEN
EXIT(TRUE)
ELSE
ERROR(Text124);
AlreadyAskedAboutSequence := TRUE;
END;
UNTIL LaborAllocAppLoc.NEXT = 0;
EXIT(TRUE);
END;
PROCEDURE ControlSkills@1101908048(SourceSubtype@1101908006 :
'Quote,Order';SourceID@1101908005 : Code[20];LineNo@1101908004 :
Integer;ResourceNo@1101908003 : Code[20]);
VAR
ResourceSkill@1101908007 : Record 25006160;
LaborSkill@1101908008 : Record 25006161;
MissedSkills@1101908009 : Text[1000];
ResourceList@1190000 : Text[500];
BEGIN
IF ServiceScheduleSetup."Control Skills" = ServiceScheduleSetup."Control

Skills"::No THEN
EXIT;
IF (ServiceScheduleSetup."Control Skills" = ServiceScheduleSetup."Control
Skills"::"Only Planning") AND
(ScheduleAction = ScheduleAction::"Time Registration")
THEN
EXIT;
MissedSkills := '';
IF ServiceLineLoc.GET(SourceSubtype, SourceID, LineNo) THEN BEGIN

IF ServiceLineLoc.Type <> ServiceLineLoc.Type::Labor THEN
EXIT;
LaborSkill.RESET;
LaborSkill.SETRANGE("Labor Code", ServiceLineLoc."No.");
IF LaborSkill.COUNT = 0 THEN
EXIT;
ResourceSkill.RESET;
ResourceSkill.SETRANGE("Resource No.", ResourceNo);
IF LaborSkill.FINDFIRST THEN
REPEAT
ResourceSkill.SETRANGE("Skill Code", LaborSkill."Skill Code");
IF NOT ResourceSkill.FINDFIRST THEN BEGIN
IF MissedSkills <> '' THEN
MissedSkills += '; ';
MissedSkills += LaborSkill."Skill Code";
END;
UNTIL LaborSkill.NEXT = 0;
IF (MissedSkills <> '') AND NOT(AlreadyAskedAboutSkills) THEN BEGIN

IF NOT CONFIRM(STRSUBSTNO(Text125, ResourceNo, MissedSkills)) THEN BEGIN
ResourceList := '';
ResourceList := AvailableResourceWithSkills(ResourceNo, LaborSkill);
IF ResourceList <> '' THEN
ERROR(STRSUBSTNO(Text139, ResourceList))
ELSE
ERROR(Text124);
END;
AlreadyAskedAboutSkills := TRUE;
END;
END;
END;
PROCEDURE AvailableResourceWithSkills@1190033(ResourceNo@1190001 : Code[20];VAR

LaborSkill@1190002 : Record 25006161) : Text[500];
VAR
ScheduleResourceGroupSpec@1190000 : Record 25006275;
ScheduleResourceGroupSpec2@1190003 : Record 25006275;
ResourceTemp@1190006 : TEMPORARY Record 156;
ResourceList@1190007 : Text[500];
ResourceAccepted@1190005 : Boolean;
i@1190008 : Integer;
BEGIN
ResourceTemp.RESET;
ResourceTemp.DELETEALL;
ResourceList := '';
ScheduleResourceGroupSpec.RESET;
ScheduleResourceGroupSpec.SETRANGE("Resource No.", ResourceNo);
IF ScheduleResourceGroupSpec.FINDFIRST THEN
REPEAT
ScheduleResourceGroupSpec2.RESET;
ScheduleResourceGroupSpec2.SETRANGE("Group Code",
ScheduleResourceGroupSpec."Group Code");
ScheduleResourceGroupSpec2.SETFILTER("Resource No.", '<>%1', ResourceNo);
IF ScheduleResourceGroupSpec2.FINDFIRST THEN
REPEAT
ResourceAccepted := TRUE;
ResourceSkill.SETRANGE("Resource No.",
ScheduleResourceGroupSpec2."Resource No.");
IF LaborSkill.FINDFIRST THEN
REPEAT
ResourceSkill.SETRANGE("Skill Code", LaborSkill."Skill Code");
IF NOT ResourceSkill.FINDFIRST THEN
ResourceAccepted := FALSE;
UNTIL LaborSkill.NEXT = 0;
IF ResourceAccepted THEN BEGIN
ResourceTemp.INIT;
ResourceTemp."No." := ScheduleResourceGroupSpec2."Resource No.";
IF ResourceTemp.INSERT THEN;
END;
UNTIL ScheduleResourceGroupSpec2.NEXT = 0;
UNTIL ScheduleResourceGroupSpec.NEXT = 0;
i := 0;
IF ResourceTemp.FINDFIRST THEN
REPEAT
IF ResourceList <> '' THEN
ResourceList += ';';
ResourceList += ResourceTemp."No.";
i += 1;
UNTIL (ResourceTemp.NEXT = 0) OR (i = 5);
EXIT(ResourceList);
END;
PROCEDURE FromQuoteToOrder@1101908049(ServiceLine@1101908000 : Record

25006146;NewServiceNo@1101908003 : Code[20]);
VAR
LaborAllocAppLocTemp@1101908004 : TEMPORARY Record 25006277;
BEGIN
LaborAllocAppLoc.SETRANGE("Document Type", ServiceLine."Document Type");
LaborAllocAppLoc.SETRANGE("Document No.", ServiceLine."Document No.");
LaborAllocAppLoc.SETRANGE("Document Line No.", ServiceLine."Line No.");
REPEAT
LaborAllocAppLocTemp := LaborAllocAppLoc;
LaborAllocAppLocTemp."Document Type" := LaborAllocAppLocTemp."Document
Type"::Order;
LaborAllocAppLocTemp."Document No." := NewServiceNo;
LaborAllocAppLocTemp.INSERT;
IF LaborAllocEntryLoc.GET(LaborAllocAppLoc."Allocation Entry No.") THEN
BEGIN
LaborAllocEntryLoc."Source Subtype" := LaborAllocEntryLoc."Source
Subtype"::Order;
LaborAllocEntryLoc."Source ID" := NewServiceNo;
LaborAllocEntryLoc.MODIFY;
END;
UNTIL LaborAllocAppLoc.NEXT = 0
ELSE
EXIT;
LaborAllocAppLoc.SETRANGE("Document Type", ServiceLine."Document Type");
LaborAllocAppLoc.SETRANGE("Document No.", ServiceLine."Document No.");
LaborAllocAppLoc.SETRANGE("Document Line No.", ServiceLine."Line No.");
LaborAllocAppLoc.DELETEALL;
IF LaborAllocAppLocTemp.FINDFIRST THEN
REPEAT
LaborAllocAppLoc := LaborAllocAppLocTemp;
LaborAllocAppLoc.INSERT(TRUE);
UNTIL LaborAllocAppLocTemp.NEXT = 0;
END;
PROCEDURE CheckRemainingLinkedAllocation@1101908050(EntryNo@1101908000 :
Integer) RetValue : Decimal;
VAR
BEGIN
//Possibly bug inside function.
//RetValue - returns deleted hours
LaborAllocEntryTemp.SETCURRENTKEY("Resource No.", "End Date-Time");
LaborAllocEntryTemp.SETFILTER(Status, '%1|%2|%3',
LaborAllocEntryTemp.Status::Pending, LaborAllocEntryTemp.Status::"On Hold",
LaborAllocEntryTemp.Status::"In Progress");
IF LaborAllocEntryTemp.FINDFIRST THEN BEGIN

REPEAT
RetValue += LaborAllocEntryTemp."Quantity (Hours)";
DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp,
LaborAllocEntryTemp."Entry No.", 11111);
END;
EXIT(RetValue);
END;
PROCEDURE CheckLaborStatus@1101908056(LaborAllocEntryLoc@1101908000 : Record

25006271) : Boolean;
VAR
StatusFinishProgress@1101908001 : Integer;
StatusPendingHold@1101908002 : Integer;
BEGIN
StatusFinishProgress := 0;
StatusPendingHold := 0;
LaborAllocEntryLoc.RESET;
IF LaborAllocEntryLoc.FINDFIRST THEN
REPEAT
IF LaborAllocEntryLoc.Status IN [LaborAllocEntryLoc.Status::Pending,
LaborAllocEntryLoc.Status::"On Hold"] THEN
StatusPendingHold +=1;
IF LaborAllocEntryLoc.Status IN [LaborAllocEntryLoc.Status::Finished,
LaborAllocEntryLoc.Status::"In Progress"] THEN
StatusFinishProgress +=1;
UNTIL LaborAllocEntryLoc.NEXT = 0;
IF (StatusFinishProgress > 0) AND (StatusPendingHold > 0) THEN

EXIT(TRUE)
ELSE
EXIT(FALSE);
END;
PROCEDURE JoinAllocationEntries@1101908052(ResourceNo@1101908001 :
Code[20];StartingDateTime@1101908002 : Decimal);
VAR
LaborAllocEntryLoc2@1101908009 : Record 25006271;
LaborAllocEntryTemp2@1101908004 : TEMPORARY Record 25006271;
LaborAllocEntryTemp3@1101908006 : TEMPORARY Record 25006271;
JoinLaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
AlreadyJoinLaborAllocEntryTemp@1101908007 : TEMPORARY Record 25006271;
JoinTotalHours@1101908008 : Decimal;
EndDateTime@1101908010 : Decimal;
BEGIN
LaborAllocEntryTemp2.RESET;
LaborAllocEntryTemp2.DELETEALL;
AlreadyJoinLaborAllocEntryTemp.RESET;
AlreadyJoinLaborAllocEntryTemp.DELETEALL;
LaborAllocEntryLoc.SETCURRENTKEY("Resource No.", "Start Date-Time");
LaborAllocEntryLoc.SETRANGE("Resource No.", ResourceNo);
LaborAllocEntryLoc.SETFILTER("Start Date-Time", '>=%1', StartingDateTime);
//21.07.2015 EB.P7 #Performance issue >>
IF SingleInstanceMgt.GetAllocationEntryNo <> 0 THEN
LaborAllocEntryLoc.SETRANGE("Entry No.",
SingleInstanceMgt.GetAllocationEntryNo);
//21.07.2015 EB.P7 #Performance issue <<
REPEAT
IF NOT LaborAllocEntryTemp2.GET(LaborAllocEntryLoc."Entry No.") THEN
BEGIN
LaborAllocEntryTemp.DELETEALL;
LaborAllocEntryTemp3.RESET;
LaborAllocEntryTemp3.DELETEALL;
FindSplitEntries(LaborAllocEntryLoc."Entry No.", LaborAllocEntryTemp,
0, 1111);
REPEAT
IF NOT LaborAllocEntryTemp2.GET(LaborAllocEntryTemp."Entry No.")
THEN BEGIN
LaborAllocEntryTemp2 := LaborAllocEntryTemp;
LaborAllocEntryTemp2.INSERT;
END;
IF NOT LaborAllocEntryTemp3.GET(LaborAllocEntryTemp."Entry No.")
THEN BEGIN
LaborAllocEntryTemp3 := LaborAllocEntryTemp;
LaborAllocEntryTemp3.INSERT;
END;

REPEAT
JoinTotalHours := 0;
IF NOT AlreadyJoinLaborAllocEntryTemp.GET(LaborAllocEntryTemp."Entry
No.") THEN BEGIN
JoinLaborAllocEntryTemp.RESET;
JoinLaborAllocEntryTemp.DELETEALL;
JoinLaborAllocEntryTemp := LaborAllocEntryTemp;
JoinLaborAllocEntryTemp.INSERT;
FindJoinEntries(JoinLaborAllocEntryTemp."End Date-Time",
LaborAllocEntryTemp3, JoinLaborAllocEntryTemp);
EndDateTime := 0;
IF JoinLaborAllocEntryTemp.FINDFIRST THEN
REPEAT
IF NOT
AlreadyJoinLaborAllocEntryTemp.GET(JoinLaborAllocEntryTemp."Entry No.") THEN BEGIN
AlreadyJoinLaborAllocEntryTemp := JoinLaborAllocEntryTemp;
AlreadyJoinLaborAllocEntryTemp.INSERT;
END;
JoinTotalHours += JoinLaborAllocEntryTemp."Quantity (Hours)";
IF JoinLaborAllocEntryTemp."End Date-Time" > EndDateTime THEN
EndDateTime := JoinLaborAllocEntryTemp."End Date-Time";
UNTIL JoinLaborAllocEntryTemp.NEXT = 0;
JoinLaborAllocEntryTemp.RESET;
IF JoinLaborAllocEntryTemp.COUNT > 1 THEN BEGIN
LaborAllocEntryLoc2.GET(LaborAllocEntryTemp."Entry No.");
LaborAllocEntryLoc2."End Date-Time" := EndDateTime;
LaborAllocEntryLoc2."Quantity (Hours)" := (EndDateTime -
LaborAllocEntryLoc2."Start Date-Time") / 3.6;
LaborAllocEntryLoc2.MODIFY;
IF JoinLaborAllocEntryTemp.FINDFIRST THEN
REPEAT
IF JoinLaborAllocEntryTemp."Entry No." <>
LaborAllocEntryTemp."Entry No." THEN BEGIN
IF LaborAllocEntryLoc2.GET(JoinLaborAllocEntryTemp."Entry
No.") THEN;
ChangeApplyTo(LaborAllocEntryLoc2."Entry No.",
LaborAllocEntryLoc2."Applies-to Entry No.");
LaborAllocEntryLoc2.DELETE;
LaborAllocAppLoc.SETRANGE("Allocation Entry No.",
JoinLaborAllocEntryTemp."Entry No.");
LaborAllocAppLoc.DELETEALL(TRUE);
END;
UNTIL JoinLaborAllocEntryTemp.NEXT = 0;
END;
END;
END;
END;
PROCEDURE FindJoinEntries@1101908053(StartingDateTime@1101908000 : Decimal;VAR

LaborAllocEntryLoc@1101908001 : Record 25006271;VAR
JoinLaborAllocEntry@1101908002 : Record 25006271);
BEGIN
IF JoinLaborAllocEntry.FINDFIRST THEN;
LaborAllocEntryLoc.SETCURRENTKEY("Resource No.", "Start Date-Time");
LaborAllocEntryLoc.SETRANGE("Start Date-Time", StartingDateTime);
LaborAllocEntryLoc.SETRANGE(Status, JoinLaborAllocEntry.Status);
REPEAT
IF NOT JoinLaborAllocEntry.GET(LaborAllocEntryLoc."Entry No.") THEN BEGIN
JoinLaborAllocEntry.INIT;
JoinLaborAllocEntry := LaborAllocEntryLoc;
JoinLaborAllocEntry.INSERT;
FindJoinEntries(LaborAllocEntryLoc."End Date-Time", LaborAllocEntryLoc,
JoinLaborAllocEntry);
END;
END;
PROCEDURE CheckUserRightsInit@1101901001();
BEGIN
CLEAR(isOperAllowedChecked);
CLEAR(OperationMainCode);
CLEAR(OperAllowed);
CLEAR(LaborAllocationEntryPrevTmp);
LaborAllocationEntryPrevTmp.DELETEALL;
LaborAllocEntryPrevStatus := -1;
END;
PROCEDURE CheckUserRights@1101908054(WhatAllow@1101908000 :
'View,Time,Planning,All') : Boolean;
BEGIN
IF UserSetup.GET(USERID) THEN BEGIN
CASE WhatAllow OF
WhatAllow::View:
IF UserSetup."Allow Use Service Schedule" IN [UserSetup."Allow Use
Service Schedule"::" "] THEN BEGIN
ErrorWithRefresh(Text128);
EXIT(FALSE);
END;
WhatAllow::Time:
Service Schedule"::" ",
UserSetup."Allow Use
Service Schedule"::"View Only"] THEN BEGIN
EXIT(FALSE);
END;
WhatAllow::Planning:
Service Schedule"::"View Only",
Service Schedule"::"Time Registration"] THEN BEGIN
IF SingleInstanceMgt.GetTimeJournalFlag THEN
EXIT(TRUE);
EXIT(FALSE);
END;
WhatAllow::All:
Service Schedule"::"View Only",
Service Schedule"::"Time Registration",
Service Schedule"::Planning]
THEN
EXIT(FALSE);
END;
END ELSE BEGIN
EXIT(FALSE);
END;
EXIT(TRUE);
END;
PROCEDURE CheckUserRightsAdv@1101904034(Operation@1101908000 :
Integer;LaborAllocationEntryPar@1101904000 : Record 25006271) : Boolean;
BEGIN
// it is atvanced version of CheckUserRights
// Operation codes:
// 0 view; 1 - time registration; 2 - Planning; 3 - ; 4 - BREAK; 100 -
allocate lines; 110 - allocate header; 120 - ALLOCATE standart event
// 200 - spliting
// 300 - move; 310 - change end time of finished
// 400 - delete entry
// due to last requirements 20.11.2013 is changed a bit operations: 300 and
310 allowed do with rights same to operation=1
// It is important to understand that function call mostly happenes at
operation right before actual write to db, so
// variable LaborAllocEntryPrevStatus is important in taking of decision
IF isOperAllowedChecked AND (OperationMainCode = Operation) AND

(LaborAllocEntryPrevStatus = LaborAllocationEntryPar.Status) THEN
EXIT(OperAllowed);
OperationMainCode := Operation;
OperAllowed := FALSE;
isOperAllowedChecked := TRUE;
LaborAllocationEntryPrevTmp.TRANSFERFIELDS(LaborAllocationEntryPar);
LaborAllocEntryPrevStatus := LaborAllocationEntryPar.Status;
WITH LaborAllocationEntryPar DO BEGIN
CASE Operation OF
0:
OperAllowed := CheckUserRights(0);
1:
2: BEGIN
END;
3: BEGIN
END;
4: BEGIN
IF "Source Type" <> "Source Type"::"Service Document" THEN
ERROR(Text108);
IF Status <> Status::"In Progress" THEN
ERROR(Text111);
END;
100: BEGIN
IF ServiceScheduleSetup."Serv. Document Alloc. Method" =
ServiceScheduleSetup."Serv. Document Alloc. Method"::Header THEN
ERROR(Text142);
END;
110: BEGIN
IF ServiceScheduleSetup."Serv. Document Alloc. Method" =
ServiceScheduleSetup."Serv. Document Alloc. Method"::Line THEN
ERROR(Text142);
END;
120: BEGIN
END;
200: BEGIN
IF NOT ((Status = Status::Pending) OR
(Status = Status::"On Hold"))
THEN
ERROR(STRSUBSTNO(Text123, Status));
LaborAllocApp.SETRANGE("Allocation Entry No.", "Entry No.");
ERROR(Text134);
END;
300: BEGIN
OperAllowed := CheckUserRights(2); //20.11.2013 EDMS P8
IF OperAllowed THEN
IF Status IN [Status::"In Progress", Status::Finished] THEN BEGIN
OperAllowed := FALSE;
IF NOT OperAllowed THEN BEGIN
ErrorWithRefresh(Text128); //22.11.2013 EDMS P8
END;
END;
END;
310: BEGIN
IF ("Source Type" <> "Source Type"::"Service Document") OR
(Status <> Status::Finished)
THEN
END;
400: BEGIN
IF (Status = Status::Finished) OR
(Status = Status::"In Progress")
THEN
IF NOT CheckUserRights(3) THEN
ERROR(STRSUBSTNO(Text114, FORMAT(Status)))
ELSE
IF NOT CONFIRM(STRSUBSTNO(Text130, FORMAT(Status))) THEN
ERROR(STRSUBSTNO(Text114, FORMAT(Status)));
END;
END;
END;
EXIT(OperAllowed);
END;
PROCEDURE FindServAllocAplicationEntries@1101908055(VAR
LaborAllocAppLoc@1101908000 : Record 25006277;DocumentType@1101908001 :
Order';DocumentNo@1101908002 : Code[20]);
BEGIN
LaborAllocAppLoc.SETRANGE("Document Type", DocumentType);
LaborAllocAppLoc.SETRANGE("Document No.", DocumentNo);
END;
PROCEDURE FindServAllocationEntries@1190041(VAR LaborAllocLoc@1101908000 :

Record 25006271;DocumentType@1101908001 : 'Quote,Order,Invoice,Credit Memo,Blanket
Order,Return Order';DocumentNo@1101908002 : Code[20]);
BEGIN
LaborAllocLoc.SETRANGE("Source Type", LaborAllocLoc."Source Type"::"Service
Document");
LaborAllocLoc.SETRANGE("Source Subtype", DocumentType);
LaborAllocLoc.SETRANGE("Source ID", DocumentNo);
END;
PROCEDURE CheckForCorrectServHeaderLine@1101908057(ServiceHdr@1101908000 :
Record 25006145;VAR ServiceLine@1101908001 : Record
25006146;WhatAllocate@1101908004 : 'Header,Line');
VAR
BEGIN
// CASE WhatAllocate OF
// WhatAllocate::Header:
// BEGIN
// LaborAllocEntryLoc.RESET;
// LaborAllocEntryLoc.SETRANGE("Source Subtype", ServiceHdr."Document
Type");
// LaborAllocEntryLoc.SETRANGE("Source ID", ServiceHdr."No.");
// IF LaborAllocEntryLoc.FINDFIRST THEN
// IF GUIALLOWED THEN
// IF NOT CONFIRM(STRSUBSTNO(Text131, ServiceHdr."Document Type",
ServiceHdr."No.")) THEN
// ERROR(Text150);
// END;
// WhatAllocate::Line:
// BEGIN
// IF ServiceLine.FINDFIRST THEN BEGIN
// DocumentNo := ServiceLine."Document No.";
// REPEAT
// IF DocumentNo <> ServiceLine."Document No." THEN
// ERROR(Text133);
// UNTIL ServiceLine.NEXT = 0;
// END;
// LaborAllocEntryLoc.RESET;
// LaborAllocEntryLoc.SETRANGE("Source Subtype", ServiceLine."Document
Type"); //12.12.2014 EB.P8
// LaborAllocEntryLoc.SETRANGE("Source ID", ServiceLine."Document No.");
// IF LaborAllocEntryLoc.FINDFIRST THEN
// IF GUIALLOWED THEN
// IF NOT CONFIRM(STRSUBSTNO(Text131, ServiceLine."Document Type",
ServiceLine."Document No.")) THEN
// ERROR(Text150);
// END;
// END;
END;
PROCEDURE IsResourceWorkingTime@1101908058(ResourceNo@1101908000 :
Code[20];CheckDate@1101908001 : Date) : Boolean;
VAR
BEGIN
IF ResourceCalendarChange.GET(ResourceNo, CheckDate) THEN BEGIN
EXIT(FALSE)
ELSE
EXIT(TRUE);
END;
ServiceHour.RESET;
ServiceHour.SETFILTER("Starting Date", '''''|<=%1', CheckDate);
ServiceHour.SETFILTER("Ending Date", '''''|>=%1', CheckDate);
ServiceHour.SETRANGE(Day, DATE2DWY(CheckDate, 1) - 1);
IF NOT ServiceHour.FINDLAST THEN
EXIT(FALSE);
EXIT(TRUE);
END;
PROCEDURE GetResourceWorkplace@1101908059(ResourceNo@1101908001 :
Code[20];CheckDate@1101908000 : Date) : Code[10];
VAR
WorkplaceResource@1101908002 : Record 25006285;
BEGIN
WorkplaceResource.RESET;
WorkplaceResource.SETRANGE("Resource No.", ResourceNo);
WorkplaceResource.SETFILTER("Starting Date", '''''|<=%1', CheckDate);
WorkplaceResource.SETFILTER("Ending Date", '''''|>=%1', CheckDate);
IF WorkplaceResource.FINDLAST THEN
EXIT(WorkplaceResource."Workplace Code")
ELSE
EXIT('');
END;
PROCEDURE GetResourceSkills@1190028(ResourceNo@1101908001 : Code[20];VAR
ResourceSkill@1101908000 : Record 25006160) : Code[10];
VAR
BEGIN
ResourceSkill.SETRANGE("Resource No.", ResourceNo);
END;
PROCEDURE GetResourceShift@1190029(ResourceNo@1101908001 : Code[20]) :

Code[10];
VAR
BEGIN
IF Resource.GET(ResourceNo) THEN
EXIT(Resource."Service Work Group Code")
ELSE
EXIT('');
END;
PROCEDURE GroupResourceCodeBuffer@1190020(VAR ResourceCodeBuffer@1190001 :

Record 25006270;CurrDate@1190000 : Date;GroupBy@1190002 : '
,Workplace,Skill,Shift');
VAR
Workplace@1190004 : Record 25006284;
BEGIN
CASE GroupBy OF
GroupBy::Workplace:
GroupResourceByWorkplaces(ResourceCodeBuffer,CurrDate);
GroupBy::Skill:
BEGIN
GroupResourceBySkills(ResourceCodeBuffer,CurrDate);
END;
GroupBy::Shift:
BEGIN
GroupResourceByShifts(ResourceCodeBuffer,CurrDate);
END;
ELSE
EXIT;
END
END;
PROCEDURE GroupResourceByWorkplaces@1190022(VAR ResourceCodeBuffer@1190001 :

Record 25006270;CurrDate@1190000 : Date);
VAR
Workplace@1190004 : Record 25006284;
codex@1190002 : Code[10];
textx@1190005 : Text[30];
BEGIN
REPEAT
WorkplaceResource.SETRANGE("Resource No.", ResourceCodeBuffer.Code);
IF CurrDate <> 0D THEN BEGIN
WorkplaceResource.SETFILTER("Starting Date", '''''|<=%1', CurrDate);
WorkplaceResource.SETFILTER("Ending Date", '''''|>=%1', CurrDate);
END;
IF WorkplaceResource.FINDLAST THEN BEGIN
ResourceCodeBuffer."Code 2" := WorkplaceResource."Workplace Code";
ResourceCodeBuffer."Applies-to Code" := WorkplaceResource."Workplace
Code";
ResourceCodeBuffer.MODIFY;
Workplace.GET(WorkplaceResource."Workplace Code");
Workplace.MARK(TRUE);
END;
Workplace.MARKEDONLY(TRUE);
IF Workplace.FINDFIRST THEN
REPEAT
ResourceCodeBuffer.INIT;
ResourceCodeBuffer.Code := Workplace.Code;
ResourceCodeBuffer.Name := Workplace.Description;
ResourceCodeBuffer."Code 2" := Workplace.Code;
ResourceCodeBuffer."Show in Bold" := TRUE;
ResourceCodeBuffer.Group := TRUE;
ResourceCodeBuffer.INSERT;
UNTIL Workplace.NEXT = 0;
END;
PROCEDURE GroupResourceBySkills@1190030(VAR ResourceCodeBuffer@1190001 : Record

25006270;CurrDate@1190000 : Date);
VAR
Skill@1190003 : Record 25006159;
BEGIN
REPEAT
ResourceCodeBuffer."Applies-to Code" := ResourceCodeBuffer."Code 2";
ResourceSkill.SETRANGE("Resource No.", ResourceCodeBuffer.Code);
IF ResourceSkill.FINDFIRST THEN
REPEAT
IF Skill.GET(ResourceSkill."Skill Code")THEN
Skill.MARK(TRUE);
UNTIL ResourceSkill.NEXT = 0;
Skill.MARKEDONLY(TRUE);
IF Skill.FINDFIRST THEN
REPEAT
ResourceCodeBuffer.Code := Skill.Code;
ResourceCodeBuffer.Name := Skill.Description;
ResourceCodeBuffer."Code 2" := Skill.Code;
UNTIL Skill.NEXT = 0;
END;
PROCEDURE GroupResourceByShifts@1190031(VAR ResourceCodeBuffer@1190001 : Record

25006270;CurrDate@1190000 : Date);
VAR
Shift@1190003 : Record 25006151;
BEGIN
REPEAT
IF Resource.GET(ResourceCodeBuffer.Code) THEN BEGIN
ResourceCodeBuffer."Code 2" := Resource."Service Work Group Code";
ResourceCodeBuffer."Applies-to Code" := Resource."Service Work Group
Code";
IF Shift.GET(Resource."Service Work Group Code") THEN
Shift.MARK(TRUE);
END;
Shift.MARKEDONLY(TRUE);
IF Shift.FINDFIRST THEN
REPEAT
ResourceCodeBuffer.Code := Shift.Code;
ResourceCodeBuffer.Name := Shift.Description;
ResourceCodeBuffer."Code 2" := Shift.Code;
UNTIL Shift.NEXT = 0;
END;
PROCEDURE ChangePlanningPolicy@1190023(ServiceHdr@1190000 : Record 25006145);

BEGIN
LaborAllocEntry.SETRANGE("Source Type", LaborAllocEntry."Source
LaborAllocEntry.SETRANGE("Source Subtype", ServiceHdr."Document Type");
LaborAllocEntry.SETRANGE("Source ID", ServiceHdr."No.");
IF LaborAllocEntry.FINDFIRST THEN
REPEAT
LaborAllocEntry."Planning Policy" := ServiceHdr."Planning Policy";
UNTIL LaborAllocEntry.NEXT = 0;
END;
PROCEDURE CheckServiceLineResource@1190024(DocType@1101904004 :
Integer;DocNo@1101904003 : Code[20];LineType@1101904002 : Integer;LineNo@1101904001
: Integer;ReturnType@1190001 : 'Error,Boolean';ResourceNo@1190002 : Code[20]) :
Boolean;
VAR
TextLoc@1101904000 : TextConst 'ENU=here are params %1';
BEGIN
LaborAllocApp.SETRANGE("Document Type", DocType);
LaborAllocApp.SETRANGE("Document No.", DocNo);
LaborAllocApp.SETRANGE("Document Line No.", LineNo);
//2012.03.19 EDMS P8 >>
IF ReturnType = ReturnType::Error THEN
ERROR(Text136)
// ERROR(TextLoc, ServiceLine.GETFILTERS)
ELSE
EXIT(FALSE);
END ELSE
EXIT(FALSE);
END ELSE BEGIN
EXIT(CheckDocAllocResource(DocType, DocNo, LineType, LineNo, ReturnType,
ResourceNo)); // P8
END;
EXIT(TRUE) ;
END;
PROCEDURE ChangeFinishedAllocEnding@1190025(LaborAllocEntry@1190001 : Record

25006271);
VAR
ChangeAllocationForm@1190000 : Page 25006360;
BEGIN
CLEAR(ChangeAllocationForm);
ChangeAllocationForm.GetServLaborAllocation(LaborAllocEntry);
ChangeAllocationForm.LOOKUPMODE(TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
ChangeAllocationForm.RUNMODAL;
END;
PROCEDURE DontModifySalesLine@1190026(DontModify@1190000 : Boolean);

BEGIN
GlobDontModifyServLine := DontModify;
END;
PROCEDURE GetCapacity@1190027(ResourceNo@1190000 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190002 : Decimal) :
Decimal;
VAR
ResCalendarChange@1190004 : Record 25006279;
Date@1190005 : Record 2000000007;
CurrDate@1190006 : Date;
CurrStartTime@1190008 : Time;
CurrEndTime@1190010 : Time;
CurrEndTime2@1190011 : Time;
Capacity@1190007 : Decimal;
BEGIN
IF NOT Resource.GET(ResourceNo) THEN
EXIT(0);
Capacity := 0;
CurrDate := DateTimeMgt.Datetime2Date(StartingDateTime);
CurrStartTime := DateTimeMgt.Datetime2Time(StartingDateTime);
REPEAT
CurrEndTime := DateTimeMgt.Datetime2Time(EndingDateTime);
IF ResCalendarChange.GET(ResourceNo, CurrDate) THEN BEGIN
IF CurrStartTime < ResCalendarChange."Starting Time" THEN
CurrStartTime := ResCalendarChange."Starting Time";
IF (CurrEndTime > ResCalendarChange."Ending Time") OR (CurrDate <
DateTimeMgt.Datetime2Date(EndingDateTime)) THEN
CurrEndTime := ResCalendarChange."Ending Time";
IF CurrEndTime > CurrStartTime THEN
Capacity := Capacity + (CurrEndTime - CurrStartTime)/(1000*60*60);
END ELSE BEGIN
Date.RESET;
Date.SETRANGE("Period Start", CurrDate);
IF Date.FINDFIRST THEN BEGIN
ServiceHour.RESET;
ServiceHour.SETRANGE("Service Work Group Code", Resource."Service Work
Group Code");
ServiceHour.SETFILTER("Starting Date", '<=%1|%2', CurrDate, 0D);
ServiceHour.SETFILTER("Ending Date", '>=%1|%2', CurrDate, 0D);
ServiceHour.SETRANGE(Day, Date."Period No." - 1);
CurrEndTime2 := CurrEndTime;
REPEAT
CurrEndTime := CurrEndTime2;
IF CurrStartTime < ServiceHour."Starting Time" THEN
CurrStartTime := ServiceHour."Starting Time";
IF (CurrEndTime > ServiceHour."Ending Time") OR (CurrDate <
DateTimeMgt.Datetime2Date(EndingDateTime)) THEN
CurrEndTime := ServiceHour."Ending Time";
IF CurrEndTime - CurrStartTime > 0 THEN
Capacity := Capacity + (CurrEndTime -
CurrStartTime)/(1000*60*60);
END;
END;
END;
CurrDate := CurrDate + 1;
CurrStartTime := 0T;
UNTIL CurrDate > DateTimeMgt.Datetime2Date(EndingDateTime);
EXIT(Capacity)
END;
PROCEDURE GetNotAvailabilityTime@1190032(VAR TempLaborAllocEntry@1190002 :

TEMPORARY Record 25006271;StartingDateTime@1190000 : Decimal;EndingDateTime@1190001
: Decimal) : Decimal;
VAR
NotAvailable@1190003 : Decimal;
CurrStart@1190004 : Decimal;
CurrEnd@1190005 : Decimal;
BEGIN
REPEAT
IF StartingDateTime > TempLaborAllocEntry."Start Date-Time" THEN
CurrStart := StartingDateTime
ELSE
CurrStart := TempLaborAllocEntry."Start Date-Time";
IF EndingDateTime < TempLaborAllocEntry."End Date-Time" THEN
CurrEnd := EndingDateTime
ELSE
CurrEnd := TempLaborAllocEntry."End Date-Time";
NotAvailable := NotAvailable + CalcHourDifference(CurrStart, CurrEnd);
UNTIL TempLaborAllocEntry.NEXT = 0;
EXIT(NotAvailable);
END;
PROCEDURE ShowServiceAllocation@1190034(SourceID@1190000 : Code[20]);

VAR
ServLaborAllocation@1190001 : Record 25006271;
BEGIN
ServLaborAllocation.RESET;
ServLaborAllocation.SETCURRENTKEY("Source Type", "Source Subtype", "Source
ID");
ServLaborAllocation.SETRANGE("Source Type", ServLaborAllocation."Source
ServLaborAllocation.SETRANGE("Source ID", SourceID);
IF ServLaborAllocation.COUNT = 0 THEN
MESSAGE(Text140)
ELSE
PAGE.RUNMODAL(PAGE::"Service Labor List", ServLaborAllocation);
END;
PROCEDURE CheckStartAndPlan@1190038(EntryNo@1190000 : Integer);

VAR
BEGIN
WorkTimeEntry.SETRANGE("Resource No.",LaborAllocEntry."Resource No.");
IF NOT WorkTimeEntry.FINDLAST THEN
ERROR(STRSUBSTNO(Text107, LaborAllocEntry."Resource No."));
Resource.GET(LaborAllocEntry."Resource No.");
IF NOT Resource."Allow Simultaneous Work" THEN BEGIN //17.10.2013 EDMS P8
LaborAllocEntryLoc.SETCURRENTKEY("Source Type", Status, "Resource No.");
LaborAllocEntryLoc.SETRANGE(Status, LaborAllocEntryLoc.Status::"In
Progress");
LaborAllocEntryLoc.SETRANGE("Resource No.", LaborAllocEntry."Resource
No.");
ERROR(Text135);
END;
IF IsTimeAvailable(LaborAllocEntryTemp, LaborAllocEntry."Resource No.",

WORKDATE, 0) THEN BEGIN
REPEAT
IF (LaborAllocEntryTemp."Start Date-Time" <= CurrDateTime) AND
(LaborAllocEntryTemp."End Date-Time" >= CurrDateTime)
THEN
ERROR(Text113);
UNTIL LaborAllocEntryTemp.NEXT = 0
ELSE
ERROR(Text113);
END ELSE
ERROR(Text113);
END;
PROCEDURE DoNotChangeServStatus@1190042();
BEGIN
DontChangeServiceStatus := TRUE;
END;
PROCEDURE LookupAllocationRTC@1101904000(EntryNo@1101904001 : Integer);

VAR
PostedServOrder@1101904003 : Record 25006149;
BEGIN
IF NOT LaborAllocEntry.GET(EntryNo) THEN EXIT;
IF LaborAllocEntry."Source Type" <> LaborAllocEntry."Source Type"::"Service

Document" THEN
EXIT;
IF ServiceHeader.GET(LaborAllocEntry."Source Subtype",LaborAllocEntry."Source
ID") THEN BEGIN
CASE ServiceHeader."Document Type" OF
ServiceHeader."Document Type"::Quote: PAGE.RUNMODAL(PAGE::"Service Quote
EDMS", ServiceHeader);
ServiceHeader."Document Type"::Order: PAGE.RUNMODAL(PAGE::"Service Order
EDMS", ServiceHeader);
END;
END ELSE BEGIN
IF PostedServOrder.GET(LaborAllocEntry."Source ID") THEN
PAGE.RUNMODAL(PAGE::"Posted Service Order EDMS", PostedServOrder);
END;
END;
PROCEDURE AllocationChanged@1101904001(EntryNo@1101904000 :
Integer;NewResourceNo@1101904001 : Code[20];VAR NewStartDT@1101904002 : Decimal;VAR
NewEndDT@1101904003 : Decimal) RetValue : Boolean;
VAR
LaborAllocEntryL@1101904004 : Record 25006271;
AdjustedTime@1101901000 : Time;
DateTmeTmp@1101901001 : Decimal;
RoundMs@1101901002 : Integer;
OrigNewStartDT@1101901004 : Decimal;
OrigNewEndDT@1101901003 : Decimal;
BEGIN
WITH LaborAllocEntryL DO BEGIN
GET(EntryNo);
OrigNewStartDT := NewStartDT;
OrigNewEndDT := NewEndDT;
IF ServiceScheduleSetup."Allocation Time Step (Minutes)" > 0 THEN
RoundMs := ServiceScheduleSetup."Allocation Time Step (Minutes)"
ELSE
RoundMs := 36000; // IF NO SETUP THEN min by system is 36 sec.
// lets do time adjustment
IF "Start Date-Time" <> NewStartDT THEN

NewStartDT := DateTimeRound(NewStartDT, RoundMs);
IF "End Date-Time" <> NewEndDT THEN BEGIN
NewEndDT := DateTimeRound(NewEndDT, RoundMs);
END;
AdjustedTime := 000001T - 1000 + RoundMs;
DateTmeTmp := DateTimeMgt.Datetime(0D, AdjustedTime);
IF ((NewEndDT - NewStartDT) < DateTmeTmp) THEN BEGIN
NewEndDT := NewStartDT+ DateTmeTmp;
END;
END;
//do define should be shown task-edit form or should not?

IF ("Resource No." <> NewResourceNo) AND (NewResourceNo <> '') THEN
RetValue := TRUE;
// rounding by 1 second
IF NOT IsDateTimeEqualDateTime("Start Date-Time", OrigNewStartDT)
THEN //20.07.2013 EDMS P8
RetValue := TRUE;
IF NOT IsDateTimeEqualDateTime("End Date-Time", OrigNewEndDT) THEN
RetValue := TRUE;
END;
EXIT(RetValue);
END;
PROCEDURE FillUnavailableTimeEntries@1101904003(VAR AllocEntry@1101908003 :

Record 25006271;ResourceNo@1101908002 : Code[20];TargetDate@1101908001 : Date);
VAR
ResCalendarChange@1101908008 : Record 25006279;
ServLaborAlloc2@1101908010 : Record 25006271;
ApplicationEntry@1101908011 : TEMPORARY Record 25006277;
Starting@1101908006 : Decimal;
Finishing@1101908005 : Decimal;
Text001@1101904000 : TextConst 'ENU=Unavailability';
ResWorkTimeChange@1101904001 : Boolean;
PrevRecStartTime@1101904002 : Time;
PrevRecEndTime@1101904003 : Time;
BEGIN
ResWorkTimeChange := FALSE;
//check for busy time in Base Calendar and in Resource Calendar Change >>
IF ResCalendarChange.GET(ResourceNo, TargetDate) THEN BEGIN
CASE ResCalendarChange."Change Type"::"Work Time Change" OF
ResCalendarChange."Change Type"::Nonworking: BEGIN
QtyToAllocate := CalcHourDifference(DateTimeMgt.Datetime(TargetDate,
000000T),
DateTimeMgt.Datetime(TargetDate,
235959.999T));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
DateTimeMgt.Datetime(TargetDate, 000000T), QtyToAllocate,
0, 0, Text001, 0,
DoChangeServLineResource,AllocEntry.Travel);
END;
ResCalendarChange."Change Type"::"Work Time Change": BEGIN
ResWorkTimeChange := TRUE;
IF ResCalendarChange."Starting Time" > 0T THEN BEGIN
000000T),
ResCalendarChange."Starting Time"));
0, 0, Text001, 0,
END;
IF ResCalendarChange."Ending Time" < 235959.999T THEN BEGIN

ResCalendarChange."Ending Time"),
235959.999T));
ResCalendarChange."Ending Time"), QtyToAllocate, 0, 0, Text001,0,
END;
END;
END;
END;
//write busy time from Service Hour EDMS >>

IF NOT ResWorkTimeChange THEN BEGIN
ServiceHour.RESET;
//AB >>
IF(ResourceLoc.GET(ResourceNo)) THEN BEGIN
//ResourceLoc.GET(ResourceNo);
Group Code");
ServiceHour.SETFILTER("Starting Date", '''''|<=%1', TargetDate);
ServiceHour.SETFILTER("Ending Date", '''''|>=%1', TargetDate);
ServiceHour.SETRANGE(Day, DATE2DWY(TargetDate, 1) - 1);
//18.01.2012 EDMS P8 >>

PrevRecStartTime := 0T;
PrevRecEndTime := 0T;
REPEAT
IF ServiceHour."Starting Time" > 0T THEN BEGIN
PrevRecEndTime),
ServiceHour."Starting Time"));
DateTimeMgt.Datetime(TargetDate, PrevRecEndTime),
QtyToAllocate, 0, 0, Text001, 0,
END;
PrevRecStartTime := ServiceHour."Starting Time";

PrevRecEndTime := ServiceHour."Ending Time";
IF ServiceHour."Ending Time" < 235959.999T THEN BEGIN
ServiceHour."Ending Time"),
235959.999T));
ServiceHour."Ending Time"), QtyToAllocate, 0, 0, Text001, 0,
END;
//18.01.2012 EDMS P8 <<
END ELSE BEGIN
000000T),
235959.999T));
0, 0, Text001, 0,
END;
END;
//AB <<
END;
END;
PROCEDURE DateTimeRound@1101904008(DateTime@1101904000 :
Decimal;RoundMs@1101904001 : Integer) : Decimal;
VAR
AdjustedTime@1101904002 : Time;
BEGIN
AdjustedTime := 000001T - 1000 + RoundMs;
EXIT(ROUND(DateTime, DateTimeMgt.Datetime(0D, AdjustedTime)))
END ELSE
EXIT(DateTime);
END;
PROCEDURE IsDateTimeEqualDateTime@1(FirstDT@1000 : Decimal;SecondDT@1001 :

Decimal) : Boolean;
BEGIN
EXIT(DateTimeRound(FirstDT, 1000) = DateTimeRound(SecondDT,
1000)); //20.07.2013 EDMS P8
END;
PROCEDURE DocAllocAdjustDocLinesResource@1101904005(DocumentType@1101904004 :
Order';DocumentNo@1101904002 : Code[20];ResourceNo@1101904003 : Code[20]);
VAR
ServiceLineLocal@1101904000 : Record 25006146;
Resources@1101904005 : Text[250];
BEGIN
// P8
IF GetSourceType(LaborAllocEntry, LaborAllocApp) <>
LaborAllocAppType::"Service Document" THEN
EXIT;
ServiceLineLocal.RESET;
ServiceLineLocal.SETRANGE("Document Type", DocumentType);
ServiceLineLocal.SETRANGE("Document No.", DocumentNo);
ServiceLineLocal.SETRANGE(Type, ServiceLineLocal.Type::Labor);
FillServiceLine(ServiceLineLocal);
IF ServiceLineLocal.FINDFIRST THEN BEGIN
Resources := GetRelatedResources(DocumentType, DocumentNo,
ServiceLineLocal.Type::Labor, ServiceLineLocal."Line No.", 0);
REPEAT
SetRelatedResources(DocumentType, DocumentNo,
ServiceLineLocal.Type::Labor, ServiceLineLocal."Line No.",
Resources, 11);
UNTIL ServiceLineLocal.NEXT = 0;
END;
END;
PROCEDURE CheckDocAllocResource@1101904004(DocType@1101904003 :
: Integer;ReturnType@1190001 : 'Error,Boolean';ResourceNo@1190002 : Code[20]) :
Boolean;
BEGIN
// P8
LaborAllocApp.SETRANGE("Document Type", DocType);
LaborAllocApp.SETRANGE("Document No.", DocNo);
//2012.03.19 EDMS P8 >>
IF ReturnType = ReturnType::Error THEN
ERROR(Text136)
ELSE
EXIT(FALSE);
END ELSE
EXIT(FALSE);
END;
EXIT(TRUE) ;
END;
PROCEDURE GetDocAllocResource@1101904006(DocumentType@1101904001 :
Order';DocumentNo@1101904000 : Code[20]) ResourceNo : Code[20];
BEGIN
// old version, look at GetDocAllocResources
LaborAllocApp.SETRANGE("Document Type", DocumentType);
LaborAllocApp.SETRANGE("Document No.", DocumentNo);
IF (LaborAllocApp."Resource No." <> '') THEN
ResourceNo := LaborAllocApp."Resource No.";
EXIT(ResourceNo);
END;
PROCEDURE GetDocAllocResources@1101904020(DocumentType@1101904001 :
Order';DocumentNo@1101904000 : Code[20]) ResourceNos : Text[250];
VAR
ServLaborApplicationTmp@1101904002 : TEMPORARY Record 25006277;
BEGIN
ResourceNos := '';
WITH LaborAllocApp DO BEGIN
RESET;
SETRANGE("Document Type", DocumentType);
SETRANGE("Document No.", DocumentNo);
REPEAT
ServLaborApplicationTmp.SETRANGE("Resource No.", "Resource No.");
IF NOT ServLaborApplicationTmp.FINDFIRST THEN BEGIN
ResourceNos += "Resource No."+',';
ServLaborApplicationTmp := LaborAllocApp;
ServLaborApplicationTmp.INSERT;
END;
UNTIL NEXT = 0;
ResourceNos := COPYSTR(ResourceNos, 1, STRLEN(ResourceNos)-1);
END;
END;
EXIT(ResourceNos);
END;
PROCEDURE GetSourceType@1101904009(LaborAllocEntryPar@1101904003 : Record

25006271;LaborAllocAppPar@1101904002 : Record 25006277) : Integer;
VAR
RetValue@1101904000 : ' ,Service Document,Standard Event,Service Line';
BEGIN
IF LaborAllocEntryPar."Entry No." > 0 THEN BEGIN
RetValue := LaborAllocEntryPar."Source Type";
IF RetValue = RetValue::"Service Document" THEN
IF LaborAllocAppPar."Document Line No." > 0 THEN
RetValue := RetValue::"Service Line";
END;
EXIT(RetValue);
END;
PROCEDURE SeparateAllocEntry@1101904007(VAR ServLaborAllocEntryPar@1101904000 :

Record 25006271;VAR ServAllocAppSourcePar@1101904026 : Record 25006277;VAR
ServLineDestPar@1101904001 : Record 25006146;ShareQtySource@1101904005 :
Decimal;ShareQtyDest@1101904006 : Decimal;StartTimeDepends@1101904007 :
Boolean;DoCreateServLine@1101904022 : Boolean;ParamStr@1101904035 : Text[30]) :
Integer;
VAR
ServLineSource@1101904021 : Record 25006146;
ServLaborAllocEntryDest@1101904002 : Record 25006271;
AllocAppEntrySource@1101904003 : Record 25006277;
AllocAppEntryDest@1101904004 : Record 25006277;
TextLoc001@1101904008 : TextConst 'ENU=Error to proceed allocation split -
should be finished or unstarted.';
AllocAppEntry@1101904025 : Record 25006277;
QtySource@1101904009 : Decimal;
QtySourceBeforeChange@1101904031 : Decimal;
QtyDest@1101904032 : Decimal;
DocMgtDMS@1101904020 : Codeunit 25006000;
SplitQuantity@1101904019 : Decimal;
SplitHours@1101904018 : Decimal;
OldQuantity@1101904017 : Decimal;
NewQuantity@1101904015 : Decimal;
NewHours@1101904014 : Decimal;
CurrentLineNo@1101904012 : Integer;
DateStart@1101904010 : Decimal;
FinishedQty@1101904011 : Decimal;
RemainingQty@1101904023 : Decimal;
AllocTimeQty@1101901000 : Decimal;
NewAllocEntryNo@1101904027 : Integer;
LineNoSource@1101904028 : Integer;
ShareOfLineInAlloc@1101904029 : Decimal;
MainAllocQty@1101904030 : Decimal;
IsSourceDeallocated@1101904033 : Boolean;
doAvoidSrcChanges@1101904036 : Boolean;
doAvoidSrcLineQtyChange@1101904037 : Boolean;
doAvoidDestLineQtyChange@1101904038 : Boolean;
BEGIN
// supposed that the function could be runned if allocation not used at all
or finished already
// Proceed only for one Alloc Entry.
// StartTimeDepends = true - means Start Time for new Allocation Entry should
be ending time of source entry.
// supposed to be used in cases:
// of adding allocation to Service Line EDMS that has already allocated to
other resource, then need to split line and allocation
// of both lines exist but need to adjust qty share for existing first
allocation and create new allocation for second line with o
// parameter ServAllocAppSourcePar - supposed to be temporary record with
stored several applications - usefull if source allocation
// is deallocated already (in procedure from that is called).
// IMPORTANT it should be filtered if real record used, instead of
temporary!
// parameter ServLaborAllocEntryPar - could be temporary or not!
// note for coding: FINISHED AND REMAINING QUANTITIES are stored only in
first AllocAppEntry entry
// parameter ServLineDestPar should be filtered or temporary in case of
ServAllocAppSourcePar.COUNT > 1
// parameter ShareQtySource - stores quantity share of labor but not entry
(so for entry it going to be adjusted)
// ParamStr: first char is digit-flag, doAvoidSrcChanges("Applies-to Entry

No.")
// 2nd char is digit-flag, doAvoidSrcLineQtyChange
// 3rd char is digit-flag, doAvoidDestLineQtyChange
IF STRLEN(ParamStr)>0 THEN
EVALUATE(doAvoidSrcChanges, COPYSTR(ParamStr,1,1));
EVALUATE(doAvoidSrcLineQtyChange, COPYSTR(ParamStr,2,1));
EVALUATE(doAvoidDestLineQtyChange, COPYSTR(ParamStr,3,1));
WITH ServAllocAppSourcePar DO BEGIN

IF NOT FINDFIRST THEN
EXIT;
LineNoSource := "Document Line No.";
ResourceNo := "Resource No.";
REPEAT
IF ("Finished Quantity (Hours)" > 0) THEN BEGIN
FindSplitEntries("Allocation Entry No.", ServLaborAllocEntryTmp, 0,
1111);
IF ServLaborAllocEntryTmp.FINDFIRST THEN BEGIN
REPEAT
AllocAppEntry.RESET;
AllocAppEntry.SETRANGE("Allocation Entry No.",
ServLaborAllocEntryTmp."Entry No.");
IF AllocAppEntry.FINDFIRST THEN
IF (AllocAppEntry."Remaining Quantity (Hours)" > 0) THEN
ERROR(TextLoc001);
END;
END;
UNTIL NEXT = 0;
FINDFIRST;
END;
//At first fix source allocation

//before run it do check: is it a real record?
LaborAllocEntry.GET(ServLaborAllocEntryPar."Entry No.");
IF NOT doAvoidSrcChanges THEN BEGIN
QtySourceBeforeChange := ServLaborAllocEntryPar."Quantity (Hours)";
IsSourceDeallocated := FALSE;
IF (ShareQtySource <> 100) THEN BEGIN
// need to update current entry quantity
WITH ServLaborAllocEntryPar DO BEGIN
MainAllocQty := "Quantity (Hours)";
QtySource := MainAllocQty * ShareQtySource/100;
IF QtySource = 0 THEN BEGIN
DeallocateIncSplit("Entry No.", TRUE);
IsSourceDeallocated := TRUE;
END ELSE BEGIN
IF NOT doAvoidSrcLineQtyChange THEN
IF ServLineSource.GET(ServLaborAllocEntryPar."Source Subtype",
ServLaborAllocEntryPar."Source ID",
LineNoSource) THEN BEGIN
ServLineSource.SetTimeQty(QtySource, TRUE, TRUE);
ServLineSource.MODIFY;
END;
IF FinishedQty = 0 THEN
ProcessMovement("Entry No.", "Resource No.", "Start Date-Time",
QtySource, 1, LaborAllocEntry.Status, -1,LaborAllocEntry.Travel)
ELSE BEGIN
ProcessMovement("Entry No.", "Resource No.", "Start Date-Time",
QtySource, 1, LaborAllocEntry.Status, -1,LaborAllocEntry.Travel);
END;
END;
END;
END;
END;
//add "Service Line EDMS" for destination

WITH ServLineDestPar DO BEGIN
IF DoCreateServLine THEN BEGIN
ServLineSource.GET(ServLaborAllocEntryPar."Source Subtype",
ServLaborAllocEntryPar."Source ID",
AllocAppEntrySource."Document Line No.");
ServLineDestPar := ServLineSource;
NewLineNo := NewLineNo + 1;
"Line No." := NewLineNo;
INSERT;
// DocMgtDMS.ServiceCopyDimensions(ServLineSource, NewLineNo);//30.10.2012
EDMS
END;
IF NOT doAvoidDestLineQtyChange THEN BEGIN
IF ShareQtyDest <> 100 THEN BEGIN
VALIDATE("Standard Time", "Standard Time" * ShareQtyDest/100);
ServLineDestPar.SetTimeQty(QtySourceBeforeChange * ShareQtyDest/100,
TRUE, TRUE);
END;
MODIFY;
END;
END;
// add allocation for destination service line

FinishedQty := ServAllocAppSourcePar."Finished Quantity (Hours)";
RemainingQty := ServAllocAppSourcePar."Remaining Quantity (Hours)";
FinishedQty := ROUND(FinishedQty * ShareQtyDest/100,0.00001);
RemainingQty := ROUND(RemainingQty * ShareQtyDest/100,0.00001);
IF StartTimeDepends AND NOT IsSourceDeallocated THEN BEGIN
DateStart := GetEntryEndingTimeFull(ServLaborAllocEntryPar."Entry No.");
IF DateStart <= DateTimeMgt.Datetime(0D, 0T) THEN // THAT Is in case when
source allocation is deallocated
DateStart := ServLaborAllocEntryPar."Start Date-Time";
END ELSE
DateStart := ServLaborAllocEntryPar."Start Date-Time";
DateStart := ROUND(DateStart, 0.000001, '>'); // it strange, but sometimes
datestart stored in database is not able to proceed
// by DateTime2Time, so need to
round-up it before!
//19.03.2013 EDMS P8 >>

IF ServLaborAllocEntryPar.Status = ServLaborAllocEntryPar.Status::Pending
THEN
AllocTimeQty := ServLineDestPar.GetTimeQty
ELSE
AllocTimeQty := ROUND(ServLaborAllocEntryPar."Quantity (Hours)" *
ShareQtyDest/100,0.00001);
//19.03.2013 EDMS P8 <<
NewAllocEntryNo := CreateNewAllocEntry(DateStart, ResourceNo,

AllocTimeQty, ServLineDestPar."Document Type",
ServLineDestPar."Document No.", ServLineDestPar."Line No.",
ServLaborAllocEntryPar."Reason Code",
ServLaborAllocEntryPar."Planning Policy", FinishedQty, RemainingQty,
ServLaborAllocEntryPar.Status);
IF ServAllocAppSourcePar.COUNT > 1 THEN BEGIN
ServAllocAppSourcePar.NEXT; // it should be second line
REPEAT
ServLineDestPar.NEXT;
CreateAppEntry(NewAllocEntryNo, ServLineDestPar."Document Type",
ServLineDestPar."Document No.",
ServLineDestPar."Line No.", ResourceNo, 0, 0, FALSE);
UNTIL ServAllocAppSourcePar.NEXT = 0;
END;
ProcessMovement(NewAllocEntryNo, ResourceNo, DateStart, AllocTimeQty, 1,
ServLaborAllocEntryPar.Status, -1,ServLaborAllocEntryPar.Travel);
EXIT(NewLineNo);
END;
PROCEDURE GetQtyShareOfLineInAlloc@1101904013(DocType@1101904001 :
Integer;DocNo@1101904010 : Code[20];LineNo@1101904011 :
Integer;EntryNo@1101904008 : Integer) ShareOfLine : Decimal;
VAR
ServAllocApp@1101904009 : Record 25006277;
QtyTotalOfApp@1101904005 : Decimal;
MainAllocQty@1101904004 : Decimal;
MainLineQty@1101904003 : Decimal;
BEGIN
WITH ServAllocApp DO BEGIN
QtyTotalOfApp := 0;
ShareOfLine := 1;
RESET;
SETRANGE("Allocation Entry No.", EntryNo);
IF ServLaborAllocationEntry.GET(EntryNo) THEN
MainAllocQty := ServLaborAllocationEntry."Quantity (Hours)"
ELSE
MainAllocQty := 0;
ServiceLine.GET(DocType, DocNo, LineNo);
MainLineQty := ServiceLine.GetTimeQty;
IF COUNT > 1 THEN BEGIN
REPEAT
IF ServiceLine.GET(DocType, DocNo, "Document Line No.") THEN
QtyTotalOfApp += ServiceLine.GetTimeQty;
UNTIL NEXT = 0;
ShareOfLine := QtyTotalOfApp/MainLineQty;
END;
END;
END;
EXIT(ShareOfLine*100);
END;
PROCEDURE GetEntryEndingTimeFull@1101904018(EntryNo@1101904001 : Integer) :

Decimal;
VAR
BEGIN
//returns ending time of last allocation part if original is splitted
FindSplitEntries(EntryNo, ServLaborAllocEntryTmp, 0, 1111);
WITH ServLaborAllocEntryTmp DO BEGIN
RESET;
IF FINDLAST THEN
EXIT("End Date-Time");
END;
EXIT(0);
END;
PROCEDURE CreateNewAllocEntry@1101904015(StartingDateTime@1190000 :
Decimal;ResourceNo@1190005 : Code[20];Hours@1190004 : Decimal;SourceType@1101904003
: Integer;SourceID@1190006 : Code[20];LineNo@1190007 : Integer;ReasonCode@1190008 :
Code[10];PlanningPolicy@1190009 : Integer;FinishedHours@1101904000 :
Decimal;RemainingHours@1101904001 : Decimal;Status@1101904002 : Integer) : Integer;
VAR
NewServLaborAllocEntry@1190001 : Record 25006271;
NewAllocAppEntry@1190002 : Record 25006277;
BEGIN
//returns new allocation entry no
NewServLaborAllocEntry.RESET;
NewServLaborAllocEntry.FINDLAST;
EntryNo := NewServLaborAllocEntry."Entry No." + 1;
NewServLaborAllocEntry.INIT;
NewServLaborAllocEntry."Entry No." := EntryNo;
NewServLaborAllocEntry."Source Type" := NewServLaborAllocEntry."Source
Type"::"Service Document";
NewServLaborAllocEntry."Source Subtype" := SourceType;
NewServLaborAllocEntry."Source ID" := SourceID;
NewServLaborAllocEntry."Start Date-Time" := ROUND(StartingDateTime, 0.00001);
NewServLaborAllocEntry."Quantity (Hours)" := Hours;
NewServLaborAllocEntry."End Date-Time" := ROUND(StartingDateTime +
NewServLaborAllocEntry."Quantity (Hours)"*3.6, 0.00001);
NewServLaborAllocEntry."Resource No." := ResourceNo;
NewServLaborAllocEntry."User ID" := USERID;
NewServLaborAllocEntry.Status := Status;
NewServLaborAllocEntry."Reason Code" := ReasonCode;
NewServLaborAllocEntry."Planning Policy" := PlanningPolicy;
NewServLaborAllocEntry.INSERT;
CreateAppEntry(EntryNo, SourceType, SourceID, LineNo, ResourceNo,

FinishedHours, RemainingHours, TRUE);
EXIT(EntryNo);
END;
PROCEDURE CreateAppEntry@1101904016(EntryNo@1101904002 :
Integer;DocType@1190000 : Integer;DocNo@1101904003 : Code[20];LineNo@1101904004 :
Integer;ResourceNo@1190005 : Code[20];FinishedHours@1101904000 :
Decimal;RemainingHours@1101904001 : Decimal;TimeLine@1101904005 : Boolean);
VAR
NewAllocAppEntry@1190002 : Record 25006277;
BEGIN
NewAllocAppEntry.INIT;
NewAllocAppEntry."Allocation Entry No." := EntryNo;
NewAllocAppEntry."Document Type" := DocType;
NewAllocAppEntry."Document No." := DocNo;
NewAllocAppEntry."Document Line No." := LineNo;
NewAllocAppEntry."Resource No." := ResourceNo;
NewAllocAppEntry."Time Line" := TimeLine;
IF TimeLine THEN BEGIN
NewAllocAppEntry."Finished Quantity (Hours)" := FinishedHours;
NewAllocAppEntry."Remaining Quantity (Hours)" := RemainingHours;
END ELSE BEGIN
NewAllocAppEntry."Finished Quantity (Hours)" := 0;
NewAllocAppEntry."Remaining Quantity (Hours)" := 0;
END;
NewAllocAppEntry.INSERT(TRUE);
END;
PROCEDURE CreateAppEntryByEntry@1101904022(VAR
ServLaborAllocationEntryPar@1101904002 : Record 25006271;VAR
ServLaborAllocApplicationPar@1190000 : Record 25006277;LineNo@1101904003 :
Integer;FinishedHours@1101904000 : Decimal;RemainingHours@1101904001 :
Decimal;TimeLine@1101904005 : Boolean);
BEGIN
WITH ServLaborAllocApplicationPar DO BEGIN
INIT;
"Allocation Entry No." := ServLaborAllocationEntryPar."Entry No.";
"Document Type" := ServLaborAllocationEntryPar."Source Subtype";
"Document No." := ServLaborAllocationEntryPar."Source ID";
"Document Line No." := LineNo;
"Resource No." := ServLaborAllocationEntryPar."Resource No.";
"Time Line" := TimeLine;
IF TimeLine THEN BEGIN
"Finished Quantity (Hours)" := FinishedHours;
"Remaining Quantity (Hours)" := RemainingHours;
END ELSE BEGIN
"Finished Quantity (Hours)" := 0;
"Remaining Quantity (Hours)" := 0;
END;
INSERT(TRUE);
END;
END;
PROCEDURE AdjustAllocEntryByShare@1101904010(ServLinePar@1101904000 : Record

25006146;ShareQty@1101904001 : Decimal);
VAR
ServLaborAllocEntry@1101904002 : Record 25006271;
AllocAppEntry@1101904003 : Record 25006277;
BEGIN
IF (ShareQty <> 100) THEN BEGIN
// need to update current entry quantity
WITH AllocAppEntry DO BEGIN
RESET;
SETRANGE("Document Type", ServLinePar."Document Type");
SETRANGE("Document No.", ServLinePar."Document No.");
SETRANGE("Document Line No.", ServLinePar."Line No.");
EXIT;
END;
WITH ServLaborAllocEntry DO BEGIN
IF GET(AllocAppEntry."Allocation Entry No.") THEN BEGIN
"Quantity (Hours)" := "Quantity (Hours)" * ShareQty/100;
"End Date-Time" := ROUND("Start Date-Time" + "Quantity (Hours)"*3.6,
0.00001);
IF "Quantity (Hours)" = 0 THEN

DELETE(TRUE)
ELSE
MODIFY(TRUE);
AllocAppEntry.RESET;
AllocAppEntry.SETRANGE("Allocation Entry No.", "Entry No.");
IF AllocAppEntry.FINDFIRST THEN BEGIN
IF AllocAppEntry."Finished Quantity (Hours)" > 0 THEN BEGIN
AllocAppEntry."Finished Quantity (Hours)" :=
AllocAppEntry."Finished Quantity (Hours)" * ShareQty/100;
END;
IF AllocAppEntry."Remaining Quantity (Hours)" > 0 THEN BEGIN
AllocAppEntry."Remaining Quantity (Hours)" := "Quantity (Hours)";
END;
AllocAppEntry."Time Line" := TRUE;
AllocAppEntry.MODIFY;
END;
END ELSE BEGIN
IF AllocAppEntry."Finished Quantity (Hours)" > 0 THEN BEGIN
AllocAppEntry."Finished Quantity (Hours)" := AllocAppEntry."Finished
Quantity (Hours)" * ShareQty/100;
END;
AllocAppEntry.MODIFY;
END;
END;
END;
END;
PROCEDURE LookupResourceToAllocEntry@1101904011(AllocEntryNo@1190004 :
Code[20]);
VAR
ResourceList@1190000 : Page 77;
BEGIN
IF NOT CheckUserRightsAdv(2, LaborAllocEntry)THEN EXIT;
CLEAR(ResourceList);
ResourceList.LOOKUPMODE(TRUE);
IF ResourceList.RUNMODAL = ACTION::LookupOK THEN BEGIN

ResourceList.SetSelection(Resource);
IF Resource.FINDFIRST THEN BEGIN

IF ServLaborAllocationEntry.GET(AllocEntryNo) THEN
REPEAT
AddResourceToAllocEntry(ServLaborAllocationEntry, LaborAllocApp,
Resource."No.", 0, LaborAllocEntry, LaborAllocApp);
UNTIL Resource.NEXT = 0;
END;
END;
END;
PROCEDURE AddResourceToAllocEntry@1101904014(VAR
ServLaborAllocationEntry@1101904000 : Record 25006271;VAR
ServLaborAllocApplication@1101904004 : Record 25006277;ResourceNo@1101904001 :
Code[20];ApplyToEntryNo@1101904006 : Integer;VAR
NewServLaborAllocEntry@1101904008 : Record 25006271;VAR
NewServLaborAllocApplication@1101904002 : Record 25006277) : Integer;
VAR
TextNotLineFound@1101904003 : TextConst 'ENU=For the location is not found
service line.';
BEGIN
// actually it is not adding to allocation entry, but creating new entry with
same pars and different resource
ServLaborAllocApplication.SETRANGE("Resource No.");
ServLaborAllocApplication.SETRANGE("Allocation Entry No.",
ServLaborAllocationEntry."Entry No.");
IF NOT ServLaborAllocApplication.FINDFIRST THEN
ERROR(TextNotLineFound);
LaborAllocEntryL.RESET;
LaborAllocEntryL.FINDLAST;
EntryNo := LaborAllocEntryL."Entry No." + 1;
NewServLaborAllocEntry.INIT;
NewServLaborAllocEntry."Entry No." := EntryNo;
NewServLaborAllocEntry."Source Type" := NewServLaborAllocEntry."Source
Type"::"Service Document";
NewServLaborAllocEntry."Source Subtype" := ServLaborAllocationEntry."Source
Subtype";
NewServLaborAllocEntry."Source ID" := ServLaborAllocationEntry."Source ID";
NewServLaborAllocEntry."Start Date-Time" :=
ROUND(ServLaborAllocationEntry."Start Date-Time", 0.00001);
NewServLaborAllocEntry."Quantity (Hours)" :=
ServLaborAllocationEntry."Quantity (Hours)";
NewServLaborAllocEntry."End Date-Time" :=
ROUND(ServLaborAllocationEntry."Start Date-Time" +
NewServLaborAllocEntry."Quantity (Hours)" * 3.6, 0.00001);
NewServLaborAllocEntry."Resource No." := ResourceNo;
NewServLaborAllocEntry."User ID" := USERID;
NewServLaborAllocEntry.Status := ServLaborAllocationEntry.Status;
NewServLaborAllocEntry."Reason Code" := ServLaborAllocationEntry."Reason
Code";
NewServLaborAllocEntry."Planning Policy" :=
ServLaborAllocationEntry."Planning Policy";
NewServLaborAllocEntry."Parent Alloc. Entry No." :=
ServLaborAllocationEntry."Entry No.";
NewServLaborAllocEntry."Parent Link Synchronize" := TRUE;
NewServLaborAllocEntry.INSERT;
//ADJUST SOURCE ENTRY sets:

WITH ServLaborAllocationEntry DO BEGIN
IF NOT "Parent Link Synchronize" THEN BEGIN
"Parent Link Synchronize" := TRUE;
MODIFY;
END;
END;
CreateAppEntryByEntry(NewServLaborAllocEntry, NewServLaborAllocApplication,
ServLaborAllocApplication."Document Line No.", 0,
ServLaborAllocationEntry."Quantity (Hours)", FALSE);
EXIT(EntryNo);
END;
PROCEDURE ShowServLineResources@1101904017(VAR ServiceLine@1101904000 : Record

25006146);
VAR
ServLaborAllocApplicationTemp@1101904002 : TEMPORARY Record 25006277;
BEGIN
IF NOT ServiceLine.FINDSET THEN
EXIT;
ServLaborAllocApplicationTemp.RESET;
ServLaborAllocApplicationTemp.DELETEALL;
ServLaborAllocApplication.SETRANGE("Document Type", ServiceLine."Document
Type");
ServLaborAllocApplication.SETRANGE("Document No.", ServiceLine."Document
No.");
ServLaborAllocApplication.SETRANGE("Document Line No.", ServiceLine."Line
No.");
IF ServLaborAllocApplication.FINDFIRST THEN
REPEAT
ServLaborAllocApplicationTemp := ServLaborAllocApplication;
ServLaborAllocApplicationTemp.INSERT;
UNTIL ServLaborAllocApplication.NEXT = 0;
PAGE.RUNMODAL(0, ServLaborAllocApplicationTemp);
END;
PROCEDURE GetMainAllocEntrNo@1101904024(EntryNo@1101904000 :
Integer;RunModeFlags@1101904002 : Integer) RetEntryNo : Integer;
VAR
StatusArray@1101904003 : ARRAY [10] OF Integer;
BEGIN
// RunModeFlags = 1011, what statuses are taken in account REAden from right
to left (On Hold,Finished,In Progress,Pending)
AdjustFlagsToArray(RunModeFlags, StatusArray);
RetEntryNo := EntryNo;
IF LaborAllocEntry.GET(EntryNo) THEN BEGIN
REPEAT
IF IsIntInArrayTen(LaborAllocEntry.Status, StatusArray) THEN
RetEntryNo := LaborAllocEntry."Entry No.";
EntryNo := LaborAllocEntry."Applies-to Entry No.";
UNTIL LaborAllocEntry."Applies-to Entry No." = 0;
END;
EXIT(RetEntryNo);
END;
PROCEDURE FindSplitEntries@1101904040(EntryNo@1101908000 : Integer;VAR

LaborAllocEntryPar@1101908002 : Record 25006271;EntryType@1101908004 :
'Original,Next,Previous';RunModeFlags@1101904000 : Integer);
VAR
LaborAllocEntryLookIn@1101908001 : Record 25006271;
LaborAllocEntryCurr@1101908003 : Record 25006271;
BEGIN
// RunModeFlags = 1011, that statuses are taken in account, readen from right
LaborAllocEntryCurr.GET(EntryNo);
IF RunModeFlags = 0 THEN BEGIN //15.08.2013 EDMS P8
// that one is a case that need to take only one status records of source
rec.
CASE LaborAllocEntryCurr.Status OF
0: RunModeFlags := 1;
END;
END;
IF EntryType <> EntryType::Previous THEN BEGIN

IF NOT LaborAllocEntryPar.GET(LaborAllocEntryCurr."Entry No.") THEN BEGIN
IF IsIntInArrayTen(LaborAllocEntryCurr.Status, StatusArray) THEN BEGIN
LaborAllocEntryPar := LaborAllocEntryCurr;
LaborAllocEntryPar.INSERT;
END;
END;
LaborAllocEntryLookIn.RESET;
LaborAllocEntryLookIn.SETRANGE("Applies-to Entry No.", EntryNo);
IF LaborAllocEntryLookIn.FINDFIRST THEN
REPEAT
FindSplitEntries(LaborAllocEntryLookIn."Entry No.", LaborAllocEntryPar,
1, RunModeFlags); //12.08.2013 EDMS P8
UNTIL LaborAllocEntryLookIn.NEXT = 0;
END;
IF EntryType <> EntryType::Next THEN BEGIN

IF NOT LaborAllocEntryPar.GET(LaborAllocEntryCurr."Entry No.") THEN BEGIN
IF IsIntInArrayTen(LaborAllocEntryCurr.Status, StatusArray) THEN BEGIN
LaborAllocEntryPar := LaborAllocEntryCurr;
LaborAllocEntryPar.INSERT;
END;
END;
IF LaborAllocEntryCurr."Applies-to Entry No." > 0 THEN
IF LaborAllocEntryLookIn.GET(LaborAllocEntryCurr."Applies-to Entry No.")
THEN
FindSplitEntries(LaborAllocEntryLookIn."Entry No.", LaborAllocEntryPar,
2, RunModeFlags); //12.08.2013 EDMS P8
END;
END;
PROCEDURE FindRelatedEntries@1101904021(EntryNo@1101904000 : Integer;VAR

LaborAllocEntryTmp@1101904001 : TEMPORARY Record 25006271;DeleteRecs@1101904003 :
Boolean;RunModeFlags@1101904004 : Integer) RetRecCount : Integer;
VAR
BEGIN
// RunModeFlags = 1011, what statuses are taken in account REAden from right
// it is supposed that related as child and parent directions

WITH LaborAllocEntryTmp DO BEGIN
IF DeleteRecs THEN BEGIN
//FIND parent part, SO THAT part is to get rid of recursive loop
IF LaborAllocEntry.GET(EntryNo) THEN
IF LaborAllocEntry."Parent Alloc. Entry No." > 0 THEN BEGIN
FindRelatedEntries(LaborAllocEntry."Parent Alloc. Entry No.",
LaborAllocEntryTmp, TRUE, 1011);
EXIT(LaborAllocEntryTmp.COUNT);
END;
RESET;
DELETEALL;
END;
EXIT;
IF NOT GET(EntryNo) THEN BEGIN
IF IsIntInArrayTen(LaborAllocEntry.Status, StatusArray) THEN BEGIN
LaborAllocEntryTmp := LaborAllocEntry;
INSERT;
END;
END;
//FIND child part
LaborAllocEntryL.SETCURRENTKEY("Parent Alloc. Entry No.");
LaborAllocEntryL.SETRANGE("Parent Alloc. Entry No.", EntryNo);
IF LaborAllocEntryL.FINDFIRST THEN
REPEAT
FindRelatedEntries(LaborAllocEntryL."Entry No.", LaborAllocEntryTmp,
FALSE, 1011);
UNTIL LaborAllocEntryL.NEXT = 0;
END;
EXIT(LaborAllocEntryTmp.COUNT);
END;
PROCEDURE FindFirstAppliedEntryNo@7() RetValue : Integer;

VAR
LaborAllocEntryParent@1101904002 : Record 25006271;
BEGIN
IF LaborAllocEntry."Applies-to Entry No." > 0 THEN BEGIN
LaborAllocEntry.GET(LaborAllocEntry."Applies-to Entry No.");
EXIT(FindFirstAppliedEntryNo)
END ELSE
EXIT(LaborAllocEntry."Entry No.");
END;
PROCEDURE FindAllocEntriesOfServLine@1101904041(ServiceLinePar@1101904003 :
Record 25006146;VAR LaborAllocEntryTmp@1101904002 : TEMPORARY Record
25006271;RunModeFlags@1101904000 : Text[30]);
VAR
LaborAllocAppL@1101904004 : Record 25006277;
BEGIN
LaborAllocAppL.RESET;
END;
PROCEDURE SynchroniseRelatedEntry@1101904023(SourceLaborAllocEntryNo@1101904000
: Integer;DestLaborAllocEntryNo@1101904001 : Integer) SynchronisedCount : Integer;
VAR
SourceLaborAllocEntryTmp@1101904002 : TEMPORARY Record 25006271;
DestLaborAllocEntryTmp@1101904003 : TEMPORARY Record 25006271;
DestStatusBefore@1101904006 : Integer;
BEGIN
FindSplitEntries(SourceLaborAllocEntryNo, SourceLaborAllocEntryTmp, 0, 1111);
FindSplitEntries(DestLaborAllocEntryNo, DestLaborAllocEntryTmp, 0, 1011);
DestLaborAllocEntryTmp.FINDFIRST;
IF SourceLaborAllocEntryTmp.COUNT > DestLaborAllocEntryTmp.COUNT THEN BEGIN
LaborAllocEntry.FINDLAST;
DestLaborAllocEntryTmp.FINDLAST;
REPEAT
InsertAllocationEntry(LaborAllocEntry, LaborAllocApp,
DestLaborAllocEntryTmp."Resource No.",
DestLaborAllocEntryTmp."Start Date-Time",
DestLaborAllocEntryTmp."Quantity (Hours)",
DestLaborAllocEntryTmp."Source Type",
DestLaborAllocEntryTmp."Source Subtype",
DestLaborAllocEntryTmp."Source ID",
DestLaborAllocEntryNo, TRUE,LaborAllocEntry.Travel);
DestLaborAllocEntryTmp := LaborAllocEntry;
DestLaborAllocEntryTmp.INSERT;
UNTIL SourceLaborAllocEntryTmp.COUNT = DestLaborAllocEntryTmp.COUNT;
END ELSE BEGIN
IF SourceLaborAllocEntryTmp.COUNT < DestLaborAllocEntryTmp.COUNT THEN BEGIN
REPEAT
DestLaborAllocEntryTmp.FINDLAST;
DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp,
DestLaborAllocEntryTmp."Entry No.", 11111);
DestLaborAllocEntryTmp.DELETE;
UNTIL SourceLaborAllocEntryTmp.COUNT = DestLaborAllocEntryTmp.COUNT;
END;
END;
// now is going to synchr. times
SourceLaborAllocEntryTmp.FINDFIRST;
DestLaborAllocEntryTmp.FINDFIRST;
EntryNo := 0;
REPEAT
LaborAllocEntry.GET(DestLaborAllocEntryTmp."Entry No.");
DestStatusBefore := LaborAllocEntry.Status;
IF DestLaborAllocEntryTmp."Applies-to Entry No." = 0 THEN
DestLaborAllocEntryTmp."Applies-to Entry No." :=
SourceLaborAllocEntryTmp."Applies-to Entry No.";
ModifyAllocationEntry(LaborAllocEntry, LaborAllocApp,
DestLaborAllocEntryTmp."Entry No.",
DestLaborAllocEntryTmp."Resource No.",
SourceLaborAllocEntryTmp."Start Date-Time",
SourceLaborAllocEntryTmp."Quantity (Hours)",
FALSE, SourceLaborAllocEntryTmp.Status,
DestLaborAllocEntryTmp."Applies-to Entry No.",LaborAllocEntry.Travel);
IF DestStatusBefore <> SourceLaborAllocEntryTmp.Status THEN BEGIN
AllocationStatus := SourceLaborAllocEntryTmp.Status;
ReasonCodeGlobal := SourceLaborAllocEntryTmp."Reason Code";
END;
DestLaborAllocEntryTmp.NEXT;
UNTIL SourceLaborAllocEntryTmp.NEXT = 0;
EXIT(SynchronisedCount);
END;
PROCEDURE SynchroniseRelatedEntries@1101904039(EntryNo@1101904000 : Integer);

VAR
BEGIN
EntryNo := GetMainAllocEntrNo(EntryNo, 1011);
FindRelatedEntries(EntryNo, LaborAllocEntryTemp, TRUE, 1011);
IF LaborAllocEntryTemp.GET(EntryNo) THEN
LaborAllocEntryTemp.DELETE;
REPEAT
IF LaborAllocEntryTemp."Parent Link Synchronize" OR
(LaborAllocEntry."Parent Link Synchronize" AND
(LaborAllocEntry."Entry No." <> LaborAllocEntryTemp."Entry No.")) THEN
BEGIN
SynchroniseRelatedEntry(EntryNo, LaborAllocEntryTemp."Entry No.");
END;
END;
PROCEDURE AllocationSetParam@1101901000(VAR SourceType@1101901000 : ',Service

Document,Standard Event';VAR QtyToAllocate@1101901001 : Decimal;VAR
ServiceLineSrcPar@1101901002 : Record 25006146;VAR ServiceLinePar@1101901005 :
TEMPORARY Record 25006146;VAR LineNo@1101901006 : Integer;Mode@1101901007 : 'New
Allocation,Move Existing,Split Existing,Break';SourceSubType@1101901008 :
'Quote,Order';SourceID@1101901009 : Code[20]);
VAR
IsServiceHeader@1101901003 : Boolean;
BEGIN
CASE SourceType OF
SourceType::"Standard Event": BEGIN
IF QtyToAllocate = 0 THEN
QtyToAllocate := 1;
END;
SourceType::"Service Document": BEGIN
IF ServiceLineSrcPar.FINDFIRST AND (ServiceLineSrcPar."Line No." > 0)
THEN BEGIN //Service Line Allocation
IF ServiceLineSrcPar.COUNT = 1 THEN
LineNo := ServiceLineSrcPar."Line No.";
QtyToAllocate := 0;
REPEAT
ServiceLinePar := ServiceLineSrcPar;
ServiceLinePar.INSERT;
IF Mode = Mode::"New Allocation" THEN
QtyToAllocate += ServiceLinePar.GetTimeQty;
UNTIL ServiceLineSrcPar.NEXT = 0;
END ELSE BEGIN //Service Header Allocation
IF Mode = Mode::"New Allocation" THEN BEGIN
ServiceLineLoc.SETRANGE("Document Type", SourceSubType);
ServiceLineLoc.SETRANGE("Document No.", SourceID);
ServiceLineLoc.SETRANGE(Type, ServiceLineLoc.Type::Labor);
IF ServiceLineLoc.FINDFIRST THEN BEGIN
QtyToAllocate := 0;
REPEAT
QtyToAllocate += ServiceLineLoc.GetTimeQty;
UNTIL ServiceLineLoc.NEXT = 0;
END;
END;
WITH ServiceLinePar DO BEGIN

RESET;
SETRANGE("Document Type", SourceSubType);
SETRANGE("Document No.", SourceID);
SETRANGE("Line No.", 0);
IF NOT FINDFIRST THEN BEGIN
INIT;
"Document Type" := SourceSubType;
"Document No." := SourceID;
"Line No." := 0;
INSERT;
END;
END;
END;
END;
END;
QtyToAllocate := RoundQtyHours(QtyToAllocate, 0);

END;
PROCEDURE RoundQtyHours@1101901003(QtyToRound@1101901000 :
Decimal;RunMode@1101901001 : Integer) : Decimal;
BEGIN
EXIT(ROUND(QtyToRound, 0.1));
END;
PROCEDURE UpdateAllocDetailsText@2(EntryNo@1001 : Integer;DetailsText@1005 :

Text[250];DetEntryNo@1002 : Integer);
VAR
ServLaborAllocationDetailLoc@1003 : Record 25006268;
Isfound@1004 : Boolean;
BEGIN
//24.10.2013 EDMS P8
WITH LaborAllocEntryLoc DO BEGIN
IF EntryNo = 0 THEN
IF GET(EntryNo) THEN BEGIN
Isfound := FALSE;
IF (DetEntryNo <> "Detail Entry No.") THEN BEGIN
IF ServLaborAllocationDetailLoc.GET(DetEntryNo) THEN BEGIN
IF ServLaborAllocationDetailLoc.Description = DetailsText THEN BEGIN
VALIDATE("Detail Entry No.", DetEntryNo);
MODIFY(TRUE);
Isfound := TRUE;
END;
END;
END;
IF NOT Isfound THEN BEGIN
IF ServLaborAllocationDetailLoc.GET("Detail Entry No.") THEN BEGIN
IF ServLaborAllocationDetailLoc.Description = DetailsText THEN BEGIN
//NO NEED CHANGE
Isfound := TRUE;
END;
END;
END;
IF NOT Isfound THEN BEGIN
ServLaborAllocationDetailLoc."Entry No." := 0;
ServLaborAllocationDetailLoc.Description := DetailsText;
ServLaborAllocationDetailLoc.INSERT(TRUE);
DetEntryNo := ServLaborAllocationDetailLoc."Entry No.";
LaborAllocEntry.VALIDATE("Detail Entry No.", DetEntryNo);
LaborAllocEntry.MODIFY(TRUE);
END;
END;
END;
END;
PROCEDURE ErrorWithRefresh@4(MsgText@1000 : Text[1024]);

BEGIN
ErrorStatus := 2;
ErrorMsgText := MsgText;
END;
PROCEDURE SetErrorStatus@6(ErrorStatusPar@1000 : Integer);
BEGIN
ErrorStatus := ErrorStatusPar;
END;
PROCEDURE GetErrorStatus@3() : Integer;

BEGIN
EXIT(ErrorStatus);
END;
PROCEDURE GetErrorMsgText@5() : Text[1024];

BEGIN
EXIT(ErrorMsgText);
END;
PROCEDURE SetAllocationStatus@25006001(AllocationStatus1@25006000 : 'Pending,In

Process,Finished,On Hold');
BEGIN
AllocationStatus := AllocationStatus1;
END;

BEGIN
IF SingleInstanceManagment.GetTimeJournalFlag THEN
EXIT;
OnDate := DateTimeMgt.Datetime2Date(StartingDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartingDateTime);
ServiceSetup.GET;
Resource.GET(ResourceNo);
CASE Resource."On Task Start" OF
Resource."On Task Start"::"Hold Other Tasks":
BEGIN
LaborAllocEntry.SETRANGE("Resource No.", ResourceNo);
LaborAllocEntry.SETRANGE(Status, LaborAllocEntry.Status::"In
Progress");
LaborAllocEntry.SETFILTER(LaborAllocEntry."Entry No.",'<>
%1',EntryNo);
LaborAllocEntry.SETFILTER(LaborAllocEntry."Applies-to Entry No.",'<>
%1',EntryNo);
LaborAllocEntry.SETFILTER("Source ID",'<>%1',ServiceSetup."Default
Idle Event");
IF LaborAllocEntry.FINDFIRST THEN BEGIN
REPEAT
MainAllocEntryNo := GetMainAllocEntrNo(LaborAllocEntry."Entry
No.", 1011);
IF MainLaborAllocationEntry.GET(MainAllocEntryNo) AND
(MainLaborAllocationEntry.Status =
MainLaborAllocationEntry.Status::"In Progress") THEN BEGIN
StatusToSet := StatusToSet::"On Hold";
SingleInstanceManagment.SetCurrAllocation(MainLaborAllocationEntry."Entry No.");
StartFinishAllocation.SetParam(ResourceNo,
DateTimeMgt.Datetime(OnDate, OnTime),
MainLaborAllocationEntry."Quantity (Hours)",
MainLaborAllocationEntry."Source Type",
MainLaborAllocationEntry."Source Subtype",
MainLaborAllocationEntry."Source ID",
StatusToSet,
0);
StartFinishAllocation.StartEndWork;
END;
//WriteAllocationEntryEnd(LaborAllocEntry."Entry No.",
StartingDateTime, FALSE, '',LaborAllocEntry.Travel);
ResourceTimeRegMgt.AddTimeRegEntries('Onhold',MainLaborAllocationEntry,MainLaborAll
ocationEntry."Resource No.",OnDate,OnTime);
UNTIL LaborAllocEntry.NEXT = 0
END;
END;
Resource."On Task Start"::"Complete Other Tasks":
BEGIN
LaborAllocEntry.SETRANGE("Resource No.", ResourceNo);
LaborAllocEntry.SETFILTER(Status,'%1',LaborAllocEntry.Status::"In
Progress");
LaborAllocEntry.SETFILTER(LaborAllocEntry."Entry No.",'<>
%1',EntryNo);
LaborAllocEntry.SETFILTER(LaborAllocEntry."Applies-to Entry No.",'<>
%1',EntryNo);
LaborAllocEntry.SETFILTER("Source ID",'<>%1',ServiceSetup."Default
Idle Event");
IF LaborAllocEntry.FINDFIRST THEN BEGIN
REPEAT
MainAllocEntryNo := GetMainAllocEntrNo(LaborAllocEntry."Entry
No.", 1011);
IF MainLaborAllocationEntry.GET(MainAllocEntryNo) AND
(MainLaborAllocationEntry.Status =
MainLaborAllocationEntry.Status::"In Progress") THEN BEGIN
StatusToSet := StatusToSet::"Finish All";
SingleInstanceManagment.SetCurrAllocation(MainLaborAllocationEntry."Entry No.");
StartFinishAllocation.SetParam(ResourceNo,
DateTimeMgt.Datetime(OnDate, OnTime),
MainLaborAllocationEntry."Quantity (Hours)",
MainLaborAllocationEntry."Source Type",
MainLaborAllocationEntry."Source Subtype",
MainLaborAllocationEntry."Source ID",
StatusToSet,
0);
StartFinishAllocation.StartEndWork;
END;
//WriteAllocationEntryEnd(LaborAllocEntry."Entry No.",
StartingDateTime, FALSE, '',LaborAllocEntry.Travel);
ResourceTimeRegMgt.AddTimeRegEntries('Complete',LaborAllocEntry,LaborAllocEntry."Re
source No.",OnDate,OnTime);
UNTIL LaborAllocEntry.NEXT = 0
END;
END;
END;
END;
PROCEDURE "--SERVICE RESOURCES--"@1101904027();

BEGIN
END;
PROCEDURE GetRelatedResources@1101904026(DocType@1101904001 :
: Integer;RunMode@1101904000 : Integer) RetValue : Text[250];
VAR
ServLaborApplication@1101904002 : Record 25006277;
ServLaborApplicationTmp@1101904003 : TEMPORARY Record 25006277;
ServLaborApplicationLoc@1101901003 : Record 25006277;
isItDocAllocation@1101904004 : Boolean;
isTempTableUse@1101901001 : Boolean;
BEGIN
//RunMode first digit from right means should it be used temp resource table
RetValue := '';
IF LineType = ServiceLine.Type::Labor THEN BEGIN
WITH ServLaborApplicationTmp DO BEGIN
RESET;
DELETEALL;
END;
WITH ServLaborApplication DO BEGIN
RESET;
SETRANGE("Document Type", DocType);
SETRANGE("Document No.", DocNo);
IF LineNo = 0 THEN BEGIN
// in case that requested for document:
SETRANGE("Document Line No.");
END ELSE BEGIN
SETRANGE("Document Line No.", 0); // at first try to find document
allocation
SETRANGE("Document Line No.", LineNo);
END;
REPEAT
ServLaborApplicationTmp.SETRANGE("Resource No.", "Resource No.");
IF NOT ServLaborApplicationTmp.FINDFIRST THEN BEGIN
RetValue += "Resource No."+',';
ServLaborApplicationTmp := ServLaborApplication;
ServLaborApplicationTmp.INSERT;
END;
UNTIL NEXT = 0;
RetValue := COPYSTR(RetValue, 1, STRLEN(RetValue)-1);
END;
END;
END;
EXIT(RetValue);
END;
PROCEDURE SetRelatedResources@1101904031(DocType@1101904018 :
: Integer;RecourcesTextSource@1101904004 : Text[250];RunMode@1101904000 : Integer)
ResourcesCount : Integer;
VAR
Posit@1101904005 : Integer;
ResourceToAdd@1101904010 : Text[30];
RecourcesText@1101904003 : Text[250];
RecourcesTextToModify@1101904012 : Text[250];
AllocEntryNo@1101904006 : Integer;
isItDocAllocation@1101904007 : Boolean;
divResult@1101904009 : Integer;
isItAllowedMessage@1101904013 : Boolean;
BEGIN
//RunMode = 0 - normal; 1 - no messages; second digit (tens) - is it document
allocation
ServiceSetup.GET;
isItAllowedMessage := ((RunMode MOD 10) = 0);
divResult := (RunMode DIV 10);
isItDocAllocation := ((divResult > 0) AND ((divResult MOD 10) > 0));
IF ((LineNo = 0) AND NOT isItDocAllocation) THEN
ERROR(Text148);
RecourcesText := RecourcesTextSource;
ResourcesCount := 0;
IF LineType = ServiceLine.Type::Labor THEN BEGIN
IF NOT FINDFIRST THEN BEGIN
// actually for nowdays such case is unpossible, but in future...
IF FINDFIRST THEN
IF isItAllowedMessage THEN BEGIN
IF NOT CONFIRM(Text147,FALSE) THEN
EXIT;
END ELSE
EXIT;
END;
REPEAT
Posit := STRPOS(RecourcesText, ',');
IF Posit > 0 THEN BEGIN
ResourceToAdd := COPYSTR(RecourcesText, 1, Posit - 1);
RecourcesText := COPYSTR(RecourcesText, Posit + 1,
STRLEN(RecourcesText)-Posit);
END ELSE BEGIN
ResourceToAdd := RecourcesText;
RecourcesText := '';
END;
IF Resource.GET(ResourceToAdd) THEN BEGIN
SETRANGE("Resource No.", ResourceToAdd);
IF NOT FINDLAST THEN BEGIN
Resource.TESTFIELD(Blocked, FALSE);
INIT;
"Allocation Entry No." := 0;
"Document Type" := DocType;
"Document No." := DocNo;
"Document Line No." := LineNo;
"Resource No." := ResourceToAdd;
INSERT(TRUE);
END;
END;
UNTIL RecourcesText = '';
SETRANGE("Resource No.");
IF isItDocAllocation THEN
IF FINDFIRST THEN
REPEAT
Posit := STRPOS(RecourcesTextSource, "Resource No.");
IF NOT (Posit > 0) THEN BEGIN
DELETE(TRUE);
FINDFIRST;
END;
UNTIL NEXT = 0;
Posit := STRPOS(RecourcesTextSource, "Resource No.");
IF NOT (Posit > 0) THEN
DELETE(TRUE);
END;
IF FINDFIRST THEN
REPEAT
RecourcesTextToModify += "Resource No." + ',';
UNTIL NEXT = 0;
IF STRLEN(RecourcesTextToModify) > 0 THEN
RecourcesTextToModify := COPYSTR(RecourcesTextToModify, 1,
STRLEN(RecourcesTextToModify)-1);
END;
END;
EXIT(ServLaborApplication.COUNT);
END;
PROCEDURE RelatedResourcesList@1101904030(DocType@1101904005 :
: Integer;VAR RelatedResources@1101904000 : Text[250]);
VAR
BEGIN
ServLaborAllocApplication.RESET;
ServLaborAllocApplication.SETRANGE("Document Type", DocType);
ServLaborAllocApplication.SETRANGE("Document No.", DocNo);
ServLaborAllocApplication.SETRANGE("Document Line No.", LineNo);
IF LineNo < 0 THEN
ServLaborAllocApplication.SETRANGE("Document Line No.");
PAGE.RUNMODAL(PAGE::"Service Line Resources", ServLaborAllocApplication);
RelatedResources := GetRelatedResources(DocType, DocNo, LineType, LineNo, 0);
END;
PROCEDURE ResourcesList@1101904029(DocType@1101904006 :
: Integer;VAR RelatedResources@1101904000 : Text[250]);
VAR
BEGIN
//??? checkstatusopen
// not used for now, it is supposed to be used for lookup (case then SS
unactive and only one resource is set)
ServiceSetup.GET;
IF ServiceSetup."Service Schedule Active" THEN
ERROR(Text146);

RESET;
IF FINDFIRST THEN
IF Resource.GET("Resource No.") THEN;
END;
IF PAGE.RUNMODAL(0,Resource) = ACTION::OK THEN BEGIN
RelatedResources := Resource."No.";
IF ServLaborApplication.FINDFIRST THEN BEGIN
ServLaborApplication.SETRANGE("Resource No.", Resource."No.");
ServLaborApplication.SETRANGE("Resource No.");
ServLaborApplication.SETFILTER("Resource No.", '<>%1', Resource."No.");
IF ServLaborApplication.FINDFIRST THEN
ServLaborApplication.DELETEALL(TRUE);
END ELSE BEGIN
ServLaborApplication.SETRANGE("Resource No.");
ServLaborApplication.FINDFIRST;
ServLaborApplication."Resource No." := Resource."No.";
ServLaborApplication.MODIFY;
ServLaborApplication.FINDLAST;
REPEAT
ServLaborApplication.DELETE(TRUE);
UNTIL ServLaborApplication."Resource No." = Resource."No.";
END;
END ELSE BEGIN
ServLaborApplication.INIT;
ServLaborApplication."Allocation Entry No." := 0;
ServLaborApplication."Document Type" := DocType;
ServLaborApplication."Document No." := DocNo;
ServLaborApplication."Document Line No." := LineNo;
ServLaborApplication."Resource No." := Resource."No.";
ServLaborApplication.INSERT(TRUE);
END;
END;
END;
PROCEDURE ResourcesCopyLineToLine@1101904028(DocType@1101904010 :
: Integer;DocTypeDestin@1101904001 : Integer;DocNoDestin@1101904002 :
Code[20];LineNoDestin@1101904003 : Integer);
VAR
ServiceLineDest@1101904004 : Record 25006146;
ResourcesText@1101904006 : Text[250];
BEGIN
//Allocation Entry No.,Document Type,Document No.,Line No.
ServiceSetup.GET;
IF NOT ServiceSetup."Service Schedule Active" THEN BEGIN
ResourcesText := GetRelatedResources(DocType, DocNo, LineType, LineNo, 0);
IF ServiceLineDest.GET(DocTypeDestin, DocNoDestin, LineNoDestin) THEN
SetRelatedResources(DocType, DocNo, LineType, LineNo, ResourcesText, 0);
END;
//means that schedule entries we are not going to copy
END;
PROCEDURE FillRelatedApplicOfEntry@1101904032(VAR
ServLaborAllocApplicationPar@1101904000 : Record 25006277;EntryNoPar@1101904001 :
Integer;VAR LineNoPar@1101904002 : Integer;DocType@1101904006 :
Integer;DocNo@1101904007 : Code[20];ResourceNoPar@1101904008 :
Code[20];NextNewAllocEntryNo@1101904009 : Integer);
VAR
LaborAllocApplicationL@1101904005 : Record 25006277;
ServLaborAllocationEntryTmp@1101904003 : TEMPORARY Record 25006271;
BEGIN
IF LaborAllocEntryL.GET(EntryNoPar) THEN BEGIN
LaborAllocApplicationL.SETRANGE("Document Type", LaborAllocEntryL."Source
Subtype");
LaborAllocApplicationL.SETRANGE("Document No.", LaborAllocEntryL."Source
ID");
LaborAllocApplicationL.SETRANGE("Allocation Entry No.",
LaborAllocEntryL."Entry No.");
IF LaborAllocApplicationL.FINDFIRST THEN
LineNoPar := LaborAllocApplicationL."Document Line No.";
FindRelatedEntries(EntryNoPar, ServLaborAllocationEntryTmp, TRUE, 1011);

WITH ServLaborAllocationEntryTmp DO BEGIN
LaborAllocApplicationL.RESET;
IF FINDFIRST THEN
REPEAT
LaborAllocApplicationL.SETRANGE("Document Type", "Source Subtype");
LaborAllocApplicationL.SETRANGE("Document No.", "Source ID");
LaborAllocApplicationL.SETRANGE("Allocation Entry No.", "Entry No.");
IF LaborAllocApplicationL.FINDFIRST THEN
IF LaborAllocApplicationL.FINDFIRST THEN BEGIN
ServLaborAllocApplicationPar := LaborAllocApplicationL;
ServLaborAllocApplicationPar.INSERT(TRUE);
END;
UNTIL NEXT = 0;
END;
END ELSE BEGIN
// means new entry
ServLaborAllocApplicationPar."Allocation Entry No." := NextNewAllocEntryNo;
ServLaborAllocApplicationPar."Document Type" := DocType;
ServLaborAllocApplicationPar."Document No." := DocNo;
ServLaborAllocApplicationPar."Document Line No." := LineNoPar;
ServLaborAllocApplicationPar."Resource No." := ResourceNoPar;
ServLaborAllocApplicationPar.INSERT(TRUE);
END;
END;
PROCEDURE RemoveDuplicates@1101901002(VAR ServLaborApplication@1101901002 :

Record 25006277);
VAR
ServLaborApplicationLoc@1101901001 : Record 25006277;
ServLaborApplicationLoc2@1101901000 : Record 25006277;
BEGIN
// THAT part to remove duplicates that are not in schedule
ServLaborApplicationLoc.RESET;
ServLaborApplicationLoc.SETRANGE("Document Type",
ServLaborApplication."Document Type");
ServLaborApplicationLoc.SETRANGE("Document No.",
ServLaborApplication."Document No.");
ServLaborApplicationLoc.SETRANGE("Document Line No.",
ServLaborApplication."Document Line No.");
ServLaborApplicationLoc.SETRANGE("Allocation Entry No.", 0);
REPEAT
ServLaborApplicationLoc.SETRANGE("Resource No.",
ServLaborApplication."Resource No.");
IF ServLaborApplicationLoc.FINDSET THEN BEGIN
ServLaborApplicationLoc2.COPYFILTERS(ServLaborApplicationLoc);
ServLaborApplicationLoc2.SETFILTER("Allocation Entry No.",'>0');
IF ServLaborApplicationLoc2.FINDSET THEN BEGIN
ServLaborApplicationLoc.DELETEALL(TRUE);
END ELSE BEGIN
IF ServLaborApplicationLoc.COUNT > 1 THEN BEGIN
REPEAT
ServLaborApplicationLoc.FINDFIRST;
ServLaborApplicationLoc.DELETE(TRUE);
UNTIL ServLaborApplicationLoc.COUNT <= 1;
END;
END;
END;
UNTIL ServLaborApplication.NEXT = 0;
END;
END;
PROCEDURE "--SMALL TECHN--"@1101904033();

BEGIN
END;
PROCEDURE CutNextDigit@1101904038(VAR Flags@1101904000 : Integer) RetValue :

Integer;
BEGIN
RetValue := Flags MOD 10;
Flags := Flags DIV 10;
EXIT(RetValue);
END;
PROCEDURE AdjustFlagsToArray@1101904035(Flags@1101904000 : Integer;VAR

ArrayDMS@1101904001 : ARRAY [10] OF Integer);
VAR
i@1101904002 : Integer;
BEGIN
FOR i := 1 TO 10 DO BEGIN
IF (CutNextDigit(Flags) > 0) THEN
ArrayDMS[i] := i-1
ELSE
ArrayDMS[i] := -1;
END;
END;
PROCEDURE IsIntInArrayTen@1101904036(CheckValue@1101904001 : Integer;VAR

ArrayDMS@1101904000 : ARRAY [10] OF Integer) RetValue : Boolean;
VAR
i@1101904002 : Integer;
BEGIN
FOR i := 1 TO 10 DO BEGIN
IF (CheckValue = ArrayDMS[i]) THEN
RetValue := TRUE;
END;
EXIT(RetValue);
END;
PROCEDURE CopyServLaborAllocAppl@9(FromDocType@1002 : 'Quote,Order,Return

Order,Invoice,Credit Memo,Blanket Order';FromDocNo@1001 :
Code[20];FromLineNo@1000 : Integer;IsPosted@1006 : Boolean;ToServLine@1003 : Record
25006146);
VAR
FromServLaborAllocAppl@1005 : Record 25006277;
NewServLaborAllocAppl@1004 : Record 25006277;
BEGIN
WITH FromServLaborAllocAppl DO BEGIN
RESET;
SETRANGE("Document Type", FromDocType);
SETRANGE("Document No.", FromDocNo);
SETRANGE("Document Line No.", FromLineNo);
SETRANGE(Posted, IsPosted);
IF FINDSET THEN
REPEAT
IF Resource.GET("Resource No.") THEN BEGIN
NewServLaborAllocAppl.INIT;
NewServLaborAllocAppl.TRANSFERFIELDS(FromServLaborAllocAppl, FALSE);
NewServLaborAllocAppl."Allocation Entry No." := 0;
NewServLaborAllocAppl."Document Type" := ToServLine."Document Type";
NewServLaborAllocAppl."Document No." := ToServLine."Document No.";
NewServLaborAllocAppl. "Document Line No." := ToServLine."Line No.";
NewServLaborAllocAppl.Posted := FALSE;
NewServLaborAllocAppl.INSERT(TRUE);
END;
UNTIL NEXT = 0;
END;
END;
PROCEDURE CancelAllocation@8(AllocationStatus1@1000 : 'Pending,In

Progress,Finish All,Finish Part,On Hold';StartingDateTime@1005 :
Decimal;ShowDialog@1003 : Boolean);
VAR
ServSchedAddInMgt@1004 : Codeunit 25006203;
BEGIN
IF ShowDialog THEN
EXIT;

MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(1, LaborAllocEntry) THEN
EXIT;
IF AllocationStatus1 = AllocationStatus1::Pending THEN BEGIN

IF (LaborAllocEntry.Status = LaborAllocEntry.Status::Pending) AND NOT
ShowDialog THEN
EXIT;
IF LaborAllocEntry.Status <> LaborAllocEntry.Status::"In Progress" THEN

ERROR(Text162);

DoReplan := FALSE;
WriteAllocationEntries(LaborAllocEntry."Resource No.", StartingDateTime,

Hours,
LaborAllocEntry."Source ID", 1,
LaborAllocEntry."Entry No.", DoReplan, AllocationStatus, FALSE,Travel);
// Cancel Start Allocations for Applied Entries too

LaborAllocEntry2.RESET;
LaborAllocEntry2.SETRANGE("Applies-to Entry No.", LaborAllocEntry."Entry
No.");
ServSchedAddInMgt.CancelStartAllocation(LaborAllocEntry2."Entry No.",
LaborAllocEntry2."Resource No.", LaborAllocEntry2."Start Date-Time",
LaborAllocEntry2."End Date-Time", FALSE);
END;
END;
PROCEDURE CopyServLaborAllocApplFromDetServLedg@25006000(FromDocType@25006006 :
'Quote,Order,Return Order,Invoice,Credit Memo,Blanket Order';FromDocNo@25006005 :
Code[20];FromLineNo@25006004 : Integer;ToServLine@25006002 : Record 25006146);
VAR
NewServLaborAllocAppl@25006000 : Record 25006277;
ServLedgEntry@25006001 : Record 25006167;
DetServLedgEntry@25006003 : Record 25006188;
BEGIN
WITH ServLedgEntry DO BEGIN
RESET;
SETRANGE("Document Type", FromDocType);
SETRANGE("Document No.", FromDocNo);
SETRANGE("Document Line No.", FromLineNo);
IF FINDSET THEN
REPEAT
DetServLedgEntry.RESET;
DetServLedgEntry.SETRANGE("Service Ledger Entry No.","Entry No.");
IF DetServLedgEntry.FINDSET THEN
REPEAT
IF Resource.GET(DetServLedgEntry."Resource No.") THEN BEGIN
NewServLaborAllocAppl.INIT;
NewServLaborAllocAppl."Allocation Entry No." := 0;
NewServLaborAllocAppl."Document Type" := ToServLine."Document Type";
NewServLaborAllocAppl."Document No." := ToServLine."Document No.";
NewServLaborAllocAppl."Document Line No." := ToServLine."Line No.";
NewServLaborAllocAppl."Line No." += 10000;
NewServLaborAllocAppl."Resource No." := DetServLedgEntry."Resource
No.";
NewServLaborAllocAppl."Finished Quantity (Hours)" :=
ABS(DetServLedgEntry."Finished Quantity (Hours)");
NewServLaborAllocAppl."Time Line" := TRUE;
NewServLaborAllocAppl."Unit Cost" := DetServLedgEntry."Unit Cost";
NewServLaborAllocAppl."Finished Cost Amount" :=
ABS(DetServLedgEntry."Cost Amount");
NewServLaborAllocAppl."Cost Amount" := ABS(DetServLedgEntry."Cost
Amount");
NewServLaborAllocAppl.Posted := FALSE;
NewServLaborAllocAppl.INSERT(TRUE);
END;
UNTIL DetServLedgEntry.NEXT=0;
UNTIL NEXT = 0;
END;
END;
BEGIN
{
05.10.2018 EB.P7 Bug in email
Modified functions:
AllocateStandardEvent
AllocateServiceLines
AllocateServiceOrder
AllocationSetParam
11.06.2015 EB.P7 #Schedule3.0
GetAllocRecDescr Modified.
28.05.2015 EB.P30 #T030

Created function:
CopyServLaborAllocApplFromDetServLedg
12.05.2015 EB.P30 #T030

Modified functions:
InsertAllocApplication
ModifyAllocApplication
18.12.2014 Elva Baltic P21 #E0003

Modified procedure:
DeleteAllocationFromServLines
12.12.2014 EB.P8
Small fix.
19.05.2014 Elva Baltic P21 #S0101 MMG7.00

Modified function:
CancelAllocation

Added function:
CancelAllocation

Modified function:
CreateFieldText
12.05.2014 Elva Baltic P21 #F182 MMG7.00

Added function:
CopyServLaborAllocAppl
09.04.2014 Elva Baltic P1 #RX MMG7.00

* Temporaty=TRUE set for variable ServiceLine in function
ServiceMoveAllocation
22.03.2014 Elva Baltic P1 #X01 MMG7.00

* Modified AllocateNewVisitOrder function

* Fix: Details Entry No. should be copied into related allocations
* New function FindFirstAppliedEntryNo
10.12.2013 EDMS P8
* fix when lost "Applies-to Entry No."
22.11.2013 EDMS P8
20.11.2013 EDMS P8
* small changes in user rights
* add functions ErrorWithRefresh
24.10.2013 EDMS P8
* Implement use of T25006268. New UpdateAllocDetailsText
17.10.2013 EDMS P8
* now able to start job with change resource
* now able to start FEW jobs if Resource."Allow Several Jobs AtOnce"
15.08.2013 EDMS P8
* fix for case: ON HOLD it did finish current allocation with correct end
time but did not createhold allocation part...
* CHANGE IN FindSplitEntries
12.08.2013 EDMS P8
* fix for case: try to Break allocation in process without chosen
T25006272.Code, now it will bring error
* fix for case: finished splitten allocation should react on moving the
same as it is in other status, like 'Pending'
20.07.2013 EDMS P8
* fix for case: create new allocation that is going to be splitten in
several parts it made unrelated allocations
* fix for case: if once push on finished allocation that is continuous on
unavailable time as well it made split
* fix for case: resize allocation in case of split it did split and in new
allocation other status than first
* fix for case: at start of split allocation it did increase total time.
* fix for case: at finish of split allocation it did left other allocation
in progress, but should delete it.
* fix for case: at Hold Allocation on serv doc allocat. it brought error ''
(do not create correct application line for next new allocat.).
* fix for case: at Hold Allocation on SPLITTEN allocation it made one hold
allacation and last alloc. part left 'In Process'
09.07.2013 EDMS P8
* fix to make new allocation line - it was created for wholo header
instead...
28.06.2013 EDMS P8
* fix error message "Not found Alloc Entry,,,"
* add COMgeVar.RUNMODAL

MSH

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

MSH

Uploaded by

Copyright:

Available Formats

Text101@1101908001 : TextConst 'ENU=Do you want to move all connected

Text112@1101908020 : TextConst 'ENU=Wrong password.';

PROCEDURE FillAllocEntryBuffer@1190003(VAR TempLaborAllocEntry@1190000 :

PROCEDURE BufferContainsSelectedEntry@1190005(VAR TempLaborAllocEntry@1190000 :

IF CellType IN [CellType::Allocation, CellType::Availability] THEN

IF CellType = CellType::Allocation THEN BEGIN

PROCEDURE GetMatrixGroupCellValue@1190021(VAR ResourceCodeBuffer@1190002 :

SetCellFormat(TempLaborAllocEntry, Bold, ForeColor);

PROCEDURE SetCellFormat@1101908034(VAR TempLaborAllocEntry@1101908000 :

IF NOT TempLaborAllocEntry.GET(SingleInstanceMgt.GetAllocationEntryNo) THEN

ColorConfig.SETRANGE("Source Type", TempLaborAllocEntry."Source Type");

PROCEDURE SetCellFormatRTC@1101904002(VAR LaborAllocEntry@1101904002 : Record

ColorConfig.SETRANGE("Source Type", LaborAllocEntry."Source Type");

ColorConfig.SETFILTER("Work Status", '%1|''''', ServiceHeader."Work Status

IF ColorConfig.FINDLAST THEN BEGIN

CurrDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

IF (CurrDateTime > LaborAllocEntry."End Date-Time") AND

PROCEDURE SetCellFormatRTCRent@10(VAR RentAvailabilityBufferTmp@1000 : Record

ColorConfig.SETRANGE("Source Type", ColorConfig."Source Type"::Rent);

IF ColorConfig.FINDLAST THEN BEGIN

PROCEDURE SetResourceColor@1101908033(ResourceNo@1101908001 : Code[20];VAR

PROCEDURE SetDateColor@1190001(DateFilter@1101908001 : Date;VAR

PROCEDURE GetAllocRecDescr@1190018(VAR LaborAllocEntry@1190000 : Record

IF RecordDesr = '' THEN

IF RecordCount = 1 THEN BEGIN

PROCEDURE Deallocate@1190006(EntryNo@1101904000 : Integer);

IF NOT LaborAllocEntryLoc.GET(EntryNo) THEN BEGIN

IF LaborAllocEntryLoc.Status IN [LaborAllocEntryLoc.Status::"In Progress",

IF LaborAllocEntryTemp.FINDFIRST THEN BEGIN

CurrDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

IF AllocationStatus1 = AllocationStatus1::"In Progress" THEN BEGIN

IF AllocationStatus1 IN [AllocationStatus1::"Finish All",

//BABEIGT, notesteet ==>

CurrDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

IF NOT LaborAllocEntry.GET(SingleInstanceMgt.GetAllocationEntryNo) THEN BEGIN

IF NOT CheckUserRightsAdv(4, LaborAllocEntry) THEN EXIT;

OldResourceNo := LaborAllocEntry."Resource No.";

IF ServiceScheduleSetup."Handle Linked Entries" <>

IF NewResourceNo <> OldResourceNo THEN BEGIN //replan old resource entries

IF ServiceScheduleSetup."Handle Linked Entries" <>

OldStartingDateTime := LaborAllocEntry."Start Date-Time";

//MESSAGE('msg in movement 1');

//MESSAGE('msg in movement 2');

IF ServiceScheduleSetup."Handle Linked Entries" <>

IF RoundMs > 0 THEN BEGIN

IF StandardEvents.RUNMODAL = ACTION::LookupOK THEN

IF NOT CheckUserRightsAdv(100, LaborAllocEntry) THEN EXIT;

IF ServiceLinesAllocation.RUNMODAL = ACTION::LookupOK THEN

IF ServiceHdrsAllocation.RUNMODAL = ACTION::LookupOK THEN

PROCEDURE AllocateEventAndStart@1190035(ResourceNo@1190002 : Code[20]);

StartingDateTime := DateTimeMgt.Datetime(WORKDATE, TIME);

IF StandardEvents.RUNMODAL = ACTION::LookupOK THEN

WITH ServiceHdr DO BEGIN

WITH ServiceHdr DO BEGIN

IF ServiceScheduleSetup."Handle Linked Entries" <>

PROCEDURE ProcessAllocationResources@1101904019(VAR ResourceTmp@1190005 :

IF NOT CheckUserRightsAdv(200, LaborAllocEntry) THEN EXIT;

IF SplitAllocTracking(EntryNo, 0) THEN BEGIN

IF ServiceScheduleSetup."Handle Linked Entries" <>

IF ServiceScheduleSetup."Handle Linked Entries" <>

DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp, EntryNo, 11111);

END ELSE BEGIN