U=X';

Text100@1101908000 : TextConst 'ENU=Do you want to delete all connected

entries?';
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.';
Text109@1101908017 : TextConst 'ENU=This labor allocation entry is already
finished.';
Text110@1101908018 : TextConst 'ENU=This labor allocation entry is already in
progress.';
Text111@1101908019 : TextConst 'ENU=You can only finish labor that is in
progress.';
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
[Link];
[Link]("Resource No.","Start Date-Time","End Date-
Time");
[Link]("Resource No.",ResourceNo);
[Link]("Start Date-Time",'<=%1',EndingDateTime);
[Link]("End Date-Time",'>%1',StartingDateTime);
IF [Link] THEN
REPEAT
TempLaborAllocEntry := LaborAllocEntry;
[Link];
UNTIL [Link] = 0;
END;

PROCEDURE BufferContainsSelectedEntry@1190005(VAR TempLaborAllocEntry@1190000 :

TEMPORARY Record 25006271) : Boolean;
BEGIN
IF [Link] THEN
REPEAT
IF TempLaborAllocEntry."Entry No." = [Link]
THEN
EXIT(TRUE);
UNTIL [Link]=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
[Link];

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

FillAllocEntryBuffer(TempLaborAllocEntry,ResourceNo,StartingDateTime,EndingDateTime
);

IF CellType = CellType::Allocation THEN BEGIN

RecordCount := [Link];
IF RecordCount > 1 THEN
CellValueText := '(' + FORMAT(RecordCount) + ') ';

IF BufferContainsSelectedEntry(TempLaborAllocEntry) THEN
CellValueText := COPYSTR(CellValueText +
GetAllocRecDescr(TempLaborAllocEntry), 1, 250)
ELSE
 BEGIN
RecordCount := 0;
[Link];
IF [Link] THEN
REPEAT
RecordCount += 1;
IF RecordCount > 1 THEN
CellValueText := COPYSTR(CellValueText + '; ', 1, 250);

CellValueText := COPYSTR(CellValueText +
GetAllocRecDescr(TempLaborAllocEntry), 1, 250);
UNTIL ([Link] = 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
TempLaborAllocEntry@1190003 : TEMPORARY Record 25006271;
RecordCount@1190004 : Integer;
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 := [Link];

[Link](ResourceCodeBuffer);
[Link];

IF [Link] THEN
REPEAT
IF ResourceCodeBuffer."Applies-to Code" = GroupCode THEN BEGIN
[Link];
IF CellType IN [CellType::Allocation, CellType::Availability] THEN BEGIN
FillAllocEntryBuffer(TempLaborAllocEntry,[Link],StartingDateTime,E
ndingDateTime);
AllocatedHours += GetNotAvailabilityTime(TempLaborAllocEntry,
StartingDateTime, EndingDateTime);
END;
IF CellType IN [CellType::Availability, CellType::Capacity] THEN
CapacityHours +=
GetCapacity([Link],StartingDateTime,EndingDateTime);
END;
UNTIL [Link] = 0;

[Link](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
TempLaborAllocEntry@1190003 : TEMPORARY Record 25006271;
RecordCount@1190004 : Integer;
BEGIN

FillAllocEntryBuffer(TempLaborAllocEntry,ResourceNo,StartingDateTime,EndingDateTime
);

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
[Link];
 RecCount := [Link];
IF RecCount = 0 THEN
EXIT;
IF BufferContainsSelectedEntry(TempLaborAllocEntry) THEN
[Link]("Active Allocation", TRUE)
ELSE
[Link]("Active Allocation", FALSE);

IF RecCount > 1 THEN BEGIN

[Link]("Mixed Allocation", TRUE);
IF [Link] THEN BEGIN
Bold := ColorConfig."Font Bold";
ForeColor := ColorConfig."Font Color";
EXIT;
END;
[Link]("Mixed Allocation", FALSE);
END ELSE
[Link]("Mixed Allocation", FALSE);

IF NOT [Link]([Link]) THEN

[Link];

[Link]("Source Type", TempLaborAllocEntry."Source Type");

[Link]("Source Subtype", TempLaborAllocEntry."Source Subtype");
IF [Link](TempLaborAllocEntry."Source Subtype",
TempLaborAllocEntry."Source ID") THEN;
[Link]("Work Status", '%1|''''', ServiceHdr."Work Status
Code");
[Link](Status, [Link]);
//DELTA BCH 27/01/2021
[Link](PDI, [Link]);
//DELTA BCH 27/01/2021
IF [Link] THEN BEGIN
Bold := ColorConfig."Font Bold";
ForeColor := ColorConfig."Font Color";
END;
END;

PROCEDURE SetCellFormatRTC@1101904002(VAR LaborAllocEntry@1101904002 : Record

25006271;VAR ForeColor@1101908002 : Integer;VAR BackColor@1101904001 : Integer);
VAR
ColorConfig@1101908003 : Record 25006281;
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
[Link];
ForeColor := 0; //Black
BackColor := 16777215; //White
EXIT;
END;

ForeColor := 0; //Black
BackColor := 16777215; //White
 [Link];
//[Link]("Active Allocation", FALSE);
//[Link]("Mixed Allocation", FALSE);

[Link]("Source Type", LaborAllocEntry."Source Type");

[Link]("Source Subtype", LaborAllocEntry."Source Subtype");

IF LaborAllocEntry."Source Type" = LaborAllocEntry."Source Type"::"Service

Document" THEN BEGIN
IF (NOT [Link](LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID")) AND
(NOT [Link](LaborAllocEntry."Source ID"))THEN
EXIT;
IF LaborAllocEntry."Source Subtype" = LaborAllocEntry."Source
Subtype"::Order THEN BEGIN
//[Link];
//[Link]("Document
Type",ServLaborAllocationApplication."Document Type"::Order);
//[Link](Posted,TRUE);
//IF [Link] THEN
// [Link]("Source Subtype", ColorConfig."Source
Subtype"::"Posted Order");
IF [Link](LaborAllocEntry."Source ID") THEN
[Link]("Source Subtype", ColorConfig."Source
Subtype"::"Posted Order");
END;
IF LaborAllocEntry."Source Subtype" = LaborAllocEntry."Source
Subtype"::"Return Order" THEN BEGIN
IF [Link](LaborAllocEntry."Source ID") THEN
[Link]("Source Subtype", ColorConfig."Source
Subtype"::"Posted Return Order");
END;
END;

[Link]("Work Status", '%1|''''', ServiceHeader."Work Status

Code");
//DELTA BCH 27/01/2021
[Link](PDI, [Link]);
//DELTA BCH 27/01/2021

[Link](Status, [Link]);

IF [Link] THEN BEGIN

ForeColor := ColorConfig."Font Color";
BackColor := ColorConfig."Background Color";
END;

CurrDateTime := [Link](WORKDATE, TIME);

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

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

([Link] = [Link]::"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
ColorConfig@1101908003 : Record 25006281;
ServiceHeader@1101908007 : Record 25006145;
ServLaborAllocationApplication@25006000 : Record 25006277;
PostedServiceHeader@25006001 : Record 25006149;
PostedServRetOrderHeader@25006002 : Record 25006154;
CurrDateTime@25006003 : Decimal;
BEGIN
[Link];
ForeColor := 0; //Black
BackColor := 16777215; //White
[Link];

[Link]("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
[Link]("Source Subtype", ColorConfig."Source
Subtype"::Order);
//Add subtype
CASE [Link] OF
[Link]::Reserved:
[Link]("Rent Order Subtype",ColorConfig."Rent Order
Subtype"::Planned);
[Link]::Rented:
[Link]("Rent Order Subtype",ColorConfig."Rent Order
Subtype"::Shipped);
[Link]::Recieved:
[Link]("Rent Order Subtype",ColorConfig."Rent Order
Subtype"::Received);
END;
END;
RentAvailabilityBufferTmp."Rent Document Type"::Quote:
[Link]("Source Subtype", ColorConfig."Source
Subtype"::Quote);
RentAvailabilityBufferTmp."Rent Document Type"::"Return Order":
[Link]("Source Subtype", ColorConfig."Source
Subtype"::"Return Order");
END;
END;
IF RentAvailabilityBufferTmp."Service Order No." <> '' THEN BEGIN
[Link]("Source Subtype", ColorConfig."Source
Subtype"::Service);
END;

IF [Link] THEN BEGIN

ForeColor := ColorConfig."Font Color";
BackColor := ColorConfig."Background Color";
END;
END;
 PROCEDURE SetResourceColor@1101908033(ResourceNo@1101908001 : Code[20];VAR
ForeColor@1101908002 : Integer);
VAR
WorkTimeEntry@1101908003 : Record 25006276;
BEGIN
[Link];

[Link];
[Link]("Resource No.",Closed);
[Link]("Resource No.", ResourceNo);
[Link](Closed,FALSE);
IF [Link] 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;
ServiceHour@1101901001 : Record 25006129;
BEGIN
Day := DATE2DWY(DateFilter,1) - 1;
[Link];
[Link](Day,Day);
IF NOT [Link] 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
TempLaborAllocEntry@1190003 : TEMPORARY Record 25006271;
RecordCount@1190004 : Integer;
BEGIN
IF NOT CheckUserRightsAdv(1, TempLaborAllocEntry) THEN EXIT;
ScheduleAction := ScheduleAction::Planning;

FillAllocEntryBuffer(TempLaborAllocEntry,ResourceNo,StartingDateTime,EndingDateTime
);
RecordCount := [Link];
 IF RecordCount = 0 THEN
EXIT;

IF RecordCount = 1 THEN BEGIN

[Link];
SelectAllocationEntry(TempLaborAllocEntry."Entry No.")
END ELSE //RecordCount > 1
IF [Link](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
ScheduleAction := ScheduleAction::Planning;

//EntryNo := [Link];

IF NOT [Link](EntryNo) THEN BEGIN

MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(2, LaborAllocEntryLoc) THEN EXIT;

IF [Link] IN [[Link]::"In Progress",

[Link]::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
[Link];
[Link]("Resource No.", "End Date-Time");

IF [Link] THEN BEGIN

REPEAT
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,
LaborAllocEntryTemp."Entry No.", 10000)
UNTIL [Link] =0;
[Link];
REPEAT
ProceedMode := 1110;
IF [Link] = 1 THEN
 ProceedMode := 1111;
IF DeleteAll THEN BEGIN
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,
LaborAllocEntryTemp."Entry No.", ProceedMode)
END ELSE
IF LaborAllocEntryTemp."Entry No." <> EntryNo THEN
DeleteAllocationEntry(LaborAllocEntry,LaborAllocApp,
LaborAllocEntryTemp."Entry No.", ProceedMode);
UNTIL [Link](-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 [Link](EntryNo) THEN BEGIN
MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(300, LaborAllocEntry) THEN EXIT;

[Link](EntryNo,NewResourceNo,NewStartingDateTime,LaborAllocEntry."
Quantity (Hours)",
LaborAllocEntry."Source Type",LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID",1, ServiceLine,0);

[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];
END;

PROCEDURE StartEndAllocation@1101908002(AllocationStatus1@1101908002 :
'Pending,In Progress,Finish All,Finish Part,On Hold');
VAR
WorkTimeEntry@1101908004 : Record 25006276;
LaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
LaborAllocEntryLoc@1101908006 : Record 25006271;
CurrDateTime@1101908000 : Decimal;
HoldHours@1101908003 : Decimal;
StartFinishAllocation@1000 : Page 25006355;
BEGIN
CLEAR(StartFinishAllocation);
IF NOT [Link]([Link]) THEN BEGIN
MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(1, LaborAllocEntry) THEN EXIT;

CurrDateTime := [Link](WORKDATE, TIME);

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

 IF [Link] = [Link]::Finished THEN
ERROR(Text109);
IF [Link] = [Link]::"In Progress" THEN
ERROR(Text110);
END;

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

AllocationStatus1::"Finish Part", AllocationStatus1::"On Hold"] THEN
BEGIN
IF [Link] <> [Link]::"In Progress" THEN
ERROR(Text111);
END;

[Link](LaborAllocEntry."Resource
No.",CurrDateTime,LaborAllocEntry."Quantity (Hours)",
LaborAllocEntry."Source
Type",LaborAllocEntry."Source Subtype",LaborAllocEntry."Source ID",
AllocationStatus1, HoldHours);
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8

//BABEIGT, notesteet ==>

IF [Link] = ACTION::LookupOK THEN BEGIN

[Link]('START',LaborAllocEntry,LaborAllocEntry."Resou
rce No.",WORKDATE,TIME);
END;
END;

PROCEDURE StartEndWorktime@1101908046(ResourceNo@1101908000 :
Code[20];Status@1101908001 : 'Start,End');
VAR
CurrDateTime@1101908003 : Decimal;
WorktimeRegistration@1000 : Page 25006353;
PageAction@1000000000 : Action;
BEGIN
IF NOT CheckUserRightsAdv(1, LaborAllocEntry) THEN EXIT;

CurrDateTime := [Link](WORKDATE, TIME);

CLEAR(WorktimeRegistration);
[Link](ResourceNo, CurrDateTime, Status);
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];
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
[Link];
 [Link];
RetValue := EndDT;
IF ServiceScheduleSetup."Show Unavailable Time" THEN BEGIN
[Link];
[Link]("Period Type",DateRec."Period Type"::Date);
[Link]("Period
Start",DateTimeMgt.Datetime2Date(StartDT),DateTimeMgt.Datetime2Date(EndDT));
IF [Link] THEN REPEAT
FillUnavailableTimeEntries(UnavailAllocEntry,NewResNo,
DateRec."Period Start");
UNTIL [Link]=0;
CurrDT := StartDT;
UnavailAllocEntryCount := [Link];
IF UnavailAllocEntryCount > 1 THEN BEGIN
CurrRecIndex := 1;
[Link];
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 -= [Link](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 -= [Link](0D, 000000.001T); //minus one
millisecond
END;
END ELSE BEGIN
NewCurrDT := CurrDT;
RetValue -= 0;
END;
END;
CurrDT := NewCurrDT;
CurrRecIndex += 1;
[Link];
END;
END;
END;

EXIT(RetValue);
END;

PROCEDURE BreakAllocation@1101908043();
 VAR
CurrDateTime@1101908001 : Decimal;
AllocationForm@1101904000 : Page 25006369;
BEGIN
CurrDateTime := [Link](WORKDATE, TIME);

IF NOT [Link]([Link]) THEN BEGIN

MESSAGE(Text121);
EXIT;
END;

IF NOT CheckUserRightsAdv(4, LaborAllocEntry) THEN EXIT;

[Link](LaborAllocEntry."Entry No.",
LaborAllocEntry."Resource No.", CurrDateTime,
LaborAllocEntry."Quantity (Hours)",
LaborAllocEntry."Source Type",LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID",3, ServiceLine,0);
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];

//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
LaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
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
ScheduleAction := ScheduleAction::Planning;
SplitTracking := SplitTracking1;
[Link](EntryNo);
IF Operation < 0 THEN
Operation := 300;
IF NOT CheckUserRightsAdv(Operation, LaborAllocEntry) THEN EXIT;

OldResourceNo := LaborAllocEntry."Resource No.";

IF NOT ([Link](NewResourceNo)) THEN BEGIN
NewResourceNo := OldResourceNo;
IF NOT ([Link](NewResourceNo)) THEN
ERROR(Text160);
 END;
OldStartingDateTime := LaborAllocEntry."Start Date-Time";
OldEndingDateTime := LaborAllocEntry."End Date-Time";
OldHours := LaborAllocEntry."Quantity (Hours)";
DoReplan := TRUE;

[Link];

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, '');

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(OldResourceNo, OldStartingDateTime);
END;
END;
//Adjust Related entries
SynchroniseRelatedEntries(EntryNo);
END;

PROCEDURE ProcessMovementApp@1101904025(VAR
ServLaborAllocApplicationPar@1101904001 : Record 25006277;EntryNo@1101904000 :
Integer;NewResourceNo@1190005 : Code[20];NewStartingDateTime@1190004 :
Decimal;NewQtyToAllocate@1190003 : Decimal;SplitTracking1@1101908000 : 'No,Yes')
MainAllocEntrNo : Integer;
VAR
LaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
OldResourceNo@1101908002 : Code[20];
OldStartingDateTime@1101908001 : Decimal;
OldEndingDateTime@1101908003 : Decimal;
OldHours@1101908004 : Decimal;
DoReplan@1190001 : Boolean;
ResourceTmp@1101904002 : TEMPORARY Record 156;
Resource@1101904003 : Record 156;
ServLaborAllocEntryTmp@1101904007 : TEMPORARY Record 25006271;
PreviousAllocEntryNo@1101904006 : Integer;
BEGIN
// at first create new entries
[Link](EntryNo);
 [Link];
[Link];
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.
[Link];
[Link]("Allocation Entry No.","Allocation Entry No.");
[Link]("Document Type","Document Type");
[Link]("Document No.","Document No.");
[Link]("Document Line No.","Document Line No.");
[Link]("Resource No.","Resource No.");
//IF NOT [Link]("Allocation Entry No.", "Document Type",
"Document No.", "Document Line No.","Line No.") THEN BEGIN
IF NOT [Link] THEN BEGIN
IF NOT [Link]("Resource No.") THEN BEGIN
IF [Link]("Resource No.") THEN BEGIN
ResourceTmp := Resource;
[Link];
END;
END;
END;
UNTIL NEXT = 0;
//'NewStartingDateTime:'+FORMAT(NewStartingDateTime)+',
NewQtyToAllocate:'+FORMAT(NewQtyToAllocate)); //
IF [Link] THEN BEGIN
MainAllocEntrNo := GetMainAllocEntrNo(LaborAllocEntry."Entry No.", 1011);
FindSplitEntries(MainAllocEntrNo, ServLaborAllocEntryTmp, 0, 1111);
PreviousAllocEntryNo := 0;
REPEAT
[Link];
REPEAT
PreviousAllocEntryNo :=
AddResourceToAllocEntry(ServLaborAllocEntryTmp, LaborAllocApp,
ResourceTmp."No.", PreviousAllocEntryNo, LaborAllocEntry,
LaborAllocApp);
UNTIL [Link] = 0;
UNTIL [Link] = 0;
END;

END;
ProcessMovement(EntryNo, NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, SplitTracking1, [Link],
-1,[Link]);
EXIT(MainAllocEntrNo);
END;

PROCEDURE MovementIncSplit@1101908011(EntryNo@1101908000 :
Integer;NewResourceNo@1101908001 : Code[20];NewStartingDateTime@1101908002 :
Decimal;NewQtyToAllocate@1101908003 : Decimal;NewStatus@1101904005 : Integer);
VAR
ServLaborAllocEntryTmp@1101908004 : TEMPORARY Record 25006271;
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;
 DoReplan@1190000 : Boolean;
RecalcQtyToAllocate@1101904000 : Decimal;
QtyToMove@1101904002 : Decimal;
OldStartingDateTime@1101904003 : Decimal;
MainAllocEntrNo@1101904004 : Integer;
Travel@25006000 : Boolean;
BEGIN
[Link];

[Link](EntryNo);
Travel := [Link];
NewSourceType := LaborAllocEntry."Source Type";
NewSourceSubType := LaborAllocEntry."Source Subtype";
NewSourceID := LaborAllocEntry."Source ID";
//NewStatus := [Link];
DoReplan := FALSE;

[Link];
IF LaborAllocEntry."Source Type" = LaborAllocEntry."Source Type"::"Service
Document" THEN BEGIN
[Link];
[Link]("Allocation Entry No.", LaborAllocEntry."Entry
No.");
IF [Link] THEN
REPEAT
FillServiceLine2(ServiceLineLoc, LaborAllocApp."Document Type",
LaborAllocApp."Document No.",
LaborAllocApp."Document Line No.");
UNTIL [Link] = 0;
END;

RecalcQtyToAllocate := 0;
FindSplitEntries(EntryNo, ServLaborAllocEntryTmp, 0, 0); //15.08.2013 EDMS
P8
IF [Link] THEN BEGIN
REPEAT
IF ServLaborAllocEntryTmp."Entry No." = EntryNo THEN
RecalcQtyToAllocate += NewQtyToAllocate
ELSE
RecalcQtyToAllocate += ServLaborAllocEntryTmp."Quantity (Hours)";
UNTIL [Link] = 0;
END;

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

QtyToMove := NewStartingDateTime - OldStartingDateTime;
//lets first split part will be as start point
MainAllocEntrNo := GetMainAllocEntrNo(LaborAllocEntry."Entry No.", 1011);
EntryNo := MainAllocEntrNo;
[Link](EntryNo);
NewStartingDateTime := LaborAllocEntry."Start Date-Time" + QtyToMove;
//MESSAGE('msg in movement 0');

DeallocateIncSplit(EntryNo, FALSE);

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

ClearAllocationEntry(EntryNo, FALSE);

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

[Link];
 IF [Link] THEN
REPEAT
FillServiceLine2(ServiceLine, ServiceLineLoc."Document Type",
ServiceLineLoc."Document No.", ServiceLineLoc."Line No.");
UNTIL [Link] = 0;

WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
RecalcQtyToAllocate,
NewSourceType, NewSourceSubType, NewSourceID, 1,
EntryNo, DoReplan, NewStatus, FALSE,Travel);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);
END;

PROCEDURE AllocateStandardEvent@1190008(ResourceNo@1190002 :
Code[20];StartingDateTime@1190001 : Decimal;EndingDateTime@1190000 : Decimal);
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 := [Link](ResourceNo,
StartingDateTime, EndingDateTime);
CurrQtyToAllocate := [Link](CurrQtyToAllocate, 0);
IF NOT CheckUserRightsAdv(2, LaborAllocEntry) THEN EXIT;

CLEAR(StandardEvents);

[Link](TRUE);

IF [Link] = ACTION::LookupOK THEN

BEGIN
[Link](StandardEvent);

//Allocate(ResourceNo,StartingDateTime,0,2,0,[Link],ServLine,0);

Allocate(ResourceNo,StartingDateTime,CurrQtyToAllocate,2,0,[Link],ServL
ine,0);
END
ELSE
EXIT;
END;
 PROCEDURE AllocateServiceLines@1190009(ResourceNo@1190004 :
Code[20];StartingDateTime@1190003 : Decimal;EndingDateTime@1190002 : Decimal);
VAR
ServiceLinesAllocation@1190000 : Page 25006354;
ServiceLine@1190001 : Record 25006146;
ServiceLine2@1190006 : Record 25006146;
ServiceHdr@1101908000 : Record 25006145;
WhatAllocation@1101908001 : 'Header,Line';
NewLineNo@1190005 : Integer;
CurrQtyToAllocate@1001 : Decimal;
ServiceScheduleMgt@1000 : Codeunit 25006201;
BEGIN
CurrQtyToAllocate := [Link](ResourceNo,
StartingDateTime, EndingDateTime);

IF NOT CheckUserRightsAdv(100, LaborAllocEntry) THEN EXIT;

CLEAR(ServiceLinesAllocation);

[Link](TRUE);

IF [Link] = ACTION::LookupOK THEN

BEGIN
ServiceLinesAllocation.SetSelectionFilter1(ServiceLine);
CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Line);

[Link];
IF [Link] THEN
REPEAT
NewLineNo := ServiceLine."Line No.";
IF NOT CheckServiceLineResource(ServiceLine."Document Type",
ServiceLine."Document No.",
[Link], 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;
[Link](ServiceLine."Document Type", ServiceLine."Document
No.", NewLineNo);
[Link](TRUE);
UNTIL [Link] = 0;
COMMIT;
[Link](TRUE);

IF [Link] 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 :
Code[20];StartingDateTime@1101908001 : Decimal;EndingDateTime@1101908000 :
Decimal);
VAR
ServiceHdrsAllocation@1101908004 : Page 25006356;
ServiceHdr@1101908003 : Record 25006145;
ServiceLineLoc@1101908005 : TEMPORARY Record 25006146;
WhatAllocation@1101908006 : 'Header,Line';
CurrQtyToAllocate@1001 : Decimal;
ServiceScheduleMgt@1000 : Codeunit 25006201;
BEGIN
CurrQtyToAllocate := [Link](ResourceNo,
StartingDateTime, EndingDateTime);
IF NOT CheckUserRightsAdv(110, LaborAllocEntry) THEN EXIT;

CLEAR(ServiceHdrsAllocation);
[Link](TRUE);

IF [Link] = ACTION::LookupOK THEN

BEGIN
[Link](ServiceHdr);
CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Header);
[Link]("Document Type", ServiceHdr."Document Type");
[Link]("Document No.", ServiceHdr."No.");
[Link]("Line No.", 0);
//Allocate(ResourceNo,StartingDateTime,0,1,ServiceHdr."Document
Type",ServiceHdr."No.",ServiceLine,0);

Allocate(ResourceNo,StartingDateTime,CurrQtyToAllocate,1,ServiceHdr."Document
Type",ServiceHdr."No.",ServiceLine,0);
END
ELSE
EXIT;
END;

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

VAR
StandardEvents@1190003 : Page 25006357;
AllocationForm@1190006 : Page 25006379;
StandardEvent@1190004 : Record 25006272;
ServLine@1190005 : Record 25006146;
StartingDateTime@1190000 : Decimal;
BEGIN
IF NOT CheckUserRightsAdv(1, LaborAllocEntry) THEN EXIT;

StartingDateTime := [Link](WORKDATE, TIME);

CLEAR(StandardEvents);

[Link](TRUE);

IF [Link] = ACTION::LookupOK THEN

BEGIN
[Link](StandardEvent);
CLEAR(AllocationForm);

[Link](ResourceNo,StartingDateTime,2,0,[Link]);
[Link](TRUE);
COMMIT; //28.06.2013 EDMS P8
[Link];
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
AllocationForm@1190006 : Page 25006369;
LaborAllocAppTemp@1101904000 : TEMPORARY Record 25006277;
BEGIN
CLEAR(AllocationForm);

[Link](0,ResourceNo,StartingDateTime,QtyToAllocate,SourceType,Sour
ceSubType,SourceID,0, ServiceLine1,ForceStatus);
[Link] := LaborAllocAppTemp;
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];
END;

PROCEDURE AllocateNewVisitQuote@1101904042(ResourceNo@1101908002 :
Code[20];StartingDateTime@1101908001 : Decimal;EndingDateTime@1101908000 :
Decimal);
VAR
ServiceHdr@1101908003 : Record 25006145;
ServiceLineLoc@1101908005 : TEMPORARY Record 25006146;
WhatAllocation@1101908006 : 'Header,Line';
DocumentNo@1101904001 : Code[20];
DocumentType@1101904000 : 'Quote,Order,Return Order';
BEGIN
IF NOT CheckUserRightsAdv(110, LaborAllocEntry) THEN EXIT;

WITH ServiceHdr DO BEGIN

DocumentNo := CreateNewServiceDocument("Document Type"::Quote);
SETRANGE("Document Type", "Document Type"::Quote);
SETRANGE("No.", DocumentNo);
IF FINDFIRST THEN BEGIN
CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Header);
Allocate(ResourceNo,StartingDateTime,0,1,ServiceHdr."Document
Type",ServiceHdr."No.",ServiceLine,0);
END ELSE
EXIT;
END;
END;

PROCEDURE AllocateNewVisitOrder@1101904037(ResourceNo@1101908002 :
Code[20];StartingDateTime@1101908001 : Decimal;EndingDateTime@1101908000 :
Decimal);
VAR
ServiceHdr@1101908003 : Record 25006145;
ServiceLineLoc@1101908005 : Record 25006146;
WhatAllocation@1101908006 : 'Header,Line';
DocumentNo@1101904001 : Code[20];
DocumentType@1101904000 : 'Quote,Order,Return Order';
BEGIN
 IF NOT CheckUserRightsAdv(110, LaborAllocEntry) THEN EXIT;

WITH ServiceHdr DO BEGIN

DocumentNo := CreateNewServiceDocument("Document Type"::Order);
SETRANGE("Document Type", "Document Type"::Order);
SETRANGE("No.", DocumentNo);
IF FINDFIRST THEN BEGIN
//22.03.2014 Elva Baltic P1 #X01 MMG7.00 >>
//CheckForCorrectServHeaderLine(ServiceHdr, ServiceLine,
WhatAllocation::Header);
[Link];
[Link]("Document Type",ServiceLineLoc."Document
Type"::Order);
[Link]("Document No.",DocumentNo);
[Link](Type,[Link]::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 :
Code[20];StartingDateTime@1190004 : Decimal;QtyToAllocate@1190003 :
Decimal;SourceType@1190002 : ' ,Service Document,Standard
Event';SourceSubType@1190001 : 'Qoute,Order';SourceID@1190000 : Code[20];VAR
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;
DoReplan@1190006 : Boolean;
BEGIN
//21.11.2013 EDMS P8
CASE SourceType OF
SourceType::"Service Document":
BEGIN
IF ServiceLine1."Line No." > 0 THEN BEGIN
IF NOT CheckUserRightsAdv(100, LaborAllocEntry) THEN EXIT;
END ELSE
IF NOT CheckUserRightsAdv(110, LaborAllocEntry) THEN EXIT;
END;
SourceType::"Standard Event":
IF NOT CheckUserRightsAdv(120, LaborAllocEntry) THEN EXIT;
ELSE
IF NOT CheckUserRightsAdv(100, LaborAllocEntry) THEN EXIT;
END;
 [Link];
ScheduleAction := ScheduleAction::Planning;
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 := [Link];
IF [Link] THEN
REPEAT
ServiceHours += [Link];
UNTIL [Link] = 0;

EntryNo := 0;
IF [Link] THEN
REPEAT
[Link];
[Link];
IF [Link] <> 0 THEN BEGIN
ServiceLine2 := ServiceLine1;
[Link];
FillServiceLine(ServiceLine2);
QtyToAllocate2 := ROUND(([Link] / 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;
UNTIL [Link] = 0;
END;

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(ResourceNo, JoinStartingDateTime);
END;

PROCEDURE ProcessAllocationResources@1101904019(VAR ResourceTmp@1190005 :

TEMPORARY Record 156;StartingDateTime@1190004 : Decimal;QtyToAllocate@1190003 :
Decimal;SourceType@1190002 : ' ,Service Document,Standard
Event';SourceSubType@1190001 : 'Qoute,Order';SourceID@1190000 : Code[20];VAR
ServiceLine1@1101908011 : Record 25006146;DivideIntoLines@1101908001 :
Boolean;ForceStatus1@25006001 : 'Pending,In Progress,Finished,On
Hold,Cancelled';TravelPar@25006000 : Boolean) MainAllocEntrNo : Integer;
VAR
ServLaborAllocEntryTmp@1101904002 : TEMPORARY Record 25006271;
PreviousAllocEntryNo@1101904000 : Integer;
TextNoRecords@1101904001 : TextConst 'ENU=No Resource to process, so no entry
is generated.';
BEGIN
IF [Link] THEN BEGIN
ProcessAllocation(ResourceTmp."No.", StartingDateTime, QtyToAllocate,
SourceType, SourceSubType,
 SourceID, ServiceLine1, DivideIntoLines, ForceStatus1,TravelPar);
MainAllocEntrNo := GetMainAllocEntrNo(LaborAllocEntry."Entry No.", 1011);
FindSplitEntries(MainAllocEntrNo, ServLaborAllocEntryTmp, 0, 1111);
PreviousAllocEntryNo := 0;
IF [Link] <> 0 THEN
REPEAT
[Link];
REPEAT
PreviousAllocEntryNo := AddResourceToAllocEntry(ServLaborAllocEntryTmp,
LaborAllocApp,
ResourceTmp."No.", PreviousAllocEntryNo, LaborAllocEntry,
LaborAllocApp);
UNTIL [Link] = 0;
UNTIL [Link] = 0;
END ELSE
ERROR(TextNoRecords);
EXIT(MainAllocEntrNo);
END;

PROCEDURE AllocationSpliting@1101908020(NewResourceNo@1101908001 :
Code[20];NewStartingDateTime@1101908000 : Decimal);
VAR
AllocationForm@1101908003 : Page 25006369;
ServiceLine@1101908002 : Record 25006146;
BEGIN
CLEAR(AllocationForm);
IF NOT [Link]([Link]) THEN BEGIN
MESSAGE(Text121);
EXIT;
END;
IF NOT CheckUserRightsAdv(200, LaborAllocEntry) THEN EXIT;

[Link]([Link]);

[Link](0,NewResourceNo,NewStartingDateTime,LaborAllocEntry."Quanti
ty (Hours)",
LaborAllocEntry."Source Type",LaborAllocEntry."Source
Subtype",LaborAllocEntry."Source ID",2, ServiceLine,0);
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];
END;

PROCEDURE ProcessSpliting@1101908021(NewResourceNo@1101908003 :
Code[20];NewStartingDateTime@1101908002 : Decimal;NewQtyToAllocate@1101908001 :
Decimal;SplitTracking1@1101908000 : 'No,Yes');
VAR
LaborAllocEntryTemp@1101908006 : TEMPORARY Record 25006271;
TotalHours@1101908007 : Decimal;
StartDateTime@1101908008 : Decimal;
EntryNo@1101908005 : Integer;
DoReplan@1101908004 : Boolean;
DifferentStatus@1101908009 : Boolean;
BEGIN
IF NewQtyToAllocate <= 0 THEN
EXIT;

IF NOT CheckUserRightsAdv(200, LaborAllocEntry) THEN EXIT;

 [Link];
ScheduleAction := ScheduleAction::Planning;
DoReplan := TRUE;

SplitTracking := SplitTracking1;
EntryNo := [Link];
[Link](EntryNo);

AllocationStatus := [Link];
ChangeAllocationStatus := TRUE;

TotalHours := CalculateTotalHours(EntryNo);
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
[Link]("Resource No.", "Start Date-Time");
IF [Link] THEN
StartDateTime := LaborAllocEntryTemp."Start Date-Time";

IF SplitAllocTracking(EntryNo, 0) THEN BEGIN

IF NewQtyToAllocate >= TotalHours THEN
MovementIncSplit(EntryNo, NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, [Link]) //do only moving
ELSE BEGIN
MovementIncSplit(EntryNo, LaborAllocEntry."Resource No.", StartDateTime,
TotalHours - NewQtyToAllocate,
[Link]); //correct old entry
DoServiceSpliting := (NewResourceNo <> LaborAllocEntry."Resource No.");
[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] THEN
REPEAT
FillServiceLine2(ServiceLine, LaborAllocApp."Document Type",
LaborAllocApp."Document No.",
LaborAllocApp."Document Line No.");
UNTIL [Link] = 0;

WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
NewQtyToAllocate, //insert new entry
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 0, 0, DoReplan,
[Link], FALSE,FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);
END;
END ELSE BEGIN
IF NewQtyToAllocate >= LaborAllocEntry."Quantity (Hours)" THEN BEGIN
DoServiceSpliting := (NewResourceNo <> LaborAllocEntry."Resource No.");
DifferentStatus := CheckLaborStatus(LaborAllocEntryTemp);
IF DifferentStatus AND DoServiceSpliting THEN BEGIN
[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] THEN
REPEAT
FillServiceLine2(ServiceLine, LaborAllocApp."Document Type",
LaborAllocApp."Document No.",
LaborAllocApp."Document Line No.");
 UNTIL [Link] = 0;

WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
NewQtyToAllocate,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 0, 0, DoReplan,
[Link], FALSE,FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);

DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp, EntryNo, 11111);

IF [Link] THEN
REPEAT
StatusChanged := FALSE;
IF LaborAllocEntryTemp."Entry No." <> EntryNo THEN BEGIN
ChangeServiceLineStatus(LaborAllocEntryTemp."Entry No.", FALSE);
StatusChanged := TRUE;
END;
UNTIL ([Link] = 0) OR StatusChanged;

END ELSE BEGIN

WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
NewQtyToAllocate,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 1, EntryNo,
DoReplan, [Link], FALSE,FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);
END;
END ELSE BEGIN
WriteAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time",
LaborAllocEntry."Quantity (Hours)" -
NewQtyToAllocate,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 1, EntryNo, DoReplan,
[Link], FALSE,FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time");

DoServiceSpliting := (NewResourceNo <> LaborAllocEntry."Resource No.");

[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] THEN
REPEAT
FillServiceLine2(ServiceLine, LaborAllocApp."Document Type",
LaborAllocApp."Document No.",
 LaborAllocApp."Document Line No.");
UNTIL [Link] = 0;

WriteAllocationEntries(NewResourceNo, NewStartingDateTime,
NewQtyToAllocate,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 0, 0, DoReplan,
[Link], FALSE,FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" <>

ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(NewResourceNo, NewStartingDateTime);
END;
END;
END;

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

BEGIN
[Link](EntryNo);
END;

PROCEDURE DeleteAllocationEntry@1190011(VAR LaborAllocEntry@1190002 : Record

25006271;VAR LaborAllocApp@1190001 : Record 25006277;EntryNo@1190000 :
Integer;RunModeFlags@1101904000 : Integer);
VAR
LaborAllocEntryLoc@1101908008 : Record 25006271;
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
[Link];

IF NOT [Link](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

IF NOT CheckUserRightsAdv(400, LaborAllocEntry) THEN EXIT;
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.");
[Link](TRUE);
END;

IF isGoingToReplan THEN
ReplanEntries(ResourceNo, EndingDateTime, -HourQty,
ServiceScheduleSetup."Replan Document", SourceSubType, SourceID);

IF isGoingToJoin THEN
IF ServiceScheduleSetup."Handle Linked Entries" <>
ServiceScheduleSetup."Handle Linked Entries"::No THEN
JoinAllocationEntries(ResourceNo, StartingDateTime);
END;

PROCEDURE InsertAllocationEntry@1190012(VAR LaborAllocEntryPar@1190008 : Record

25006271;VAR LaborAllocAppPar@1190007 : Record 25006277;ResourceNo@1190005 :
Code[20];StartingDateTime@1190004 : Decimal;QtyToAllocate@1190003 :
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
ServiceLine1@1101908001 : Record 25006146;
LaborAllocApp1@1101908002 : Record 25006277;
ServiceHeader@1190009 : Record 25006145;
RetStartDateTime@1101908003 : Decimal;
EntryNo@1190006 : Integer;
LineNo@1101908004 : Integer;
SingleInstanceManagment@25006000 : Codeunit 25006001;
BEGIN
[Link];

//[Link];
//IF [Link] THEN
//EntryNo := LaborAllocEntry."Entry No.";
[Link];
IF [Link] THEN
EntryNo := LaborAllocEntry."Entry No.";
IF [Link] 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" := [Link];
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
[Link](ServiceHeader."Document Type"::Order, SourceID);
"Planning Policy" := ServiceHeader."Planning Policy";
END;
IF "Source Subtype" = "Source Subtype"::Quote THEN BEGIN
[Link](ServiceHeader."Document Type"::Quote, SourceID);
"Planning Policy" := ServiceHeader."Planning Policy";
END;
END;
END;
INSERT;
//LaborAllocEntryPar := LaborAllocEntry;
//IF NOT [Link] 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 [Link] AND (ApplyToEntry = 0) THEN BEGIN //17.04.2008.
EDMS P2
REPEAT
LineNo := ServiceLine."Line No.";
IF DoServiceSpliting THEN
LineNo := SplitServiceLine(ServiceLine."Document Type",
ServiceLine."Document No.", ServiceLine."Line No.");

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);
UNTIL [Link] = 0;
DoServiceSpliting := FALSE;
[Link];
[Link];
END ELSE BEGIN
[Link];
[Link]("Allocation Entry No.",
LaborAllocEntryPar."Applies-to Entry No.");
IF [Link] 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);

InsertAllocApplication(LaborAllocAppPar, EntryNo,
LaborAllocApp1."Document Type", LaborAllocApp1."Document No.",
LineNo, ResourceNo,
DoChangeServLineResource,TravelPar);
UNTIL [Link] = 0;
END;
END ELSE BEGIN //09.04.2013 EDMS P8
//09.07.2013 EDMS P8 >>
IF [Link] AND (ApplyToEntry = 0) THEN BEGIN
REPEAT
LineNo := ServiceLine."Line No.";
IF DoServiceSpliting THEN
LineNo := SplitServiceLine(ServiceLine."Document Type",
ServiceLine."Document No.", ServiceLine."Line No.");

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);
UNTIL [Link] = 0;
DoServiceSpliting := FALSE;
[Link];
[Link];
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,
DoChangeServLineResource,TravelPar);
END ELSE BEGIN
[Link];
[Link]("Allocation Entry No.",
LaborAllocEntryPar."Applies-to Entry No.");
IF [Link] 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);
 InsertAllocApplication(LaborAllocAppPar, EntryNo,
LaborAllocApp1."Document Type", LaborAllocApp1."Document No.",
LineNo, ResourceNo,
DoChangeServLineResource,TravelPar);
UNTIL [Link] = 0;
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 :
Integer;NewResourceNo@1190005 : Code[20];NewStartingDateTime@1190004 :
Decimal;NewQtyToAllocate@1190003 : Decimal;DoChangeServLineResource@1101908000 :
Boolean;Status@1101904000 : Integer;AppliesToEntryNo@1101904001 :
Integer;Travel@25006000 : Boolean);
VAR
LaborAllocAppLoc@1101908001 : Record 25006277;
OldResourceNo@1101908002 : Code[20];
BEGIN
[Link];
[Link](EntryNo);
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;
[Link] := Travel;
IF AppliesToEntryNo > 0 THEN //10.12.2013 EDMS P8
[Link]("Applies-to Entry No.",
AppliesToEntryNo); //14.03.2014 Elva Baltic P8 #S0003 MMG7.00
IF Status >= 0 THEN
[Link] := Status;
[Link];

IF (ServiceScheduleSetup."Control Labor Sequence") OR

(ServiceScheduleSetup."Control Skills" <> ServiceScheduleSetup."Control
Skills"::No)
THEN BEGIN
[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] 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 [Link] = 0;
END;

IF LaborAllocEntry."Source Type" = LaborAllocEntry."Source Type"::"Service

Document" THEN
ModifyAllocApplication(LaborAllocApp, EntryNo, NewResourceNo,
DoChangeServLineResource,Travel);
END;

PROCEDURE DeleteAllocApplication@1101908014(VAR LaborAllocApp@1101908001 :

Record 25006277;AllocationEntryNo@1101908000 : Integer);
VAR
LaborAllocAppLoc@1101908006 : Record 25006277;
DocumentType@1101908003 : 'Quote,Order,Invoice,Credit Memo,Blanket
Order,Return Order';
DocumentNo@1101908004 : Code[20];
LineNo@1101908005 : Integer;
ResourceNo@1101904000 : Code[20];
BEGIN
[Link];
[Link]("Allocation Entry No.", AllocationEntryNo);
IF [Link] THEN
REPEAT
DocumentType := LaborAllocApp."Document Type";
DocumentNo := LaborAllocApp."Document No.";
ResourceNo := LaborAllocApp."Resource No.";
LineNo := LaborAllocApp."Document Line No.";
[Link](TRUE);

[Link];
[Link]("Document Type", DocumentType);
[Link]("Document No.", DocumentNo);
[Link]("Document Line No.", LineNo);
// IF NOT [Link] THEN BEGIN // P8
// IF LineNo = 0 THEN
// IF CONFIRM(Text145) THEN
// DocAllocAdjustDocLinesResource(DocumentType, DocumentNo, '');
//END;

UNTIL [Link] = 0;
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;
EntryNo@1101908005 : Integer;
IsTimeLine@1101908008 : Boolean;
ResourceCost@25006000 : Record 156;
BEGIN
IsTimeLine := FALSE;
[Link];
[Link]("Allocation Entry No.", AllocationEntry);
[Link]("Time Line", TRUE);
IF NOT [Link] THEN
IsTimeLine := TRUE;

IF NOT [Link](AllocationEntry) THEN EXIT; //28.06.2013

EDMS P8
 [Link];
IF [Link] THEN
EntryNo := LaborAllocApp."Allocation Entry No.";

EntryNo += 1;
[Link];
LaborAllocApp."Allocation Entry No." := AllocationEntry;
LaborAllocApp."Document Type" := DocumentType;
LaborAllocApp."Document No." := DocumentNo;
LaborAllocApp."Document Line No." := LineNo;
LaborAllocApp."Resource No." := ResourceNo;
[Link] := Travel;
IF IsTimeLine THEN BEGIN
LaborAllocApp."Time Line" := IsTimeLine;
LaborAllocApp."Remaining Quantity (Hours)" :=
LaborAllocEntryLocal."Quantity (Hours)";
END;
IF [Link](ResourceNo)
THEN //12.05.2015 EB.P30 #T030
[Link]("Unit Cost", ResourceCost."Unit
Cost"); //12.05.2015 EB.P30 #T030
[Link](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
[Link](EntryNo);
[Link]("Total Time Spent","Total Time Spent
Travel");
[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] THEN
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;
[Link] := Travel;
IF Travel THEN
TotalTimeSpent := LaborAllocEntryLocal."Total Time Spent Travel"
ELSE
TotalTimeSpent := LaborAllocEntryLocal."Total Time Spent";

[Link]("Finished Quantity (Hours)", TotalTimeSpent);

 [Link]("Remaining Quantity (Hours)",
LaborAllocEntryLocal."Quantity (Hours)"-TotalTimeSpent);

//12.05.2015 EB.P30 #T030 >>

IF IsResourceChanged THEN BEGIN
IF [Link](ResourceNo) THEN
[Link]("Unit Cost", ResourceCost."Unit Cost");
END;
//12.05.2015 EB.P30 #T030
[Link];
IF DoChangeServLineResource THEN BEGIN
DocAllocAdjustDocLinesResource(LaborAllocApp."Document Type",
LaborAllocApp."Document No.", ResourceNo); // P8
END;
UNTIL [Link] = 0;
END;

PROCEDURE IsTimeAvailable@1101908005(VAR ServLaborAlloc@1101908003 : Record

25006271;ResourceNo@1101908002 : Code[20];CurrentDay@1101908001 :
Date;ModifyEntryNo@1101908013 : Integer) : Boolean;
VAR
ServiceHour@1101908009 : Record 25006129;
ResourceCalendarChange@1101908008 : Record 25006279;
ServLaborAlloc2@1101908010 : Record 25006271;
LaborAllocApp@1101908011 : TEMPORARY Record 25006277;
ResourceLoc@1190000 : Record 156;
CheckDescription@1101908007 : Text[50];
Starting@1101908006 : Decimal;
Finishing@1101908005 : Decimal;
QtyToAllocate@1101908012 : Decimal;
EntryNo@1101908004 : Integer;
HourEntry@1190001 : Integer;
WhichEntry@1190003 : Integer;
PeriodStart@1190002 : Time;
OwnWorkTime@1101908014 : Boolean;
DoChangeServLineResource@1101908015 : Boolean;
BEGIN
//EDMS P2
[Link];
DoChangeServLineResource := FALSE;
//check for busy time in Base Calendar and in Resource Calendar Change >>
OwnWorkTime := FALSE;
IF [Link](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([Link](CurrentDay,
000000T),
[Link](CurrentDay,
ResourceCalendarChange."Starting Time"));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay, 000000T), QtyToAllocate,
0, 0, 'Err1', 0, DoChangeServLineResource,FALSE);
OwnWorkTime := TRUE;
END ELSE BEGIN
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay, 000000T), 0,
0, 0, 'Err1', 0, DoChangeServLineResource,FALSE);
OwnWorkTime := TRUE;
END;

IF NOT (ResourceCalendarChange."Ending Time" > 235959T) THEN BEGIN

QtyToAllocate := CalcHourDifference([Link](CurrentDay,
ResourceCalendarChange."Ending Time"),
[Link](CurrentDay,
235959.999T));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay,
ResourceCalendarChange."Ending Time"), QtyToAllocate, 0, 0, 'Err2',0,
DoChangeServLineResource,FALSE);
OwnWorkTime := TRUE;
END ELSE BEGIN
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay,
ResourceCalendarChange."Ending Time"), 0, 0, 0, 'Err2',0,
DoChangeServLineResource,FALSE);
OwnWorkTime := TRUE;
END;
END;
END;

//write busy time from Service Hour EDMS >>

IF NOT OwnWorkTime THEN BEGIN
[Link];
//AB >>
//[Link](ResourceNo);
IF [Link](ResourceNo) THEN BEGIN
[Link]("Service Work Group Code", ResourceLoc."Service Work
Group Code");
[Link]("Starting Date", '''''|<=%1', CurrentDay);
[Link]("Ending Date", '''''|>=%1', CurrentDay);
[Link](Day, DATE2DWY(CurrentDay, 1) - 1);
//21.02.2010 EDMSB P2 >>
HourEntry := [Link];
IF [Link] THEN BEGIN
PeriodStart := 000000T;
REPEAT
WhichEntry += 1;
IF NOT (ServiceHour."Starting Time" = PeriodStart) THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](CurrentDay,
PeriodStart),
[Link](CurrentDay,
ServiceHour."Starting Time"));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay, PeriodStart),
QtyToAllocate, 0, 0, 'Err4', 0,
DoChangeServLineResource,FALSE);
END ELSE BEGIN
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay, PeriodStart), 0,
0, 0, 'Err4', 0,
DoChangeServLineResource,FALSE);
END;
PeriodStart := ServiceHour."Ending Time";
 IF HourEntry = WhichEntry THEN BEGIN
IF NOT (ServiceHour."Ending Time" > 235959T) THEN BEGIN
QtyToAllocate :=
CalcHourDifference([Link](CurrentDay, ServiceHour."Ending Time"),

[Link](CurrentDay, 235959.999T));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay,
ServiceHour."Ending Time"), QtyToAllocate, 0, 0, 'Err5', 0,
DoChangeServLineResource,FALSE);
END ELSE BEGIN
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay,
ServiceHour."Ending Time"), 0, 0, 0, 'Err5', 0,
DoChangeServLineResource,FALSE);
END;
END;
UNTIL [Link] = 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
ServiceHour@1190005 : Record 25006129;
ResourceCalendarChange@1190004 : Record 25006279;
ResourceLoc@1190003 : Record 156;
CurrentDay@1190006 : Date;
BEGIN
CurrentDay := DateTimeMgt.Datetime2Date(StartingDateTime);

IF [Link](ResourceNo, CurrentDay) THEN BEGIN

IF ResourceCalendarChange."Change Type" = ResourceCalendarChange."Change
Type"::Nonworking THEN
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;

[Link];
[Link]("Service Work Group Code", ResourceLoc."Service Work
Group Code");
[Link]("Starting Date", '''''|<=%1', CurrentDay);
 [Link]("Ending Date", '''''|>=%1', CurrentDay);
[Link](Day, DATE2DWY(CurrentDay, 1) - 1);
//18.01.2012 EDMS P8 >>
IF [Link] THEN BEGIN
REPEAT
IF (DateTimeMgt.Datetime2Time(StartingDateTime) <= ServiceHour."Ending
Time") AND
(DateTimeMgt.Datetime2Time(EndingDateTime) >= ServiceHour."Starting
Time")
THEN
EXIT(TRUE);
UNTIL [Link] = 0;
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
QtyToAllocate@1101908004 : Decimal;
BEGIN
//busy time from date start till starttime >>
IF NOT (StartTime = 000000T) THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](CurrentDay,
000000T),
[Link](CurrentDay,
StartTime));
InsertAllocationEntry(ServLaborAllocPar, LaborAllocApp, ResourceNo,
[Link](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
QtyToAllocate@1101908004 : Decimal;
BEGIN
//busy time from date start till starttime >>
IF NOT (StartTime = 000000T) THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](CurrentDay,
StartTime),
[Link](CurrentDay,
235959.999T));
InsertAllocationEntry(ServLaborAlloc, LaborAllocApp, ResourceNo,
[Link](CurrentDay, StartTime), QtyToAllocate,
0, 0, 'Err3', 0, FALSE,FALSE);
END;
// <<
END;

PROCEDURE WriteAllocationEntries@1101908000(ResourceNo@1101908011 :
Code[20];StartingDateTime@1101908012 : Decimal;QtyToAllocate@1101908013 :
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;
ServiceHour@1101908007 : Record 25006129;
RepairStatus@1101908006 : Record 25006166;
CurrentDay@1101908004 : Date;
StartTime@1101908003 : Time;
RetStartDateTime@1101908001 : Decimal;
ReplanHours@1101908002 : Decimal;
QtyToAllocate2@1101908022 : Decimal;
ApplyToEntry@1101908020 : Integer;
FirstEntry@1101908019 : Boolean;
DoChangeServLineResource@1101908008 : Boolean;
ChangeAllocationStatusLocal@1101908009 : Boolean;
DoOneServiceMoving@1101908021 : Boolean;
Allocations@25006001 : Page 25006362;
BEGIN
[Link];
CurrentDay := DateTimeMgt.Datetime2Date(StartingDateTime);
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;
[Link];

//MESSAGE('AllocationStatus:'+FORMAT(AllocationStatus)+'
AllocationStatusAction: '+FORMAT(AllocationStatusAction)+' ScheduleAction:
'+FORMAT(ScheduleAction));

IF [Link] THEN
REPEAT
//MESSAGE('msg in writeAlloc, 1');
IF FirstEntry AND (FunctionMode = FunctionMode::Modify) THEN BEGIN
IF [Link](ModifyEntryNo) THEN;
IF [Link](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",
ReplanHours, ServiceScheduleSetup."Replan Document",
SourceSubType, SourceID);
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",
SourceSubType, SourceID);
IF ReplanHours > 0 THEN
ReplanEntries(ResourceNo, ServLaborAllocTemp."Start Date-Time",
ReplanHours, ServiceScheduleSetup."Replan Document",
SourceSubType, SourceID);
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 [Link] = 0;
END;

PROCEDURE CalculateReplanHours@1101908039(NewQty@1101908000 :
Decimal;OldQty@1101908001 : Decimal;NewStartDateTime@1101908002 :
Decimal;OldStartDateTime@1101908003 : Decimal;ResourceNo@1101908005 : Code[20]) :
Decimal;
VAR
ReplanHours@1101908004 : Decimal;
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
ReplanHours@1101908003 : Decimal;
DoOneServiceMoving@1101908002 : Boolean;
LaborAllocEntryTemp@1101904000 : TEMPORARY Record 25006271;
BEGIN
[Link];
[Link](EntryNo);

IF DoReplan THEN BEGIN

ReplanHours := CheckForTime(LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time",
EndingDateTime, EntryNo,
ServiceScheduleSetup."Replan Document",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID");
IF ReplanHours > 0 THEN
ReplanEntries(LaborAllocEntry."Resource No.", LaborAllocEntry."End Date-
Time", ReplanHours,
ServiceScheduleSetup."Replan Document",
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,
ServiceScheduleSetup."Replan Document",
LaborAllocEntry."Source Subtype", LaborAllocEntry."Source ID")
END;
END;

[Link](EntryNo);
ChangeStatus(LaborAllocEntry);
ModifyAllocationEntry(LaborAllocEntry, LaborAllocApp, LaborAllocEntry."Entry
No.", LaborAllocEntry."Resource No.",
LaborAllocEntry."Start Date-Time",
CalcHourDifference(LaborAllocEntry."Start Date-Time",
EndingDateTime),
FALSE, -1, LaborAllocEntry."Applies-to Entry
No.",Travel);

IF ReasonCode <> '' THEN

ModifyReason(LaborAllocEntry, ReasonCode);

ChangeServiceLineStatus(LaborAllocEntry."Entry No.", FALSE);

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;
LaborAllocAppTemp@1101908009 : TEMPORARY Record 25006277;
LastTime@1101908006 : Decimal;
AllocateCurrentQty@1101908008 : Decimal;
AllocateStartDateTime@1101908010 : Decimal;
DayQty@1101908011 : Integer;
DoChangeServLineResource@1101908012 : Boolean;
BEGIN
[Link];
//IF ServiceScheduleSetup."Disable Unavail. Time Control" THEN BEGIN
InsertAllocationEntry(ServLaborAllocTemp, LaborAllocAppTemp, ResourceNo,
[Link](CurrentDay, StartTime), QtyToAllocate,
0, 0, 'Err6', 0,
DoChangeServLineResource,FALSE);
EXIT;
//END;
{
DayQty := 0;
DoChangeServLineResource := FALSE;
REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
ModifyEntryNo) THEN BEGIN
IsStarttimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
[Link];
 [Link]("Resource No.", "Start Date-Time");
LastTime := 0;

IF [Link] 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,
DoChangeServLineResource,FALSE);
QtyToAllocate -= AllocateCurrentQty;
END;

[Link]("End Date-Time", '>%1',

ServLaborAllocTemp2."End Date-Time");
LastTime := ServLaborAllocTemp2."End Date-Time";
UNTIL [Link] = 0;
END;

[Link];
[Link];
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
ServLaborAllocTemp2@1101908000 : TEMPORARY Record 25006271;
LaborAllocAppTemp@1101908009 : TEMPORARY Record 25006277;
LastTime@1101908006 : Decimal;
AllocateCurrentQty@1101908008 : Decimal;
AllocateStartDateTime@1101908010 : Decimal;
DayQty@1101908011 : Integer;
DoChangeServLineResource@1101908012 : Boolean;
BEGIN
DayQty := 0;
DoChangeServLineResource := FALSE;
REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
ModifyEntryNo) THEN BEGIN
IsStarttimeAvailableBackward(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
[Link];
[Link]("Resource No.", "End Date-Time");
LastTime := 0;

IF [Link] 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;

InsertAllocationEntry(ServLaborAllocTemp, LaborAllocAppTemp,
ResourceNo, AllocateStartDateTime, AllocateCurrentQty,
0, 0, 'Err7', 0,
DoChangeServLineResource,FALSE);
QtyToAllocate -= AllocateCurrentQty;
END;

LastTime := ServLaborAllocTemp2."Start Date-Time";

[Link]("Start Date-Time", '<%1',
ServLaborAllocTemp2."Start Date-Time");
UNTIL [Link](-1) = 0;
END;

[Link];
[Link];
CurrentDay := CurrentDay - 1;
StartTime := 000000T;
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
ServLaborAlloc@1101908002 : Record 25006271;
BEGIN
[Link];
[Link]("Applies-to Entry No.");
 [Link]("Applies-to Entry No.", ChangeFromEntry);
[Link]("Entry No.", '<>%1', ChangeToEntry);
IF [Link] THEN
REPEAT
[Link]("Applies-to Entry No.",
ChangeToEntry); //14.03.2014 Elva Baltic P8 #S0003 MMG7.00
[Link];
UNTIL [Link] = 0;
END;

PROCEDURE SplitAllocTracking@1101908008(EntryNo@1101908000 :
Integer;Mode@1101908001 : 'Move,Delete') : Boolean;
VAR
LaborAllocEntryTemp@1101908002 : TEMPORARY Record 25006271;
QuestionText@1101908003 : Text[200];
BEGIN
[Link];
IF ServiceScheduleSetup."Handle Linked Entries" =
ServiceScheduleSetup."Handle Linked Entries"::No THEN
EXIT(FALSE);

IF ServiceScheduleSetup."Handle Linked Entries" =

ServiceScheduleSetup."Handle Linked Entries"::Yes THEN
EXIT(TRUE);

IF Mode = Mode::Delete THEN

QuestionText := Text100;

IF ServiceScheduleSetup."Handle Linked Entries" =

ServiceScheduleSetup."Handle Linked Entries"::Prompt THEN BEGIN
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
[Link];
IF [Link] > 1 THEN
IF CONFIRM(QuestionText) THEN
EXIT(TRUE);
END;

EXIT(FALSE);
END;

PROCEDURE FillServiceLine@1101908017(VAR ServiceLine1@1101908000 : Record

25006146);
BEGIN
IF [Link] THEN
REPEAT
ServiceLine := ServiceLine1;
IF [Link] THEN;
UNTIL [Link] = 0;
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 [Link] THEN;
END;
 PROCEDURE CalculateTotalHours@1101908010(EntryNo@1101908000 : Integer) :
Decimal;
VAR
LaborAllocEntryTemp@1101908001 : TEMPORARY Record 25006271;
TotalHours@1101908002 : Decimal;
BEGIN
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
IF [Link] THEN
REPEAT
TotalHours += LaborAllocEntryTemp."Quantity (Hours)";
UNTIL [Link] = 0;

EXIT(TotalHours);
END;

PROCEDURE CalcLaborRemainHours@1101904012(EntryNo@1101908000 : Integer) :

Decimal;
VAR
LaborAllocEntryTemp@1101908001 : TEMPORARY Record 25006271;
TotalHours@1101908002 : Decimal;
BEGIN
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
[Link](Status, '%1|%2',
[Link]::Pending, [Link]::"On Hold");
IF [Link] THEN
REPEAT
TotalHours += LaborAllocEntryTemp."Quantity (Hours)";
UNTIL [Link] = 0;

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;
LaborAllocApp2@1101908004 : Record 25006277;
LaborAllocEntryTemp@1101908003 : TEMPORARY Record 25006271;
LaborAllocAppTemp@1101908002 : TEMPORARY Record 25006277;
ServiceLineTemp@1101908008 : TEMPORARY Record 25006146;
CurrentDay@1101908009 : Date;
StartTime@1101908010 : Time;
ApplyToEntry@1101908007 : Integer;
NewStartingDateTime@1101908012 : Decimal;
NewEndingDateTime@1101908014 : Decimal;
OldEndingTime@1101908013 : Decimal;
WorkHours@1101908015 : Decimal;
DoReplan@1101908017 : Boolean;
BEGIN
[Link];
OldEndingTime := 0;
DoReplan := FALSE;
[Link];
[Link]("Resource No.", ResourceNo);
[Link]("Start Date-Time", '>=%1', StartingDateTime);
[Link](Status, '%1|%2', [Link]::Pending,
[Link]::"On Hold");
[Link]("Planning Policy", LaborAllocEntry2."Planning
Policy"::Queue);

IF [Link] THEN
REPEAT
LaborAllocEntryTemp := LaborAllocEntry2;
[Link];
UNTIL [Link] = 0;

IF DoOneServiceMoving THEN BEGIN

[Link]("Planning Policy");
[Link]("Source Type", LaborAllocEntry2."Source
Type"::"Service Document");
[Link]("Source Subtype", SourceSubType);
[Link]("Source ID", SourceID);
IF [Link] THEN
REPEAT
LaborAllocEntryTemp := LaborAllocEntry2;
IF [Link] THEN;
UNTIL [Link] = 0;
END;

[Link]("Resource No.", "Start Date-Time");

IF [Link] THEN
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,
[Link], FALSE,FALSE);
NewEndingDateTime := LaborAllocEntry."End Date-Time";
UNTIL [Link] = 0;
END;

PROCEDURE CalcWorkHourDifference@1101908022(ResourceNo@1101908000 :
Code[20];FromDateTime@1101908001 : Decimal;ToDateTime@1101908002 : Decimal) :
Decimal;
VAR
ServLaborAllocTemp@1101908009 : TEMPORARY Record 25006271;
ServLaborAllocTemp2@1101908008 : TEMPORARY Record 25006271;
LaborAllocAppTemp@1101908007 : TEMPORARY Record 25006277;
CurrentDay@1101908012 : Date;
StartTime@1101908013 : Time;
LastTime@1101908006 : Decimal;
AllocateCurrentQty@1101908005 : Decimal;
AllocateStartDateTime@1101908004 : Decimal;
AllocateCurrentEndDateTime@1101908003 : Decimal;
WorkHours@1101908010 : Decimal;
FromDateTime2@1101908015 : Decimal;
CycleEnd@1101908011 : Boolean;
IsReverse@1101908014 : Boolean;
DoChangeServLineResource@1101908016 : 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;
DoChangeServLineResource := FALSE;

REPEAT
IF IsTimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay, 0) THEN
BEGIN
IsStarttimeAvailable(ServLaborAllocTemp2, ResourceNo, CurrentDay,
StartTime);
[Link];
[Link]("Resource No.", "Start Date-Time");
LastTime := 0;
IF [Link] 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);
InsertAllocationEntry(ServLaborAllocTemp, LaborAllocAppTemp,
ResourceNo, AllocateStartDateTime, AllocateCurrentQty,
0, 0, 'Err8', 0,
DoChangeServLineResource,FALSE);
END;
[Link]("End Date-Time", '>%1',
ServLaborAllocTemp2."End Date-Time");
 LastTime := ServLaborAllocTemp2."End Date-Time";
UNTIL ([Link] = 0) OR CycleEnd;
END;
[Link];
[Link];
CurrentDay := CurrentDay + 1;
StartTime := 000000T;
UNTIL CycleEnd OR ([Link](CurrentDay, StartTime) > ToDateTime);

WorkHours := 0;
[Link];
IF [Link] THEN
REPEAT
WorkHours += ServLaborAllocTemp."Quantity (Hours)";
UNTIL [Link] = 0;

IF IsReverse THEN
EXIT(-WorkHours);

EXIT(WorkHours);
END;

PROCEDURE CalculateNewStartDateTime@1101908023(ResourceNo@1101908007 :
Code[20];StartingDateTime@1101908006 : Decimal;QtyToAllocate@1101908005 :
Decimal) : Decimal;
VAR
ServLaborAllocTemp@1101908000 : TEMPORARY Record 25006271;
CurrentDay@1101908001 : Date;
StartTime@1101908002 : Time;
BEGIN
CurrentDay := DateTimeMgt.Datetime2Date(StartingDateTime);
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;

[Link];
IF [Link] 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
ServLaborAlloc@1101908003 : Record 25006271;
ContinueStartingDateTime@1101908004 : Decimal;
BEGIN
ContinueStartingDateTime := FinishingDateTime;
 [Link];
[Link]("Resource No.", ResourceNo);
[Link]("Start Date-Time", StartingDateTime,
FinishingDateTime - 0.00001);
IF EntryNo <> 0 THEN
[Link]("Entry No.", '<>%1', EntryNo);
[Link]("Resource No.", "Start Date-Time");

IF DoOneServiceMoving THEN BEGIN

[Link]("Source Type", ServLaborAlloc."Source
Type"::"Service Document");
[Link]("Source Subtype", SourceSubType);
[Link]("Source ID", SourceID);
END;

IF [Link] THEN
ContinueStartingDateTime := ServLaborAlloc."Start Date-Time";

EXIT(CalcHourDifference(ContinueStartingDateTime, FinishingDateTime));
END;

PROCEDURE SplitServiceLine@1101908024(DocumentType@1101908007 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
Order';DocumentNo@1101908006 : Code[20];LineNo@1101908005 : Integer) : Integer;
VAR
ServiceLineLoc@1101908002 : Record 25006146;
NewLineNo@1101908003 : Integer;
BEGIN
IF [Link](DocumentType, DocumentNo, LineNo) THEN
NewLineNo := [Link](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
LaborAllocEntryLoc@1101908003 : Record 25006271;
BEGIN
[Link];
[Link]("Document Type", DocumentType);
[Link]("Document No.", DocumentNo);
[Link]("Resource No.", ResourceNo);
IF [Link] THEN
REPEAT
IF ([Link](LaborAllocApp."Allocation Entry No.")) AND
NOT([Link](LaborAllocApp."Allocation Entry No."))
THEN BEGIN
LaborAllocEntry := LaborAllocEntryLoc;
[Link];
END;
UNTIL [Link] = 0 ;
END;
 PROCEDURE ProcessStartLabor@1101908004(StartingDateTime@1101908000 : Decimal);
VAR
WorkTimeEntry@1101908001 : Record 25006276;
Hours@1101908002 : Decimal;
EntryNo@1101908003 : Integer;
DoReplan@1101908004 : Boolean;
ResourceNo@1000 : Code[20];
OnDate@25006000 : Date;
OnTime@25006001 : Time;
Travel@25006002 : Boolean;
BEGIN
[Link];
ScheduleAction := ScheduleAction::"Time Registration";
EntryNo := [Link];
[Link](EntryNo);
Travel := [Link];
//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";

ChangeAllocationStatus := TRUE;
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
ResourceNo := LaborAllocEntry."Resource No.";

[Link](DateTimeMgt.Datetime2Date(StartingDateTime));
OnDate := DateTimeMgt.Datetime2Date(StartingDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartingDateTime);

[Link](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",
LaborAllocEntry."Source ID", 1, EntryNo, DoReplan,
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;
EntryNo@1101908005 : Integer;
DoReplan@1101908004 : Boolean;
OnDate@25006000 : Date;
OnTime@25006001 : Time;
Travel@25006002 : Boolean;
BEGIN
ScheduleAction := ScheduleAction::"Time Registration";
[Link];
AllocationStatusAction := AllocationStatus1;

EntryNo := [Link];
[Link](EntryNo);
Travel := [Link];
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

WriteAllocationEntryEnd(EntryNo, EndingDateTime, DoReplan,
ReasonCode,Travel);

IF AllocationStatus = AllocationStatus::"On Hold" THEN BEGIN

//AllocationStatus := AllocationStatus::Finished;
//AllocationStatus := AllocationStatus::"On Hold";
WriteAllocationEntryEnd(EntryNo, EndingDateTime, DoReplan,
ReasonCode,Travel);
HoldHours += CheckRemainingLinkedAllocation(EntryNo); //15.08.2013 EDMS P8
[Link](EntryNo); //20.07.2013 EDMS P8
 ChangeAllocationStatus := TRUE;
AllocationStatus := AllocationStatus::"On Hold";
ReasonCodeGlobal := ReasonCode;
IF HoldHours > 0 THEN
WriteAllocationEntries(LaborAllocEntry."Resource No.",
LaborAllocEntry."End Date-Time", HoldHours,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
// 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 [Link](LaborAllocEntry."Resource No.")
THEN
[Link](LaborAllocEntry."Resource
No.",OnDate,OnTime);
END;

PROCEDURE ProcessBreak@1101908041(StandardCode@1101908004 :
Code[20];ReasonCode@1101908006 : Code[10];BreakHours@1101908005 : Decimal);
VAR
LaborAllocEntry2@1101908003 : Record 25006271;
LaborAllocEntry3@25006000 : Record 25006271;
ServStandardEvent@1000 : Record 25006272;
CurrDateTime@1101908000 : Decimal;
FinishedHours@1101908001 : Decimal;
HoldHours@1101908002 : Decimal;
DoReplan@1190000 : Boolean;
Travel@25006001 : Boolean;
BEGIN
ScheduleAction := ScheduleAction::"Time Registration";
[Link];
[Link](StandardCode); //12.08.2013 EDMS P8

CurrDateTime := [Link](WORKDATE, TIME);

[Link]([Link]);
FinishedHours := CalcHourDifference(LaborAllocEntry2."Start Date-Time",
CurrDateTime);
HoldHours := LaborAllocEntry2."Quantity (Hours)" - FinishedHours;
DoReplan := TRUE;
Travel := [Link];

AllocationStatus := AllocationStatus::Finished;
WriteAllocationEntryEnd([Link], CurrDateTime,
DoReplan, ReasonCode,Travel);

AllocationStatus := AllocationStatus::Pending;
WriteAllocationEntries(LaborAllocEntry2."Resource No.", CurrDateTime,
BreakHours, 2, 0, StandardCode, 0, 0, DoReplan, 0, FALSE,Travel);

ChangeAllocationStatus := TRUE;
 AllocationStatus := AllocationStatus::"On Hold";
WriteAllocationEntries(LaborAllocEntry2."Resource No.", LaborAllocEntry."End
Date-Time", HoldHours,
LaborAllocEntry2."Source Type",
LaborAllocEntry2."Source Subtype",
LaborAllocEntry2."Source ID", 0,
[Link], DoReplan, -1, FALSE,Travel);
END;

PROCEDURE ProcessHoldLabor@25006002(CurrentDateTime@25006002 : Decimal);

VAR
WorkTimeEntry@1101908001 : Record 25006276;
Hours@1101908002 : Decimal;
EntryNo@1101908003 : Integer;
DoReplan@1101908004 : Boolean;
ResourceNo@1000 : Code[20];
LaborAllocEntryTmp@25006000 : TEMPORARY Record 25006271;
LaborAllocEntry@25006001 : Record 25006271;
OnDate@25006003 : Date;
OnTime@25006004 : Time;
Travel@25006005 : Boolean;
BEGIN
{
EntryNo := [Link];
FindSplitEntries(EntryNo, LaborAllocEntryTmp, 0, 1111);
IF [Link] THEN
REPEAT
IF [Link](LaborAllocEntryTmp."Entry No.") THEN BEGIN
ReasonCodeGlobal := LaborAllocEntry."Reason Code";
AllocationStatus := AllocationStatus::"On Hold";
ChangeStatus(LaborAllocEntry);
END;
UNTIL [Link] = 0;

ChangeServiceLineStatus(EntryNo,FALSE);

OnDate := DateTimeMgt.Datetime2Date(CurrentDateTime);
OnTime := DateTimeMgt.Datetime2Time(CurrentDateTime);
IF NOT [Link](LaborAllocEntryTmp."Resource
No.") THEN
[Link](LaborAllocEntryTmp."Resource
No.",OnDate,OnTime);
}

[Link];
ScheduleAction := ScheduleAction::"Time Registration";
EntryNo := [Link];
[Link](EntryNo);
Travel := [Link];

Hours := CalcHourDifference(CurrentDateTime,LaborAllocEntry."End Date-Time");

IF Hours <= 0 THEN
Hours := LaborAllocEntry."Quantity (Hours)";

ReasonCodeGlobal := LaborAllocEntry."Reason Code";

ChangeAllocationStatus := TRUE;
AllocationStatus := AllocationStatus::"On Hold";
 AskedForAllocationSpliting := TRUE;
DoReplan := TRUE;
IF Resource."No." <> '' THEN
ResourceNo := Resource."No."
ELSE
ResourceNo := LaborAllocEntry."Resource No.";

[Link](DateTimeMgt.Datetime2Date(CurrentDateTime));
OnDate := DateTimeMgt.Datetime2Date(CurrentDateTime);
OnTime := DateTimeMgt.Datetime2Time(CurrentDateTime);

//[Link](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",
LaborAllocEntry."Source ID", 1, EntryNo, DoReplan,
AllocationStatus, FALSE,Travel);
END;

IF NOT [Link](ResourceNo) THEN

[Link](ResourceNo,OnDate,OnTime);
END;

PROCEDURE ChangeStatus@1101908025(VAR LaborAllocEntry@1101908000 : Record

25006271);
BEGIN
[Link](Status, AllocationStatus);
[Link]("Reason Code", ReasonCodeGlobal);
[Link];
END;

PROCEDURE ChangeServiceLineStatus@1101908026(EntryNo@1101908001 :
Integer;Remove@1190000 : Boolean);
VAR
ServiceHdr@1190002 : Record 25006145;
ServiceLine@1101908000 : Record 25006146;
ServiceLineTemp@1190007 : TEMPORARY Record 25006146;
PostedServiceHdr@1190003 : Record 25006149;
PostedServiceLine@1190004 : Record 25006150;
PostedServRetHdr@1190005 : Record 25006154;
PostedServRetLine@1190006 : Record 25006155;
LaborAllocEntry@1101908003 : Record 25006271;
LaborAllocApp@1101908002 : Record 25006277;
LaborAllocApp2@1101908004 : Record 25006277;
WorkStatus@1101908006 : Record 25006166;
CurrStatus@1101908005 : Integer;
WorkStatusCode@1190001 : Code[10];
Resource@1101904000 : Record 156;
BEGIN
[Link](EntryNo);
IF LaborAllocEntry."Source Type" <> LaborAllocEntry."Source Type"::"Service
Document" THEN
EXIT;
 IF DontChangeServiceStatus THEN
EXIT;

[Link];
[Link]("Allocation Entry No.", EntryNo);
IF [Link] THEN
REPEAT
CurrStatus := 999999;
WorkStatusCode := '';
[Link];
[Link]("Document Type", LaborAllocApp."Document Type");
[Link]("Document No.", LaborAllocApp."Document No.");
IF LaborAllocApp."Document Line No." <> 0 THEN BEGIN
[Link]("Document Line No.", LaborAllocApp."Document
Line No.");
IF Remove THEN
[Link]("Allocation Entry No.", '<>%1', EntryNo);
IF [Link] THEN
REPEAT
[Link](LaborAllocApp2."Resource No.");
IF NOT (ServiceScheduleSetup."Only Pers. Affect Doc. Status" AND
([Link] = [Link]::Machine)) THEN BEGIN
IF [Link](LaborAllocApp2."Allocation Entry No.")
THEN BEGIN
[Link];
[Link]("Service Order Status",
[Link]);
IF [Link] THEN;

IF CurrStatus > [Link] THEN BEGIN

CurrStatus := [Link];
WorkStatusCode := [Link];
END;
END;
END;
UNTIL [Link] = 0;

IF NOT [Link] THEN BEGIN

//Preparing temp variable to be used as parameter
[Link];
[Link];
[Link];
[Link]("Document Type",LaborAllocApp."Document Type");
[Link]("Document No.",LaborAllocApp."Document No.");
IF [Link] THEN
REPEAT
[Link];
ServiceLineTemp := ServiceLine;
[Link];
UNTIL [Link] = 0;

//Updating service line status

[Link];
[Link](LaborAllocApp."Document Type",
LaborAllocApp."Document No.", LaborAllocApp."Document Line No.");
[Link] := WorkStatusCode;
IF NOT GlobDontModifyServLine THEN
 [Link](TRUE);

//Updating service line status in temp variable

[Link](LaborAllocApp."Document Type",
LaborAllocApp."Document No.", LaborAllocApp."Document Line No.");
[Link] := WorkStatusCode;
[Link](TRUE);

[Link](ServiceLine."Document Type", ServiceLine."Document

No.");
ChangeServiceHeaderStatus(ServiceHdr,ServiceLineTemp);
END;
END ELSE BEGIN
[Link];
[Link]("Service Order Status", [Link]);
IF [Link] THEN;
IF NOT [Link] THEN BEGIN
[Link](LaborAllocApp."Document Type", LaborAllocApp."Document
No.");
IF Remove THEN
[Link]("Work Status Code", '')
ELSE
[Link]("Work Status Code", [Link]);
[Link](TRUE);
END;
END;
UNTIL [Link] = 0;
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 := '';

[Link];
[Link]("Document Type", ServiceLine."Document Type"::Order);
[Link]("Document No.", ServiceHeader."No.");
[Link](Type, [Link]::Labor);
IF [Link] THEN
REPEAT
IF [Link]([Link]) THEN BEGIN
IF [Link] < LowestStatus THEN BEGIN
LowestStatus := [Link];
StatusCode := [Link];
END;
END;
UNTIL [Link] = 0;

[Link]("Work Status Code", StatusCode);

[Link](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];
LaborAllocApp@1101904000 : Record 25006277;
LaborAllocEntry@1101904001 : Record 25006271;
Resource@1101904002 : Record 156;
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
[Link]("Resource No.");
IF NOT (ServiceScheduleSetup."Only Pers. Affect Doc. Status" AND
([Link] = [Link]::Machine)) THEN BEGIN
IF [Link]("Allocation Entry No.") THEN BEGIN
[Link];
[Link]("Service Order Status",
[Link]);
IF [Link] THEN BEGIN
IF [Link] < LowestStatus THEN BEGIN
LowestStatus := [Link];
StatusCode := [Link];
END;
END;
END;
END;
UNTIL NEXT = 0;
END;

[Link];
[Link]("Document Type", ServiceHeader."Document Type");
[Link]("Document No.", ServiceHeader."No.");
[Link](Type, [Link]::Labor);
IF [Link] THEN
REPEAT
IF [Link]([Link]) THEN BEGIN
IF [Link] < LowestStatus THEN BEGIN
LowestStatus := [Link];
StatusCode := [Link];
END;
END;
UNTIL [Link] = 0;

[Link]("Work Status Code", StatusCode);

[Link](TRUE);
END;

PROCEDURE ProcessStartWorkday@1101908030(ResourceNo@1101908002 :
Code[20];StartDateTime@1101908003 : Decimal);
VAR
WorkTimeEntry@1101908001 : Record 25006276;
EntryNo@1101908000 : Integer;
 ServLaborAllocationEntry@25006000 : Record 25006271;
OnDate@25006001 : Date;
OnTime@25006002 : Time;
BEGIN
ScheduleAction := ScheduleAction::"Time Registration";
[Link];
[Link]("Resource No.", ResourceNo);
[Link](Closed, FALSE);
IF [Link] THEN BEGIN
MESSAGE(STRSUBSTNO(Text120, ResourceNo));
EXIT;
END;

[Link];
IF [Link] THEN
EntryNo := WorkTimeEntry."Entry No." + 1
ELSE
EntryNo := 1;

[Link];
WorkTimeEntry."Entry No." := EntryNo;
[Link]("Resource No.", ResourceNo);
[Link]("Worktime Begin", StartDateTime);
[Link](TRUE);

OnDate := DateTimeMgt.Datetime2Date(StartDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartDateTime);

[Link]('STARTWORKTIME',ResourceNo,OnDate,OnTime);
[Link](ResourceNo,OnDate,OnTime);
END;

PROCEDURE ProcessEndWorkday@1101908031(ResourceNo@1101908004 :
Code[20];EndDateTime@1101908000 : Decimal);
VAR
WorkTimeEntry@1101908003 : Record 25006276;
ServLaborAllocationEntryL@1000 : Record 25006271;
DoReplan@1101908001 : Boolean;
ResourceTimeRegMgt@25006000 : Codeunit 25006290;
ServiceSetup@25006001 : Record 25006120;
ServStandardEvent@25006002 : Record 25006272;
OnDate@25006003 : Date;
OnTime@25006004 : Time;
BEGIN
[Link];
ScheduleAction := ScheduleAction::"Time Registration";
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 FINDFIRST THEN BEGIN
IF GUIALLOWED THEN BEGIN //11.12.2018 EB.P7
IF CONFIRM(Text129) THEN
REPEAT
AllocationStatus := AllocationStatus::Finished;
WriteAllocationEntryEnd("Entry No.", EndDateTime, DoReplan,
'',[Link]);

[Link]('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;

[Link]("Resource No.",Closed);
[Link]("Resource No.",ResourceNo);
[Link](Closed,FALSE);
IF NOT [Link] THEN BEGIN
MESSAGE(STRSUBSTNO(Text119, ResourceNo));
EXIT;
END;

[Link]("Worktime End", EndDateTime);

[Link]("Worked Hours",
CalcHourDifference(WorkTimeEntry."Worktime Begin", EndDateTime));
[Link](Closed, TRUE);
[Link](TRUE);

[Link](ResourceNo,OnDate,OnTime);

[Link]('FINISHWORKTIME',ResourceNo,OnDate,OnTime)
;
END;

PROCEDURE ProcessStartWorkdaySilent@25006003(ResourceNo@1101908002 :
Code[20];StartDateTime@1101908003 : Decimal);
VAR
WorkTimeEntry@1101908001 : Record 25006276;
EntryNo@1101908000 : Integer;
ServLaborAllocationEntry@25006000 : Record 25006271;
OnDate@25006001 : Date;
OnTime@25006002 : Time;
BEGIN
OnDate := DateTimeMgt.Datetime2Date(StartDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartDateTime);
 ScheduleAction := ScheduleAction::"Time Registration";
[Link];
[Link]("Resource No.", ResourceNo);
[Link](Closed, FALSE);
IF NOT [Link] THEN BEGIN
[Link];
IF [Link] THEN
EntryNo := WorkTimeEntry."Entry No." + 1
ELSE
EntryNo := 1;

[Link];
WorkTimeEntry."Entry No." := EntryNo;
[Link]("Resource No.", ResourceNo);
[Link]("Worktime Begin", StartDateTime);
[Link](TRUE);

[Link]('STARTWORKTIME',ResourceNo,OnDate,OnTime);

END;
END;

PROCEDURE CompareSchedulePassword@1101908028(ResourceNo@1101908001 :
Code[20];SchedulePassword@1101908002 : Text[20]);
BEGIN
IF [Link](ResourceNo) THEN
IF Resource."Serv. Schedule Password" = SchedulePassword THEN
EXIT;

ERROR(Text112);
END;

PROCEDURE CreateFieldText@1101908032(EntryNo@1101908000 : Integer) : Text[250];

VAR
LaborAllocEntry@1101908002 : Record 25006271;
LaborAllocApp@1101908001 : Record 25006277;
ScheduleCellConfig@1101908003 : Record 25006280;
ServHdr@1101908004 : Record 25006145;
ServLine@1101908005 : Record 25006146;
StandardEvent@1101908006 : Record 25006272;
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
[Link](Sequence);
EndText := '';
[Link](EntryNo);
[Link];
[Link]("Allocation Entry No.", EntryNo);
 IF [Link] THEN;
IF LaborAllocEntry."Source Type" = LaborAllocEntry."Source Type"::"Service
Document" THEN BEGIN
IF [Link](LaborAllocApp."Document Type", LaborAllocApp."Document No.")
THEN BEGIN
IF LaborAllocApp."Document Line No." <> 0 THEN BEGIN
[Link](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 [Link](LaborAllocApp."Document No.") THEN BEGIN
IF LaborAllocApp."Document Line No." <> 0 THEN BEGIN
[Link]( LaborAllocApp."Document No.",
LaborAllocApp."Document Line 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
[Link](LaborAllocEntry."Source ID");
SourceTypeFilter := FORMAT(DATABASE::"Serv. Standard Event");
END;
//24.10.2013 EDMS P8 >>
IF LaborAllocEntry."Detail Entry No." > 0 THEN
IF [Link](LaborAllocEntry."Detail Entry No.")
THEN BEGIN
IF SourceTypeFilter <> '' THEN
SourceTypeFilter += '|';
SourceTypeFilter += FORMAT(DATABASE::"Serv. Allocation Description");;
END;
[Link]("Source Type", SourceTypeFilter);
//24.10.2013 EDMS P8 <<

IF [Link] THEN
REPEAT
CASE ScheduleCellConfig."Source Type" OF
DATABASE::"Service Header EDMS" :
BEGIN
[Link](DATABASE::"Service Header EDMS");
[Link](ServHdr);
END;
DATABASE::"Service Line EDMS" :
BEGIN
[Link](DATABASE::"Service Line EDMS");
[Link](ServLine);
END;
DATABASE::"Posted Serv. Order Header" :
BEGIN
[Link](DATABASE::"Service Header EDMS");
[Link](PostedServHdr);
END;
DATABASE::"Posted Serv. Order Line" :
BEGIN
[Link](DATABASE::"Service Line EDMS");
 [Link](PostedServLine);
END;
DATABASE::"Serv. Standard Event" :
BEGIN
[Link](DATABASE::"Serv. Standard Event");
[Link](StandardEvent);
END;
//24.10.2013 EDMS P8 >>
DATABASE::"Serv. Allocation Description" :
BEGIN
[Link](DATABASE::"Serv. Allocation Description");
[Link](ServLaborAllocationDetailLoc);
END;
//24.10.2013 EDMS P8 <<
END;

FieldRef := [Link](ScheduleCellConfig."Source Ref. No.");

// 14.05.2014 Elva Baltic P21 #S0102 MMG7.00 >>

EVALUATE(FieldRefClass,FORMAT([Link]));
IF FieldRefClass = FieldRefClass::FlowField THEN
[Link];
// 14.05.2014 Elva Baltic P21 #S0102 MMG7.00 <<

FieldValue := FORMAT([Link]);
FieldOption := [Link];

IF FieldOption <> '' THEN BEGIN

EVALUATE(OptionNumber, FieldValue);
FieldValue := SELECTSTR(OptionNumber + 1, FieldOption);
END;

IF [Link] <> '' THEN

FieldCaption := [Link] + ': '
ELSE
FieldCaption := '';

IF FieldValue <> '' THEN BEGIN

IF EndText = '' THEN
EndText := COPYSTR(FieldCaption + FieldValue, 1, 250)
ELSE
EndText := COPYSTR(EndText + '; ' + FieldCaption + FieldValue, 1,
250);
END;
[Link];
UNTIL [Link] = 0;

EXIT(EndText);
END;

PROCEDURE CreateNewServiceDocument@1101908038(DocumentType@1190000 :
'Quote,Order,Return Order') : Code[20];
VAR
ServHeader@1101908000 : Record 25006145;
BEGIN
CLEAR(ServHeader);
[Link];
ServHeader."Document Type" := DocumentType;
[Link](TRUE);
 COMMIT;
CASE DocumentType OF
DocumentType::Quote:
[Link](PAGE::"Service Quote EDMS", ServHeader);
DocumentType::Order:
[Link](PAGE::"Service Order EDMS", ServHeader);
END;

EXIT(ServHeader."No.");
END;

PROCEDURE DeleteAllocationFromServLines@1101908040(ServLine@1101908000 : Record

25006146);
VAR
LaborAllocEntry@1101908002 : Record 25006271;
LaborAllocApp@1101908001 : Record 25006277;
LaborAllocEntry2@1101908004 : Record 25006271;
LaborAllocApp2@1101908003 : Record 25006277;
LaborAllocAppTemp@1190000 : TEMPORARY Record 25006277;
BEGIN
// 18.12.2014 Elva Baltic P21 #E0003 >>
[Link];
[Link]("Document Type", ServLine."Document Type");
[Link]("Document No.", ServLine."Document No.");
[Link]("Document Line No.", ServLine."Line No.");
IF [Link] THEN
REPEAT
[Link](TRUE);
UNTIL [Link] = 0;
// 18.12.2014 Elva Baltic P21 #E0003 <<

[Link];
[Link];
[Link]("Document Type", ServLine."Document Type");
[Link]("Document No.", ServLine."Document No.");
[Link]("Document Line No.", ServLine."Line No.");
IF [Link] THEN BEGIN
IF GUIALLOWED THEN
IF NOT CONFIRM(Text117) THEN
ERROR(Text118);
REPEAT
IF [Link](LaborAllocApp."Allocation Entry No.") THEN
IF [Link] = [Link]::Finished THEN
ERROR(Text116);
LaborAllocAppTemp := LaborAllocApp;
[Link];
UNTIL [Link] = 0;
END;

IF [Link] THEN //tempp2

REPEAT
DeleteAllocationEntry(LaborAllocEntry2, LaborAllocApp2,
LaborAllocAppTemp."Allocation Entry No.", 11111);
UNTIL [Link] = 0;
END;

PROCEDURE DeleteAllocationFromServHdr@1190037(ServHdr@1101908000 : Record

25006145);
VAR
 LaborAllocEntry@1101908002 : Record 25006271;
LaborAllocApp@1101908001 : Record 25006277;
LaborAllocEntry2@1101908004 : Record 25006271;
LaborAllocApp2@1101908003 : Record 25006277;
LaborAllocAppTemp@1190000 : TEMPORARY Record 25006277;
BEGIN
[Link];
[Link];
[Link]("Document Type", ServHdr."Document Type");
[Link]("Document No.", ServHdr."No.");
[Link]("Document Line No.", 0);
IF [Link] THEN BEGIN
IF NOT CONFIRM(Text117) THEN
ERROR(Text118);
REPEAT
IF [Link](LaborAllocApp."Allocation Entry No.") THEN
IF [Link] = [Link]::Finished THEN
ERROR(Text116);
LaborAllocAppTemp := LaborAllocApp;
[Link];
UNTIL [Link] = 0;
END;

IF [Link] THEN //tempp2

REPEAT
DeleteAllocationEntry(LaborAllocEntry2, LaborAllocApp2,
LaborAllocAppTemp."Allocation Entry No.", 11111);
UNTIL [Link] = 0;
END;

PROCEDURE ModifyReason@1101908042(VAR LaborAllocEntry@1101908000 : Record

25006271;ReasonCode@1101908001 : Code[10]);
BEGIN
LaborAllocEntry."Reason Code" := ReasonCode;
[Link];
END;

PROCEDURE PostingServLine@1101908044(ServiceLine@1101908000 : Record

25006146;NewOrderNo@1101908001 : Code[20]);
VAR
LaborAllocEntry@1101908003 : Record 25006271;
LaborAllocApp@1101908002 : Record 25006277;
LaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
LaborAllocAppTemp@1101908004 : TEMPORARY Record 25006277;
BEGIN
IF [Link] <> [Link]::Labor THEN
EXIT;

[Link];
[Link];
[Link];

[Link];
[Link]("Document Type", ServiceLine."Document Type");
[Link]("Document No.", ServiceLine."Document No.");
[Link]("Document Line No.", ServiceLine."Line No.");
IF NOT [Link] THEN
EXIT
ELSE
 REPEAT
IF [Link](LaborAllocApp."Allocation Entry No.") THEN BEGIN
IF ([Link] <> [Link]::Finished) AND
ServiceScheduleSetup."Post Only When Finished" THEN
ERROR(STRSUBSTNO(Text115, ServiceLine."Line No."));
LaborAllocEntryTemp := LaborAllocEntry;
IF [Link] THEN;
END;
LaborAllocAppTemp := LaborAllocApp;
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
[Link](LaborAllocAppTemp."Allocation Entry No.",
LaborAllocAppTemp."Document Type",
LaborAllocAppTemp."Document No.",
LaborAllocAppTemp."Document Line No.", LaborAllocAppTemp."Line No.");
[Link](TRUE);
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
IF [Link](LaborAllocEntryTemp."Entry No.") THEN
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
[Link](LaborAllocEntryTemp);
LaborAllocEntry."Source ID" := NewOrderNo;
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
[Link](LaborAllocAppTemp);
LaborAllocApp."Document No." := NewOrderNo;
[Link] := TRUE;
[Link](TRUE);
UNTIL [Link] = 0;
END;

PROCEDURE PostingServHdr@1190036(ServiceHdr@1101908000 : Record

25006145;NewOrderNo@1101908001 : Code[20]);
VAR
LaborAllocEntry@1101908003 : Record 25006271;
LaborAllocApp@1101908002 : Record 25006277;
LaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
LaborAllocAppTemp@1101908004 : TEMPORARY Record 25006277;
BEGIN
[Link];
[Link];
[Link];
[Link];

[Link];
[Link]("Document Type", ServiceHdr."Document Type");
[Link]("Document No.", ServiceHdr."No.");
 [Link]("Document Line No.", 0);
IF NOT [Link] THEN
EXIT
ELSE
REPEAT
IF [Link](LaborAllocApp."Allocation Entry No.") THEN BEGIN
IF ([Link] <> [Link]::Finished) AND
ServiceScheduleSetup."Post Only When Finished" THEN
ERROR(STRSUBSTNO(Text141, ServiceHdr."No."));
LaborAllocEntryTemp := LaborAllocEntry;
IF [Link] THEN;
END;
LaborAllocAppTemp := LaborAllocApp;
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
[Link](LaborAllocAppTemp."Allocation Entry No.",
LaborAllocAppTemp."Document Type",
LaborAllocAppTemp."Document No.",
LaborAllocAppTemp."Document Line No.",
LaborAllocAppTemp."Line No.");
[Link](TRUE);
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
IF [Link](LaborAllocEntryTemp."Entry No.") THEN
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
LaborAllocEntry := LaborAllocEntryTemp;
LaborAllocEntry."Source ID" := NewOrderNo;
[Link];
UNTIL [Link] = 0;

IF [Link] THEN
REPEAT
LaborAllocApp := LaborAllocAppTemp;
LaborAllocApp."Document No." := NewOrderNo;
[Link] := TRUE;
[Link](TRUE);
UNTIL [Link] = 0;
END;

PROCEDURE ClearAllocationEntry@1101908045(EntryNo@1101908000 :
Integer;TimeCompensateByMoveOtherAlloc@1000000000 : Boolean);
VAR
LaborAllocEntry@1101908001 : Record 25006271;
DoOneServiceMoving@1101908002 : Boolean;
BEGIN
[Link];
IF NOT [Link](EntryNo) THEN
EXIT;

IF TimeCompensateByMoveOtherAlloc THEN //15.04.2013 EDMS P8

 ReplanEntries(LaborAllocEntry."Resource No.", LaborAllocEntry."End Date-
Time",
-LaborAllocEntry."Quantity (Hours)",
ServiceScheduleSetup."Replan Document",
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;
[Link]("Applies-to Entry No.", 0); //14.03.2014 Elva
Baltic P8 #S0003 MMG7.00
[Link] := [Link]::Pending;
LaborAllocEntry."Reason Code" := '';
[Link];
END;

PROCEDURE ControlLaborSequence@1101908047(SourceSubtype@1101908000 :
'Quote,Order';SourceID@1101908001 : Code[20];LineNo@1101908003 :
Integer;StartingDateTime@1101908002 : Decimal) : Boolean;
VAR
LaborAllocEntryLoc@1101908005 : Record 25006271;
LaborAllocAppLoc@1101908004 : Record 25006277;
BEGIN
[Link];
IF NOT ServiceScheduleSetup."Control Labor Sequence" THEN
EXIT;
[Link];
[Link]("Document Type", SourceSubtype);
[Link]("Document No.", SourceID);
[Link]("Document Line No.", '<%1', LineNo);
IF [Link] THEN
REPEAT
IF [Link](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 [Link] = 0;

EXIT(TRUE);
END;

PROCEDURE ControlSkills@1101908048(SourceSubtype@1101908006 :
'Quote,Order';SourceID@1101908005 : Code[20];LineNo@1101908004 :
Integer;ResourceNo@1101908003 : Code[20]);
VAR
LaborAllocEntryLoc@1101908002 : Record 25006271;
LaborAllocAppLoc@1101908001 : Record 25006277;
ServiceLineLoc@1101908000 : Record 25006146;
ResourceSkill@1101908007 : Record 25006160;
LaborSkill@1101908008 : Record 25006161;
MissedSkills@1101908009 : Text[1000];
ResourceList@1190000 : Text[500];
BEGIN
 [Link];

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 [Link](SourceSubtype, SourceID, LineNo) THEN BEGIN

IF [Link] <> [Link]::Labor THEN
EXIT;

[Link];
[Link]("Labor Code", ServiceLineLoc."No.");
IF [Link] = 0 THEN
EXIT;

[Link];
[Link]("Resource No.", ResourceNo);
IF [Link] THEN
REPEAT
[Link]("Skill Code", LaborSkill."Skill Code");
IF NOT [Link] THEN BEGIN
IF MissedSkills <> '' THEN
MissedSkills += '; ';
MissedSkills += LaborSkill."Skill Code";
END;
UNTIL [Link] = 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;
ResourceSkill@1190004 : Record 25006160;
ResourceTemp@1190006 : TEMPORARY Record 156;
ResourceList@1190007 : Text[500];
ResourceAccepted@1190005 : Boolean;
i@1190008 : Integer;
BEGIN
 [Link];
[Link];
ResourceList := '';
[Link];
[Link]("Resource No.", ResourceNo);
IF [Link] THEN
REPEAT
[Link];
[Link]("Group Code",
ScheduleResourceGroupSpec."Group Code");
[Link]("Resource No.", '<>%1', ResourceNo);
IF [Link] THEN
REPEAT
ResourceAccepted := TRUE;
[Link];
[Link]("Resource No.",
ScheduleResourceGroupSpec2."Resource No.");
IF [Link] THEN
REPEAT
[Link]("Skill Code", LaborSkill."Skill Code");
IF NOT [Link] THEN
ResourceAccepted := FALSE;
UNTIL [Link] = 0;
IF ResourceAccepted THEN BEGIN
[Link];
ResourceTemp."No." := ScheduleResourceGroupSpec2."Resource No.";
IF [Link] THEN;
END;
UNTIL [Link] = 0;
UNTIL [Link] = 0;

i := 0;
IF [Link] THEN
REPEAT
IF ResourceList <> '' THEN
ResourceList += ';';
ResourceList += ResourceTemp."No.";
i += 1;
UNTIL ([Link] = 0) OR (i = 5);

EXIT(ResourceList);
END;

PROCEDURE FromQuoteToOrder@1101908049(ServiceLine@1101908000 : Record

25006146;NewServiceNo@1101908003 : Code[20]);
VAR
LaborAllocEntryLoc@1101908002 : Record 25006271;
LaborAllocAppLoc@1101908001 : Record 25006277;
LaborAllocAppLocTemp@1101908004 : TEMPORARY Record 25006277;
BEGIN
[Link];
[Link]("Document Type", ServiceLine."Document Type");
[Link]("Document No.", ServiceLine."Document No.");
[Link]("Document Line No.", ServiceLine."Line No.");
IF [Link] THEN
REPEAT
LaborAllocAppLocTemp := LaborAllocAppLoc;
LaborAllocAppLocTemp."Document Type" := LaborAllocAppLocTemp."Document
Type"::Order;
 LaborAllocAppLocTemp."Document No." := NewServiceNo;
[Link];
IF [Link](LaborAllocAppLoc."Allocation Entry No.") THEN
BEGIN
LaborAllocEntryLoc."Source Subtype" := LaborAllocEntryLoc."Source
Subtype"::Order;
LaborAllocEntryLoc."Source ID" := NewServiceNo;
[Link];
END;
UNTIL [Link] = 0
ELSE
EXIT;

[Link];
[Link]("Document Type", ServiceLine."Document Type");
[Link]("Document No.", ServiceLine."Document No.");
[Link]("Document Line No.", ServiceLine."Line No.");
[Link];

IF [Link] THEN
REPEAT
LaborAllocAppLoc := LaborAllocAppLocTemp;
[Link](TRUE);
UNTIL [Link] = 0;
END;

PROCEDURE CheckRemainingLinkedAllocation@1101908050(EntryNo@1101908000 :
Integer) RetValue : Decimal;
VAR
LaborAllocEntryLoc@1101908002 : Record 25006271;
LaborAllocAppLoc@1101908001 : Record 25006277;
LaborAllocEntryTemp@1101908004 : TEMPORARY Record 25006271;
BEGIN
//Possibly bug inside function.
//RetValue - returns deleted hours
FindSplitEntries(EntryNo, LaborAllocEntryTemp, 0, 1111);
[Link];
[Link]("Resource No.", "End Date-Time");
[Link](Status, '%1|%2|%3',
[Link]::Pending, [Link]::"On Hold",
[Link]::"In Progress");

IF [Link] THEN BEGIN

REPEAT
RetValue += LaborAllocEntryTemp."Quantity (Hours)";
DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp,
LaborAllocEntryTemp."Entry No.", 11111);
UNTIL [Link] = 0;
END;
EXIT(RetValue);
END;

PROCEDURE CheckLaborStatus@1101908056(LaborAllocEntryLoc@1101908000 : Record

25006271) : Boolean;
VAR
StatusFinishProgress@1101908001 : Integer;
StatusPendingHold@1101908002 : Integer;
BEGIN
StatusFinishProgress := 0;
 StatusPendingHold := 0;
[Link];
IF [Link] THEN
REPEAT
IF [Link] IN [[Link]::Pending,
[Link]::"On Hold"] THEN
StatusPendingHold +=1;
IF [Link] IN [[Link]::Finished,
[Link]::"In Progress"] THEN
StatusFinishProgress +=1;
UNTIL [Link] = 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
LaborAllocEntryLoc@1101908000 : Record 25006271;
LaborAllocEntryLoc2@1101908009 : Record 25006271;
LaborAllocEntryTemp@1101908003 : TEMPORARY Record 25006271;
LaborAllocEntryTemp2@1101908004 : TEMPORARY Record 25006271;
LaborAllocEntryTemp3@1101908006 : TEMPORARY Record 25006271;
JoinLaborAllocEntryTemp@1101908005 : TEMPORARY Record 25006271;
AlreadyJoinLaborAllocEntryTemp@1101908007 : TEMPORARY Record 25006271;
LaborAllocAppLoc@1101908011 : Record 25006277;
JoinTotalHours@1101908008 : Decimal;
EndDateTime@1101908010 : Decimal;
BEGIN
[Link];
[Link];
[Link];
[Link];

[Link];
[Link]("Resource No.", "Start Date-Time");
[Link]("Resource No.", ResourceNo);
[Link]("Start Date-Time", '>=%1', StartingDateTime);
//21.07.2015 EB.P7 #Performance issue >>
IF [Link] <> 0 THEN
[Link]("Entry No.",
[Link]);
//21.07.2015 EB.P7 #Performance issue <<

IF [Link] THEN
REPEAT
IF NOT [Link](LaborAllocEntryLoc."Entry No.") THEN
BEGIN
[Link];
[Link];
[Link];
[Link];
FindSplitEntries(LaborAllocEntryLoc."Entry No.", LaborAllocEntryTemp,
0, 1111);
IF [Link] THEN
REPEAT
 IF NOT [Link](LaborAllocEntryTemp."Entry No.")
THEN BEGIN
LaborAllocEntryTemp2 := LaborAllocEntryTemp;
[Link];
END;
IF NOT [Link](LaborAllocEntryTemp."Entry No.")
THEN BEGIN
LaborAllocEntryTemp3 := LaborAllocEntryTemp;
[Link];
END;
UNTIL [Link] = 0;

[Link]("Resource No.", "Start Date-Time");

IF [Link] THEN
REPEAT
JoinTotalHours := 0;
IF NOT [Link](LaborAllocEntryTemp."Entry
No.") THEN BEGIN
[Link];
[Link];
JoinLaborAllocEntryTemp := LaborAllocEntryTemp;
[Link];

FindJoinEntries(JoinLaborAllocEntryTemp."End Date-Time",
LaborAllocEntryTemp3, JoinLaborAllocEntryTemp);
EndDateTime := 0;
IF [Link] THEN
REPEAT
IF NOT
[Link](JoinLaborAllocEntryTemp."Entry No.") THEN BEGIN
AlreadyJoinLaborAllocEntryTemp := JoinLaborAllocEntryTemp;
[Link];
END;
JoinTotalHours += JoinLaborAllocEntryTemp."Quantity (Hours)";
IF JoinLaborAllocEntryTemp."End Date-Time" > EndDateTime THEN
EndDateTime := JoinLaborAllocEntryTemp."End Date-Time";
UNTIL [Link] = 0;

[Link];
IF [Link] > 1 THEN BEGIN
[Link](LaborAllocEntryTemp."Entry No.");
LaborAllocEntryLoc2."End Date-Time" := EndDateTime;
LaborAllocEntryLoc2."Quantity (Hours)" := (EndDateTime -
LaborAllocEntryLoc2."Start Date-Time") / 3.6;
[Link];
IF [Link] THEN
REPEAT
IF JoinLaborAllocEntryTemp."Entry No." <>
LaborAllocEntryTemp."Entry No." THEN BEGIN

IF [Link](JoinLaborAllocEntryTemp."Entry
No.") THEN;
ChangeApplyTo(LaborAllocEntryLoc2."Entry No.",
LaborAllocEntryLoc2."Applies-to Entry No.");
[Link];

[Link];
[Link]("Allocation Entry No.",
JoinLaborAllocEntryTemp."Entry No.");
 [Link](TRUE);

END;
UNTIL [Link] = 0;
END;
END;
UNTIL [Link] = 0;
END;
UNTIL [Link] = 0;
END;

PROCEDURE FindJoinEntries@1101908053(StartingDateTime@1101908000 : Decimal;VAR

LaborAllocEntryLoc@1101908001 : Record 25006271;VAR
JoinLaborAllocEntry@1101908002 : Record 25006271);
BEGIN
IF [Link] THEN;
[Link]("Resource No.", "Start Date-Time");
[Link]("Start Date-Time", StartingDateTime);
[Link](Status, [Link]);

IF [Link] THEN
REPEAT
IF NOT [Link](LaborAllocEntryLoc."Entry No.") THEN BEGIN
[Link];
JoinLaborAllocEntry := LaborAllocEntryLoc;
[Link];
FindJoinEntries(LaborAllocEntryLoc."End Date-Time", LaborAllocEntryLoc,
JoinLaborAllocEntry);
END;
UNTIL [Link] = 0;
END;

PROCEDURE CheckUserRightsInit@1101901001();
BEGIN
CLEAR(isOperAllowedChecked);
CLEAR(OperationMainCode);
CLEAR(OperAllowed);
CLEAR(LaborAllocationEntryPrevTmp);
[Link];
LaborAllocEntryPrevStatus := -1;
END;

PROCEDURE CheckUserRights@1101908054(WhatAllow@1101908000 :
'View,Time,Planning,All') : Boolean;
BEGIN
IF [Link](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:
IF UserSetup."Allow Use Service Schedule" IN [UserSetup."Allow Use
Service Schedule"::" ",
UserSetup."Allow Use
Service Schedule"::"View Only"] THEN BEGIN
ErrorWithRefresh(Text128);
 EXIT(FALSE);
END;
WhatAllow::Planning:
IF UserSetup."Allow Use Service Schedule" IN [UserSetup."Allow Use
Service Schedule"::" ",
UserSetup."Allow Use
Service Schedule"::"View Only",
UserSetup."Allow Use
Service Schedule"::"Time Registration"] THEN BEGIN
IF [Link] THEN
EXIT(TRUE);

ErrorWithRefresh(Text128);
EXIT(FALSE);
END;
WhatAllow::All:
IF UserSetup."Allow Use Service Schedule" IN [UserSetup."Allow Use
Service Schedule"::" ",
UserSetup."Allow Use
Service Schedule"::"View Only",
UserSetup."Allow Use
Service Schedule"::"Time Registration",
UserSetup."Allow Use
Service Schedule"::Planning]
THEN
EXIT(FALSE);
END;
END ELSE BEGIN
ErrorWithRefresh(Text128);
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 = [Link]) THEN
EXIT(OperAllowed);
OperationMainCode := Operation;
OperAllowed := FALSE;
isOperAllowedChecked := TRUE;
[Link](LaborAllocationEntryPar);
LaborAllocEntryPrevStatus := [Link];
 WITH LaborAllocationEntryPar DO BEGIN
CASE Operation OF
0:
OperAllowed := CheckUserRights(0);
1:
OperAllowed := CheckUserRights(1);
2: BEGIN
OperAllowed := CheckUserRights(2);
END;
3: BEGIN
OperAllowed := CheckUserRights(3);
END;
4: BEGIN
IF "Source Type" <> "Source Type"::"Service Document" THEN
ERROR(Text108);
IF Status <> Status::"In Progress" THEN
ERROR(Text111);
OperAllowed := CheckUserRights(1);
END;
100: BEGIN
[Link];
IF ServiceScheduleSetup."Serv. Document Alloc. Method" =
ServiceScheduleSetup."Serv. Document Alloc. Method"::Header THEN
ERROR(Text142);
OperAllowed := CheckUserRights(2);
END;
110: BEGIN
[Link];
IF ServiceScheduleSetup."Serv. Document Alloc. Method" =
ServiceScheduleSetup."Serv. Document Alloc. Method"::Line THEN
ERROR(Text142);
OperAllowed := CheckUserRights(2);
END;
120: BEGIN
OperAllowed := CheckUserRights(2);
END;
200: BEGIN
IF NOT ((Status = Status::Pending) OR
(Status = Status::"On Hold"))
THEN
ERROR(STRSUBSTNO(Text123, Status));

[Link];
[Link]("Allocation Entry No.", "Entry No.");
[Link]("Document Line No.", 0);
IF [Link] THEN
ERROR(Text134);
OperAllowed := CheckUserRights(2);
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;
OperAllowed := CheckUserRights(3);
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
ErrorWithRefresh(Text138);
OperAllowed := CheckUserRights(3);
END;
400: BEGIN
OperAllowed := CheckUserRights(2);
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 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
Order';DocumentNo@1101908002 : Code[20]);
BEGIN
[Link]("Document Type", DocumentType);
[Link]("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
[Link]("Source Type", LaborAllocLoc."Source Type"::"Service
Document");
[Link]("Source Subtype", DocumentType);
[Link]("Source ID", DocumentNo);
END;

PROCEDURE CheckForCorrectServHeaderLine@1101908057(ServiceHdr@1101908000 :
Record 25006145;VAR ServiceLine@1101908001 : Record
25006146;WhatAllocate@1101908004 : 'Header,Line');
VAR
LaborAllocEntryLoc@1101908003 : Record 25006271;
LaborAllocAppLoc@1101908002 : Record 25006277;
DocumentNo@1101908005 : Code[20];
BEGIN
// CASE WhatAllocate OF
// WhatAllocate::Header:
// BEGIN
// [Link];
// [Link]("Source Subtype", ServiceHdr."Document
Type");
// [Link]("Source ID", ServiceHdr."No.");
// IF [Link] THEN
 // IF GUIALLOWED THEN
// IF NOT CONFIRM(STRSUBSTNO(Text131, ServiceHdr."Document Type",
ServiceHdr."No.")) THEN
// ERROR(Text150);
// END;
// WhatAllocate::Line:
// BEGIN
// IF [Link] THEN BEGIN
// DocumentNo := ServiceLine."Document No.";
// REPEAT
// IF DocumentNo <> ServiceLine."Document No." THEN
// ERROR(Text133);
// UNTIL [Link] = 0;
// END;
// [Link];
// [Link]("Source Subtype", ServiceLine."Document
Type"); //12.12.2014 EB.P8
// [Link]("Source ID", ServiceLine."Document No.");
// IF [Link] 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
ServiceHour@1101908003 : Record 25006129;
ResourceCalendarChange@1101908002 : Record 25006279;
BEGIN
IF [Link](ResourceNo, CheckDate) THEN BEGIN
IF ResourceCalendarChange."Change Type" = ResourceCalendarChange."Change
Type"::Nonworking THEN
EXIT(FALSE)
ELSE
EXIT(TRUE);
END;

[Link];
[Link]("Starting Date", '''''|<=%1', CheckDate);
[Link]("Ending Date", '''''|>=%1', CheckDate);
[Link](Day, DATE2DWY(CheckDate, 1) - 1);
IF NOT [Link] THEN
EXIT(FALSE);

EXIT(TRUE);
END;

PROCEDURE GetResourceWorkplace@1101908059(ResourceNo@1101908001 :
Code[20];CheckDate@1101908000 : Date) : Code[10];
VAR
WorkplaceResource@1101908002 : Record 25006285;
BEGIN
[Link];
[Link]("Resource No.", ResourceNo);
[Link]("Starting Date", '''''|<=%1', CheckDate);
 [Link]("Ending Date", '''''|>=%1', CheckDate);
IF [Link] THEN
EXIT(WorkplaceResource."Workplace Code")
ELSE
EXIT('');
END;

PROCEDURE GetResourceSkills@1190028(ResourceNo@1101908001 : Code[20];VAR

ResourceSkill@1101908000 : Record 25006160) : Code[10];
VAR
WorkplaceResource@1101908002 : Record 25006285;
BEGIN
[Link];
[Link]("Resource No.", ResourceNo);
END;

PROCEDURE GetResourceShift@1190029(ResourceNo@1101908001 : Code[20]) :

Code[10];
VAR
Resource@1101908002 : Record 156;
BEGIN
IF [Link](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
WorkplaceResource@1190003 : Record 25006285;
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
WorkplaceResource@1190003 : Record 25006285;
Workplace@1190004 : Record 25006284;
codex@1190002 : Code[10];
textx@1190005 : Text[30];
BEGIN
IF [Link] THEN
 REPEAT
[Link]("Resource No.", [Link]);
IF CurrDate <> 0D THEN BEGIN
[Link]("Starting Date", '''''|<=%1', CurrDate);
[Link]("Ending Date", '''''|>=%1', CurrDate);
END;

IF [Link] THEN BEGIN

ResourceCodeBuffer."Code 2" := WorkplaceResource."Workplace Code";
ResourceCodeBuffer."Applies-to Code" := WorkplaceResource."Workplace
Code";
[Link];
[Link](WorkplaceResource."Workplace Code");
[Link](TRUE);
END;
UNTIL [Link] = 0;

[Link](TRUE);
IF [Link] THEN
REPEAT
[Link];
[Link] := [Link];
[Link] := [Link];
ResourceCodeBuffer."Code 2" := [Link];
ResourceCodeBuffer."Show in Bold" := TRUE;
[Link] := TRUE;
[Link];
UNTIL [Link] = 0;
END;

PROCEDURE GroupResourceBySkills@1190030(VAR ResourceCodeBuffer@1190001 : Record

25006270;CurrDate@1190000 : Date);
VAR
ResourceSkill@1190002 : Record 25006160;
Skill@1190003 : Record 25006159;
BEGIN
IF [Link] THEN
REPEAT
ResourceCodeBuffer."Applies-to Code" := ResourceCodeBuffer."Code 2";
[Link];
[Link]("Resource No.", [Link]);
IF [Link] THEN
REPEAT
IF [Link](ResourceSkill."Skill Code")THEN
[Link](TRUE);
UNTIL [Link] = 0;
UNTIL [Link] = 0;

[Link](TRUE);
IF [Link] THEN
REPEAT
[Link];
[Link] := [Link];
[Link] := [Link];
ResourceCodeBuffer."Code 2" := [Link];
ResourceCodeBuffer."Show in Bold" := TRUE;
[Link] := TRUE;
 [Link];
UNTIL [Link] = 0;
END;

PROCEDURE GroupResourceByShifts@1190031(VAR ResourceCodeBuffer@1190001 : Record

25006270;CurrDate@1190000 : Date);
VAR
Resource@1190002 : Record 156;
Shift@1190003 : Record 25006151;
BEGIN
IF [Link] THEN
REPEAT
IF [Link]([Link]) THEN BEGIN
ResourceCodeBuffer."Code 2" := Resource."Service Work Group Code";
ResourceCodeBuffer."Applies-to Code" := Resource."Service Work Group
Code";
[Link];
IF [Link](Resource."Service Work Group Code") THEN
[Link](TRUE);
END;
UNTIL [Link] = 0;

[Link](TRUE);
IF [Link] THEN
REPEAT
[Link];
[Link] := [Link];
[Link] := [Link];
ResourceCodeBuffer."Code 2" := [Link];
ResourceCodeBuffer."Show in Bold" := TRUE;
[Link] := TRUE;
[Link];
UNTIL [Link] = 0;
END;

PROCEDURE ChangePlanningPolicy@1190023(ServiceHdr@1190000 : Record 25006145);

BEGIN
[Link];
[Link]("Source Type", LaborAllocEntry."Source
Type"::"Service Document");
[Link]("Source Subtype", ServiceHdr."Document Type");
[Link]("Source ID", ServiceHdr."No.");
IF [Link] THEN
REPEAT
LaborAllocEntry."Planning Policy" := ServiceHdr."Planning Policy";
[Link];
UNTIL [Link] = 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
[Link];
[Link]("Document Type", DocType);
 [Link]("Document No.", DocNo);
[Link]("Document Line No.", LineNo);
IF [Link] THEN BEGIN
//2012.03.19 EDMS P8 >>
[Link]("Resource No.", ResourceNo);
IF NOT [Link] THEN BEGIN
IF ReturnType = ReturnType::Error THEN
ERROR(Text136)
// ERROR(TextLoc, [Link])
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
IF NOT CheckUserRightsAdv(310, LaborAllocEntry) THEN EXIT;

CLEAR(ChangeAllocationForm);
[Link](LaborAllocEntry);
[Link](TRUE); //03.04.2013 P8
COMMIT; //28.06.2013 EDMS P8
[Link];
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
ServiceHour@1190003 : Record 25006129;
ResCalendarChange@1190004 : Record 25006279;
Date@1190005 : Record 2000000007;
Resource@1190009 : Record 156;
CurrDate@1190006 : Date;
CurrStartTime@1190008 : Time;
CurrEndTime@1190010 : Time;
CurrEndTime2@1190011 : Time;
Capacity@1190007 : Decimal;
BEGIN
IF NOT [Link](ResourceNo) THEN
EXIT(0);
Capacity := 0;
CurrDate := DateTimeMgt.Datetime2Date(StartingDateTime);
CurrStartTime := DateTimeMgt.Datetime2Time(StartingDateTime);
REPEAT
 CurrEndTime := DateTimeMgt.Datetime2Time(EndingDateTime);
IF [Link](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
[Link];
[Link]("Period Start", CurrDate);
IF [Link] THEN BEGIN
[Link];
[Link]("Service Work Group Code", Resource."Service Work
Group Code");
[Link]("Starting Date", '<=%1|%2', CurrDate, 0D);
[Link]("Ending Date", '>=%1|%2', CurrDate, 0D);
[Link](Day, Date."Period No." - 1);
IF [Link] THEN BEGIN
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);
UNTIL [Link] = 0;
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
IF [Link] THEN
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 [Link] = 0;

EXIT(NotAvailable);
END;

PROCEDURE ShowServiceAllocation@1190034(SourceID@1190000 : Code[20]);

VAR
ServLaborAllocation@1190001 : Record 25006271;
BEGIN
[Link];
[Link]("Source Type", "Source Subtype", "Source
ID");
[Link]("Source Type", ServLaborAllocation."Source
Type"::"Service Document");
[Link]("Source ID", SourceID);
IF [Link] = 0 THEN
MESSAGE(Text140)
ELSE
[Link](PAGE::"Service Labor List", ServLaborAllocation);
END;

PROCEDURE CheckStartAndPlan@1190038(EntryNo@1190000 : Integer);

VAR
LaborAllocEntryLoc@1190001 : Record 25006271;
LaborAllocEntry@1190002 : Record 25006271;
LaborAllocEntryTemp@1190005 : TEMPORARY Record 25006271;
WorkTimeEntry@1190003 : Record 25006276;
CurrDateTime@1190004 : Decimal;
BEGIN
[Link](EntryNo);
CurrDateTime := [Link](WORKDATE, TIME);

[Link];
[Link]("Resource No.",Closed);
[Link]("Resource No.",LaborAllocEntry."Resource No.");
[Link](Closed,FALSE);
IF NOT [Link] THEN
ERROR(STRSUBSTNO(Text107, LaborAllocEntry."Resource No."));

[Link](LaborAllocEntry."Resource No.");
IF NOT Resource."Allow Simultaneous Work" THEN BEGIN //17.10.2013 EDMS P8
[Link];
[Link]("Source Type", Status, "Resource No.");
[Link](Status, [Link]::"In
Progress");
[Link]("Resource No.", LaborAllocEntry."Resource
No.");
IF [Link] THEN
ERROR(Text135);
END;

IF IsTimeAvailable(LaborAllocEntryTemp, LaborAllocEntry."Resource No.",

WORKDATE, 0) THEN BEGIN
[Link];
IF [Link] THEN
REPEAT
IF (LaborAllocEntryTemp."Start Date-Time" <= CurrDateTime) AND
(LaborAllocEntryTemp."End Date-Time" >= CurrDateTime)
 THEN
ERROR(Text113);
UNTIL [Link] = 0
ELSE
ERROR(Text113);
END ELSE
ERROR(Text113);
END;

PROCEDURE DoNotChangeServStatus@1190042();
BEGIN
DontChangeServiceStatus := TRUE;
END;

PROCEDURE LookupAllocationRTC@1101904000(EntryNo@1101904001 : Integer);

VAR
LaborAllocEntry@1101904000 : Record 25006271;
ServiceHeader@1101904002 : Record 25006145;
PostedServOrder@1101904003 : Record 25006149;
BEGIN
IF NOT [Link](EntryNo) THEN EXIT;

IF LaborAllocEntry."Source Type" <> LaborAllocEntry."Source Type"::"Service

Document" THEN
EXIT;

IF [Link](LaborAllocEntry."Source Subtype",LaborAllocEntry."Source
ID") THEN BEGIN
CASE ServiceHeader."Document Type" OF
ServiceHeader."Document Type"::Quote: [Link](PAGE::"Service Quote
EDMS", ServiceHeader);
ServiceHeader."Document Type"::Order: [Link](PAGE::"Service Order
EDMS", ServiceHeader);
END;
END ELSE BEGIN
IF [Link](LaborAllocEntry."Source ID") THEN
[Link](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;

[Link];
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.
IF RoundMs > 0 THEN BEGIN
// 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 := [Link](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
ServiceHour@1101908009 : Record 25006129;
ResCalendarChange@1101908008 : Record 25006279;
ServLaborAlloc2@1101908010 : Record 25006271;
ApplicationEntry@1101908011 : TEMPORARY Record 25006277;
ResourceLoc@1190000 : Record 156;
CheckDescription@1101908007 : Text[50];
Starting@1101908006 : Decimal;
Finishing@1101908005 : Decimal;
QtyToAllocate@1101908012 : Decimal;
EntryNo@1101908004 : Integer;
DoChangeServLineResource@1101908015 : Boolean;
Text001@1101904000 : TextConst 'ENU=Unavailability';
ResWorkTimeChange@1101904001 : Boolean;
PrevRecStartTime@1101904002 : Time;
PrevRecEndTime@1101904003 : Time;
BEGIN
[Link];
DoChangeServLineResource := FALSE;
ResWorkTimeChange := FALSE;

//check for busy time in Base Calendar and in Resource Calendar Change >>
IF [Link](ResourceNo, TargetDate) THEN BEGIN
CASE ResCalendarChange."Change Type"::"Work Time Change" OF
ResCalendarChange."Change Type"::Nonworking: BEGIN
QtyToAllocate := CalcHourDifference([Link](TargetDate,
000000T),
 [Link](TargetDate,
235959.999T));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate, 000000T), QtyToAllocate,
0, 0, Text001, 0,
DoChangeServLineResource,[Link]);
END;

ResCalendarChange."Change Type"::"Work Time Change": BEGIN

ResWorkTimeChange := TRUE;
IF ResCalendarChange."Starting Time" > 0T THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](TargetDate,
000000T),
[Link](TargetDate,
ResCalendarChange."Starting Time"));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate, 000000T), QtyToAllocate,
0, 0, Text001, 0,
DoChangeServLineResource,[Link]);
END;

IF ResCalendarChange."Ending Time" < 235959.999T THEN BEGIN

QtyToAllocate := CalcHourDifference([Link](TargetDate,
ResCalendarChange."Ending Time"),
[Link](TargetDate,
235959.999T));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate,
ResCalendarChange."Ending Time"), QtyToAllocate, 0, 0, Text001,0,
DoChangeServLineResource,[Link]);
END;
END;
END;
END;

//write busy time from Service Hour EDMS >>

IF NOT ResWorkTimeChange THEN BEGIN
[Link];
//AB >>
IF([Link](ResourceNo)) THEN BEGIN
//[Link](ResourceNo);
[Link]("Service Work Group Code", ResourceLoc."Service Work
Group Code");
[Link]("Starting Date", '''''|<=%1', TargetDate);
[Link]("Ending Date", '''''|>=%1', TargetDate);
[Link](Day, DATE2DWY(TargetDate, 1) - 1);

//18.01.2012 EDMS P8 >>

IF [Link] THEN BEGIN
PrevRecStartTime := 0T;
PrevRecEndTime := 0T;
REPEAT
IF ServiceHour."Starting Time" > 0T THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](TargetDate,
PrevRecEndTime),
[Link](TargetDate,
ServiceHour."Starting Time"));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate, PrevRecEndTime),
 QtyToAllocate, 0, 0, Text001, 0,
DoChangeServLineResource,[Link]);
END;

PrevRecStartTime := ServiceHour."Starting Time";

PrevRecEndTime := ServiceHour."Ending Time";
UNTIL [Link] = 0;
IF ServiceHour."Ending Time" < 235959.999T THEN BEGIN
QtyToAllocate := CalcHourDifference([Link](TargetDate,
ServiceHour."Ending Time"),
[Link](TargetDate,
235959.999T));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate,
ServiceHour."Ending Time"), QtyToAllocate, 0, 0, Text001, 0,
DoChangeServLineResource,[Link]);
END;
//18.01.2012 EDMS P8 <<
END ELSE BEGIN
QtyToAllocate := CalcHourDifference([Link](TargetDate,
000000T),
[Link](TargetDate,
235959.999T));
InsertAllocationEntry(AllocEntry, ApplicationEntry, ResourceNo,
[Link](TargetDate, 000000T), QtyToAllocate,
0, 0, Text001, 0,
DoChangeServLineResource,[Link]);
END;
END;
//AB <<
END;
END;

PROCEDURE DateTimeRound@1101904008(DateTime@1101904000 :
Decimal;RoundMs@1101904001 : Integer) : Decimal;
VAR
AdjustedTime@1101904002 : Time;
BEGIN
IF RoundMs > 0 THEN BEGIN
AdjustedTime := 000001T - 1000 + RoundMs;
EXIT(ROUND(DateTime, [Link](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 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
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;
[Link];
[Link]("Document Type", DocumentType);
[Link]("Document No.", DocumentNo);
[Link](Type, [Link]::Labor);
FillServiceLine(ServiceLineLocal);
IF [Link] THEN BEGIN
Resources := GetRelatedResources(DocumentType, DocumentNo,
[Link]::Labor, ServiceLineLocal."Line No.", 0);
REPEAT
SetRelatedResources(DocumentType, DocumentNo,
[Link]::Labor, ServiceLineLocal."Line No.",
Resources, 11);
UNTIL [Link] = 0;
END;
END;

PROCEDURE CheckDocAllocResource@1101904004(DocType@1101904003 :
Integer;DocNo@1101904002 : Code[20];LineType@1101904001 : Integer;LineNo@1101904000
: Integer;ReturnType@1190001 : 'Error,Boolean';ResourceNo@1190002 : Code[20]) :
Boolean;
BEGIN
// P8
[Link];
[Link]("Document Type", DocType);
[Link]("Document No.", DocNo);
[Link]("Document Line No.", 0);
IF [Link] THEN BEGIN
//2012.03.19 EDMS P8 >>
[Link]("Resource No.", ResourceNo);
IF NOT [Link] THEN BEGIN
IF ReturnType = ReturnType::Error THEN
ERROR(Text136)
ELSE
EXIT(FALSE);
END ELSE
EXIT(FALSE);
END;
EXIT(TRUE) ;
END;

PROCEDURE GetDocAllocResource@1101904006(DocumentType@1101904001 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
Order';DocumentNo@1101904000 : Code[20]) ResourceNo : Code[20];
BEGIN
// old version, look at GetDocAllocResources
[Link];
[Link]("Document Type", DocumentType);
[Link]("Document No.", DocumentNo);
[Link]("Document Line No.", 0);
IF [Link] THEN
IF (LaborAllocApp."Resource No." <> '') THEN
ResourceNo := LaborAllocApp."Resource No.";
EXIT(ResourceNo);
END;
 PROCEDURE GetDocAllocResources@1101904020(DocumentType@1101904001 :
'Quote,Order,Invoice,Credit Memo,Blanket Order,Return
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);
SETRANGE("Document Line No.", 0);
IF FINDFIRST THEN BEGIN
REPEAT
[Link]("Resource No.", "Resource No.");
IF NOT [Link] THEN BEGIN
ResourceNos += "Resource No."+',';
ServLaborApplicationTmp := LaborAllocApp;
[Link];
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;
ServLaborAllocEntryTmp@1101904024 : TEMPORARY 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;
OldHours@1101904016 : Decimal;
NewQuantity@1101904015 : Decimal;
NewHours@1101904014 : Decimal;
NewLineNo@1101904013 : Integer;
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;
ResourceNo@1101904034 : Code[20];
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
[Link] > 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));
IF STRLEN(ParamStr)>1 THEN
EVALUATE(doAvoidSrcLineQtyChange, COPYSTR(ParamStr,2,1));
IF STRLEN(ParamStr)>2 THEN
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 [Link] THEN BEGIN
REPEAT
[Link];
[Link]("Allocation Entry No.",
ServLaborAllocEntryTmp."Entry No.");
IF [Link] THEN
IF (AllocAppEntry."Remaining Quantity (Hours)" > 0) THEN
ERROR(TextLoc001);
UNTIL [Link] = 0;
END;
END;
UNTIL NEXT = 0;
FINDFIRST;
END;

//At first fix source allocation

//before run it do check: is it a real record?
[Link](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 [Link](ServLaborAllocEntryPar."Source Subtype",
ServLaborAllocEntryPar."Source ID",
LineNoSource) THEN BEGIN
[Link](QtySource, TRUE, TRUE);
[Link];
END;
IF FinishedQty = 0 THEN
ProcessMovement("Entry No.", "Resource No.", "Start Date-Time",
QtySource, 1, [Link], -1,[Link])
ELSE BEGIN
ProcessMovement("Entry No.", "Resource No.", "Start Date-Time",
QtySource, 1, [Link], -1,[Link]);
END;
END;
END;
END;
END;

//add "Service Line EDMS" for destination

WITH ServLineDestPar DO BEGIN
IF DoCreateServLine THEN BEGIN
 [Link](ServLaborAllocEntryPar."Source Subtype",
ServLaborAllocEntryPar."Source ID",
AllocAppEntrySource."Document Line No.");
ServLineDestPar := ServLineSource;
NewLineNo := NewLineNo + 1;
"Line No." := NewLineNo;
INSERT;

// [Link](ServLineSource, NewLineNo);//30.10.2012
EDMS

END;
IF NOT doAvoidDestLineQtyChange THEN BEGIN
IF ShareQtyDest <> 100 THEN BEGIN
VALIDATE("Standard Time", "Standard Time" * ShareQtyDest/100);
[Link](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 <= [Link](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 [Link] = [Link]::Pending
THEN
AllocTimeQty := [Link]
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,
[Link]);
IF [Link] > 1 THEN BEGIN
[Link]; // it should be second line
REPEAT
[Link];
CreateAppEntry(NewAllocEntryNo, ServLineDestPar."Document Type",
ServLineDestPar."Document No.",
ServLineDestPar."Line No.", ResourceNo, 0, 0, FALSE);
UNTIL [Link] = 0;
END;
ProcessMovement(NewAllocEntryNo, ResourceNo, DateStart, AllocTimeQty, 1,
[Link], -1,[Link]);
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;
ServiceLine@1101904000 : Record 25006146;
ServLaborAllocationEntry@1101904006 : Record 25006271;
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 FINDFIRST THEN BEGIN
IF [Link](EntryNo) THEN
MainAllocQty := ServLaborAllocationEntry."Quantity (Hours)"
ELSE
MainAllocQty := 0;
[Link](DocType, DocNo, LineNo);
MainLineQty := [Link];
IF COUNT > 1 THEN BEGIN
REPEAT
IF [Link](DocType, DocNo, "Document Line No.") THEN
QtyTotalOfApp += [Link];
UNTIL NEXT = 0;
ShareOfLine := QtyTotalOfApp/MainLineQty;
END;
END;
END;
EXIT(ShareOfLine*100);
END;

PROCEDURE GetEntryEndingTimeFull@1101904018(EntryNo@1101904001 : Integer) :

Decimal;
VAR
ServLaborAllocEntryTmp@1101904000 : TEMPORARY Record 25006271;
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;
EntryNo@1190003 : Integer;
BEGIN
//returns new allocation entry no
[Link];
[Link];
EntryNo := NewServLaborAllocEntry."Entry No." + 1;

[Link];
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;
[Link] := Status;
NewServLaborAllocEntry."Reason Code" := ReasonCode;
NewServLaborAllocEntry."Planning Policy" := PlanningPolicy;
[Link];

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
[Link];
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;
[Link](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.");
IF NOT FINDFIRST THEN
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);
[Link];
[Link]("Allocation Entry No.", "Entry No.");
IF [Link] 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;
[Link];
END;
END ELSE BEGIN
IF AllocAppEntry."Finished Quantity (Hours)" > 0 THEN BEGIN
AllocAppEntry."Finished Quantity (Hours)" := AllocAppEntry."Finished
Quantity (Hours)" * ShareQty/100;
END;
[Link];
END;
END;
END;
END;

PROCEDURE LookupResourceToAllocEntry@1101904011(AllocEntryNo@1190004 :
Code[20]);
VAR
ResourceList@1190000 : Page 77;
ServLaborAllocationEntry@1190001 : Record 25006271;
Resource@1190006 : Record 156;
NewLineNo@1190005 : Integer;
BEGIN
IF NOT CheckUserRightsAdv(2, LaborAllocEntry)THEN EXIT;

CLEAR(ResourceList);

[Link](TRUE);

IF [Link] = ACTION::LookupOK THEN BEGIN

[Link](Resource);

IF [Link] THEN BEGIN

IF [Link](AllocEntryNo) THEN
REPEAT
AddResourceToAllocEntry(ServLaborAllocationEntry, LaborAllocApp,
Resource."No.", 0, LaborAllocEntry, LaborAllocApp);
UNTIL [Link] = 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.';
EntryNo@1101904005 : Integer;
LaborAllocEntryL@1101904007 : Record 25006271;
BEGIN
// actually it is not adding to allocation entry, but creating new entry with
same pars and different resource
 [Link]("Resource No.");
[Link]("Allocation Entry No.",
ServLaborAllocationEntry."Entry No.");
IF NOT [Link] THEN
ERROR(TextNotLineFound);

[Link];
[Link];
EntryNo := LaborAllocEntryL."Entry No." + 1;

[Link];
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;
[Link] := [Link];
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;
[Link];

//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
ServLaborAllocApplication@1101904001 : Record 25006277;
ServLaborAllocApplicationTemp@1101904002 : TEMPORARY Record 25006277;
BEGIN
IF NOT [Link] THEN
EXIT;
[Link];
 [Link];
[Link]("Document Type", ServiceLine."Document
Type");
[Link]("Document No.", ServiceLine."Document
No.");
[Link]("Document Line No.", ServiceLine."Line
No.");
IF [Link] THEN
REPEAT
ServLaborAllocApplicationTemp := ServLaborAllocApplication;
[Link];
UNTIL [Link] = 0;
[Link](0, ServLaborAllocApplicationTemp);
END;

PROCEDURE GetMainAllocEntrNo@1101904024(EntryNo@1101904000 :
Integer;RunModeFlags@1101904002 : Integer) RetEntryNo : Integer;
VAR
LaborAllocEntryL@1101904001 : Record 25006271;
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 [Link](EntryNo) THEN BEGIN
REPEAT
[Link](EntryNo);
IF IsIntInArrayTen([Link], 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;
StatusArray@1101904001 : ARRAY [10] OF Integer;
BEGIN
// RunModeFlags = 1011, that statuses are taken in account, readen from right
to left (On Hold,Finished,In Progress,Pending)
[Link](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 [Link] OF
0: RunModeFlags := 1;
1: RunModeFlags := 10;
2: RunModeFlags := 100;
3: RunModeFlags := 1000;
END;
END;
AdjustFlagsToArray(RunModeFlags, StatusArray);
 IF EntryType <> EntryType::Previous THEN BEGIN
IF NOT [Link](LaborAllocEntryCurr."Entry No.") THEN BEGIN
IF IsIntInArrayTen([Link], StatusArray) THEN BEGIN
LaborAllocEntryPar := LaborAllocEntryCurr;
[Link];
END;
END;
[Link];
[Link]("Applies-to Entry No.", EntryNo);
IF [Link] THEN
REPEAT
FindSplitEntries(LaborAllocEntryLookIn."Entry No.", LaborAllocEntryPar,
1, RunModeFlags); //12.08.2013 EDMS P8
UNTIL [Link] = 0;
END;

IF EntryType <> EntryType::Next THEN BEGIN

IF NOT [Link](LaborAllocEntryCurr."Entry No.") THEN BEGIN
IF IsIntInArrayTen([Link], StatusArray) THEN BEGIN
LaborAllocEntryPar := LaborAllocEntryCurr;
[Link];
END;
END;
IF LaborAllocEntryCurr."Applies-to Entry No." > 0 THEN
IF [Link](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
LaborAllocEntryL@1101904002 : Record 25006271;
StatusArray@1101904005 : 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);

// 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 [Link](EntryNo) THEN
IF LaborAllocEntry."Parent Alloc. Entry No." > 0 THEN BEGIN
FindRelatedEntries(LaborAllocEntry."Parent Alloc. Entry No.",
LaborAllocEntryTmp, TRUE, 1011);
EXIT([Link]);
END;
RESET;
DELETEALL;
END;
IF NOT [Link](EntryNo) THEN
EXIT;
IF NOT GET(EntryNo) THEN BEGIN
 IF IsIntInArrayTen([Link], StatusArray) THEN BEGIN
LaborAllocEntryTmp := LaborAllocEntry;
INSERT;
END;
END;
//FIND child part
[Link]("Parent Alloc. Entry No.");
[Link]("Parent Alloc. Entry No.", EntryNo);
IF [Link] THEN
REPEAT
FindRelatedEntries(LaborAllocEntryL."Entry No.", LaborAllocEntryTmp,
FALSE, 1011);
UNTIL [Link] = 0;
END;
EXIT([Link]);
END;

PROCEDURE FindFirstAppliedEntryNo@7() RetValue : Integer;

VAR
LaborAllocEntryParent@1101904002 : Record 25006271;
BEGIN
IF LaborAllocEntry."Applies-to Entry No." > 0 THEN BEGIN
[Link](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
LaborAllocEntryL@1101904001 : Record 25006271;
LaborAllocAppL@1101904004 : Record 25006277;
BEGIN
[Link];
END;

PROCEDURE SynchroniseRelatedEntry@1101904023(SourceLaborAllocEntryNo@1101904000
: Integer;DestLaborAllocEntryNo@1101904001 : Integer) SynchronisedCount : Integer;
VAR
SourceLaborAllocEntryTmp@1101904002 : TEMPORARY Record 25006271;
DestLaborAllocEntryTmp@1101904003 : TEMPORARY Record 25006271;
LaborAllocEntryL@1101904004 : Record 25006271;
EntryNo@1101904005 : Integer;
DestStatusBefore@1101904006 : Integer;
BEGIN
FindSplitEntries(SourceLaborAllocEntryNo, SourceLaborAllocEntryTmp, 0, 1111);
FindSplitEntries(DestLaborAllocEntryNo, DestLaborAllocEntryTmp, 0, 1011);
[Link];
[Link];
IF [Link] > [Link] THEN BEGIN
[Link];
[Link];
EntryNo := LaborAllocEntry."Entry No.";
[Link];
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,[Link]);
DestLaborAllocEntryTmp := LaborAllocEntry;
[Link];
UNTIL [Link] = [Link];
END ELSE BEGIN
IF [Link] < [Link] THEN BEGIN
REPEAT
[Link];
DeleteAllocationEntry(LaborAllocEntry, LaborAllocApp,
DestLaborAllocEntryTmp."Entry No.", 11111);
[Link];
UNTIL [Link] = [Link];
END;
END;
// now is going to synchr. times
[Link];
[Link];
EntryNo := 0;
REPEAT
[Link](DestLaborAllocEntryTmp."Entry No.");
DestStatusBefore := [Link];
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, [Link],
DestLaborAllocEntryTmp."Applies-to Entry No.",[Link]);
IF DestStatusBefore <> [Link] THEN BEGIN
AllocationStatus := [Link];
ReasonCodeGlobal := SourceLaborAllocEntryTmp."Reason Code";
ChangeStatus(LaborAllocEntry);
ChangeServiceLineStatus(LaborAllocEntry."Entry No.", FALSE);
END;
EntryNo := LaborAllocEntry."Entry No.";
[Link];
UNTIL [Link] = 0;
EXIT(SynchronisedCount);
END;

PROCEDURE SynchroniseRelatedEntries@1101904039(EntryNo@1101904000 : Integer);

VAR
LaborAllocEntryTemp@1101904001 : TEMPORARY Record 25006271;
BEGIN
EntryNo := GetMainAllocEntrNo(EntryNo, 1011);
[Link](EntryNo);
FindRelatedEntries(EntryNo, LaborAllocEntryTemp, TRUE, 1011);
IF [Link](EntryNo) THEN
[Link];
IF [Link] THEN
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;
UNTIL [Link] = 0;
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
ServiceLineLoc@1101901004 : Record 25006146;
IsServiceHeader@1101901003 : Boolean;
BEGIN
CASE SourceType OF
SourceType::"Standard Event": BEGIN
IF QtyToAllocate = 0 THEN
QtyToAllocate := 1;

END;
SourceType::"Service Document": BEGIN
IF [Link] AND (ServiceLineSrcPar."Line No." > 0)
THEN BEGIN //Service Line Allocation
IF [Link] = 1 THEN
LineNo := ServiceLineSrcPar."Line No.";
QtyToAllocate := 0;
REPEAT
ServiceLinePar := ServiceLineSrcPar;
[Link];
IF Mode = Mode::"New Allocation" THEN
QtyToAllocate += [Link];
UNTIL [Link] = 0;
END ELSE BEGIN //Service Header Allocation
IF Mode = Mode::"New Allocation" THEN BEGIN
[Link];
[Link]("Document Type", SourceSubType);
[Link]("Document No.", SourceID);
[Link](Type, [Link]::Labor);
IF [Link] THEN BEGIN
QtyToAllocate := 0;
REPEAT
QtyToAllocate += [Link];
UNTIL [Link] = 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
LaborAllocEntryLoc@1000 : Record 25006271;
ServLaborAllocationDetailLoc@1003 : Record 25006268;
Isfound@1004 : Boolean;
BEGIN
//24.10.2013 EDMS P8
WITH LaborAllocEntryLoc DO BEGIN
IF EntryNo = 0 THEN
EntryNo := LaborAllocEntry."Entry No.";
IF GET(EntryNo) THEN BEGIN
Isfound := FALSE;
IF (DetEntryNo <> "Detail Entry No.") THEN BEGIN
IF [Link](DetEntryNo) THEN BEGIN
IF [Link] = DetailsText THEN BEGIN
VALIDATE("Detail Entry No.", DetEntryNo);
MODIFY(TRUE);
Isfound := TRUE;
END;
END;
END;
IF NOT Isfound THEN BEGIN
IF [Link]("Detail Entry No.") THEN BEGIN
IF [Link] = DetailsText THEN BEGIN
//NO NEED CHANGE
Isfound := TRUE;
END;
END;
END;
IF NOT Isfound THEN BEGIN
ServLaborAllocationDetailLoc."Entry No." := 0;
[Link] := DetailsText;
[Link](TRUE);
DetEntryNo := ServLaborAllocationDetailLoc."Entry No.";
[Link]("Detail Entry No.", DetEntryNo);
[Link](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;

PROCEDURE FinishOtherTasks@25006004(ResourceNo@25006000 :
Code[20];EntryNo@25006001 : Integer;StartingDateTime@25006004 : Decimal);
VAR
OnDate@25006003 : Date;
OnTime@25006002 : Time;
MainAllocEntryNo@25006005 : Integer;
MainLaborAllocationEntry@25006006 : Record 25006271;
StartFinishAllocation@25006008 : Page 25006355;
StatusToSet@25006007 : 'Pending,In Process,Finish All,Finish Part,On Hold';
SingleInstanceManagment@25006009 : Codeunit 25006001;
Resource@25006010 : Record 156;
BEGIN
IF [Link] THEN
EXIT;
OnDate := DateTimeMgt.Datetime2Date(StartingDateTime);
OnTime := DateTimeMgt.Datetime2Time(StartingDateTime);

[Link];
[Link](ResourceNo);
CASE Resource."On Task Start" OF
Resource."On Task Start"::"Hold Other Tasks":
BEGIN
[Link];
[Link]("Resource No.", ResourceNo);
[Link](Status, [Link]::"In
Progress");
[Link](LaborAllocEntry."Entry No.",'<>
%1',EntryNo);
[Link](LaborAllocEntry."Applies-to Entry No.",'<>
%1',EntryNo);
 [Link]("Source ID",'<>%1',ServiceSetup."Default
Idle Event");
IF [Link] THEN BEGIN
REPEAT
AllocationStatus := AllocationStatus::"On Hold";
MainAllocEntryNo := GetMainAllocEntrNo(LaborAllocEntry."Entry
No.", 1011);
IF [Link](MainAllocEntryNo) AND
([Link] =
[Link]::"In Progress") THEN BEGIN
StatusToSet := StatusToSet::"On Hold";

[Link](MainLaborAllocationEntry."Entry No.");
[Link](ResourceNo,
[Link](OnDate, OnTime),
MainLaborAllocationEntry."Quantity (Hours)",
MainLaborAllocationEntry."Source Type",
MainLaborAllocationEntry."Source Subtype",
MainLaborAllocationEntry."Source ID",
StatusToSet,
0);
[Link];
END;
//WriteAllocationEntryEnd(LaborAllocEntry."Entry No.",
StartingDateTime, FALSE, '',[Link]);

[Link]('Onhold',MainLaborAllocationEntry,MainLaborAll
ocationEntry."Resource No.",OnDate,OnTime);
UNTIL [Link] = 0
END;
END;
Resource."On Task Start"::"Complete Other Tasks":
BEGIN
[Link];
[Link]("Resource No.", ResourceNo);
[Link](Status,'%1',[Link]::"In
Progress");
[Link](LaborAllocEntry."Entry No.",'<>
%1',EntryNo);
[Link](LaborAllocEntry."Applies-to Entry No.",'<>
%1',EntryNo);
[Link]("Source ID",'<>%1',ServiceSetup."Default
Idle Event");
IF [Link] THEN BEGIN
REPEAT
AllocationStatus := AllocationStatus::Finished;
MainAllocEntryNo := GetMainAllocEntrNo(LaborAllocEntry."Entry
No.", 1011);
IF [Link](MainAllocEntryNo) AND
([Link] =
[Link]::"In Progress") THEN BEGIN
StatusToSet := StatusToSet::"Finish All";

[Link](MainLaborAllocationEntry."Entry No.");
[Link](ResourceNo,
[Link](OnDate, OnTime),
MainLaborAllocationEntry."Quantity (Hours)",
MainLaborAllocationEntry."Source Type",
MainLaborAllocationEntry."Source Subtype",
 MainLaborAllocationEntry."Source ID",
StatusToSet,
0);
[Link];
END;
//WriteAllocationEntryEnd(LaborAllocEntry."Entry No.",
StartingDateTime, FALSE, '',[Link]);

[Link]('Complete',LaborAllocEntry,LaborAllocEntry."Re
source No.",OnDate,OnTime);
UNTIL [Link] = 0
END;
END;
END;
END;

PROCEDURE "--SERVICE RESOURCES--"@1101904027();

BEGIN
END;

PROCEDURE GetRelatedResources@1101904026(DocType@1101904001 :
Integer;DocNo@1101904006 : Code[20];LineType@1101904007 : Integer;LineNo@1101904008
: Integer;RunMode@1101904000 : Integer) RetValue : Text[250];
VAR
ServLaborApplication@1101904002 : Record 25006277;
ServLaborApplicationTmp@1101904003 : TEMPORARY Record 25006277;
ServiceLine@1101904005 : Record 25006146;
ServLaborApplicationLoc@1101901003 : Record 25006277;
isItDocAllocation@1101904004 : Boolean;
StatusArray@1101901000 : ARRAY [10] OF Integer;
isTempTableUse@1101901001 : Boolean;
BEGIN
//RunMode first digit from right means should it be used temp resource table
RetValue := '';
IF LineType = [Link]::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
IF NOT FINDFIRST THEN
SETRANGE("Document Line No.", LineNo);
END;
IF FINDFIRST THEN BEGIN
REPEAT
[Link]("Resource No.", "Resource No.");
IF NOT [Link] THEN BEGIN
RetValue += "Resource No."+',';
ServLaborApplicationTmp := ServLaborApplication;
 [Link];
END;
UNTIL NEXT = 0;
RetValue := COPYSTR(RetValue, 1, STRLEN(RetValue)-1);
END;
END;
END;
EXIT(RetValue);
END;

PROCEDURE SetRelatedResources@1101904031(DocType@1101904018 :
Integer;DocNo@1101904017 : Code[20];LineType@1101904016 : Integer;LineNo@1101904015
: Integer;RecourcesTextSource@1101904004 : Text[250];RunMode@1101904000 : Integer)
ResourcesCount : Integer;
VAR
ServLaborApplication@1101904002 : Record 25006277;
Posit@1101904005 : Integer;
ServiceSetup@1101904008 : Record 25006120;
ResourceToAdd@1101904010 : Text[30];
Resource@1101904011 : Record 156;
RecourcesText@1101904003 : Text[250];
RecourcesTextToModify@1101904012 : Text[250];
AllocEntryNo@1101904006 : Integer;
isItDocAllocation@1101904007 : Boolean;
divResult@1101904009 : Integer;
isItAllowedMessage@1101904013 : Boolean;
ServiceLine@1101904001 : Record 25006146;
BEGIN
//RunMode = 0 - normal; 1 - no messages; second digit (tens) - is it document
allocation
[Link];
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 = [Link]::Labor THEN BEGIN
WITH ServLaborApplication DO BEGIN
SETRANGE("Document Type", DocType);
SETRANGE("Document No.", DocNo);
SETRANGE("Document Line No.", LineNo);
IF NOT FINDFIRST THEN BEGIN
SETRANGE("Document Line No.", 0);
// 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;
SETRANGE("Document Line No.", LineNo);
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 [Link](ResourceToAdd) THEN BEGIN
SETRANGE("Resource No.", ResourceToAdd);
IF NOT FINDLAST THEN BEGIN
[Link](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
SETRANGE("Document Line No.", 0);
IF FINDFIRST THEN
REPEAT
Posit := STRPOS(RecourcesTextSource, "Resource No.");
IF NOT (Posit > 0) THEN BEGIN
DELETE(TRUE);
FINDFIRST;
END;
UNTIL NEXT = 0;
IF FINDFIRST THEN BEGIN
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([Link]);
END;

PROCEDURE RelatedResourcesList@1101904030(DocType@1101904005 :
Integer;DocNo@1101904004 : Code[20];LineType@1101904003 : Integer;LineNo@1101904002
: Integer;VAR RelatedResources@1101904000 : Text[250]);
VAR
ServLaborAllocApplication@1101904001 : Record 25006277;
BEGIN
[Link];
[Link]("Document Type", DocType);
[Link]("Document No.", DocNo);
 [Link]("Document Line No.", LineNo);
IF LineNo < 0 THEN
[Link]("Document Line No.");
[Link](PAGE::"Service Line Resources", ServLaborAllocApplication);
RelatedResources := GetRelatedResources(DocType, DocNo, LineType, LineNo, 0);
END;

PROCEDURE ResourcesList@1101904029(DocType@1101904006 :
Integer;DocNo@1101904005 : Code[20];LineType@1101904004 : Integer;LineNo@1101904003
: Integer;VAR RelatedResources@1101904000 : Text[250]);
VAR
ServLaborApplication@1101904001 : Record 25006277;
Resource@1101904002 : Record 156;
ServiceSetup@1101904007 : Record 25006120;
BEGIN
//??? checkstatusopen
// not used for now, it is supposed to be used for lookup (case then SS
unactive and only one resource is set)

[Link];
IF ServiceSetup."Service Schedule Active" THEN
ERROR(Text146);

WITH ServLaborApplication DO BEGIN

RESET;
SETRANGE("Document Type", DocType);
SETRANGE("Document No.", DocNo);
SETRANGE("Document Line No.", LineNo);
IF FINDFIRST THEN
IF [Link]("Resource No.") THEN;
END;
IF [Link](0,Resource) = ACTION::OK THEN BEGIN
RelatedResources := Resource."No.";
IF [Link] THEN BEGIN
[Link]("Resource No.", Resource."No.");
IF [Link] THEN BEGIN
[Link]("Resource No.");
[Link]("Resource No.", '<>%1', Resource."No.");
IF [Link] THEN
[Link](TRUE);
END ELSE BEGIN
[Link]("Resource No.");
[Link];
ServLaborApplication."Resource No." := Resource."No.";
[Link];
[Link];
REPEAT
[Link](TRUE);
UNTIL ServLaborApplication."Resource No." = Resource."No.";
END;
END ELSE BEGIN
[Link];
ServLaborApplication."Allocation Entry No." := 0;
ServLaborApplication."Document Type" := DocType;
ServLaborApplication."Document No." := DocNo;
ServLaborApplication."Document Line No." := LineNo;
ServLaborApplication."Resource No." := Resource."No.";
[Link](TRUE);
END;
 END;
END;

PROCEDURE ResourcesCopyLineToLine@1101904028(DocType@1101904010 :
Integer;DocNo@1101904009 : Code[20];LineType@1101904008 : Integer;LineNo@1101904007
: 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.
[Link];
IF NOT ServiceSetup."Service Schedule Active" THEN BEGIN
ResourcesText := GetRelatedResources(DocType, DocNo, LineType, LineNo, 0);
IF [Link](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
LaborAllocEntryL@1101904004 : Record 25006271;
LaborAllocApplicationL@1101904005 : Record 25006277;
ServLaborAllocationEntryTmp@1101904003 : TEMPORARY Record 25006271;
BEGIN
IF [Link](EntryNoPar) THEN BEGIN
[Link]("Document Type", LaborAllocEntryL."Source
Subtype");
[Link]("Document No.", LaborAllocEntryL."Source
ID");
[Link]("Allocation Entry No.",
LaborAllocEntryL."Entry No.");
IF [Link] THEN
LineNoPar := LaborAllocApplicationL."Document Line No.";

FindRelatedEntries(EntryNoPar, ServLaborAllocationEntryTmp, TRUE, 1011);

WITH ServLaborAllocationEntryTmp DO BEGIN
[Link];
IF FINDFIRST THEN
REPEAT
[Link]("Document Type", "Source Subtype");
[Link]("Document No.", "Source ID");
[Link]("Allocation Entry No.", "Entry No.");
IF [Link] THEN
IF [Link] THEN BEGIN
ServLaborAllocApplicationPar := LaborAllocApplicationL;
[Link](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;
[Link](TRUE);
END;
END;

PROCEDURE RemoveDuplicates@1101901002(VAR ServLaborApplication@1101901002 :

Record 25006277);
VAR
ServLaborApplicationLoc@1101901001 : Record 25006277;
ServLaborApplicationLoc2@1101901000 : Record 25006277;
BEGIN
IF [Link] THEN BEGIN
// THAT part to remove duplicates that are not in schedule
[Link];
[Link]("Document Type",
ServLaborApplication."Document Type");
[Link]("Document No.",
ServLaborApplication."Document No.");
[Link]("Document Line No.",
ServLaborApplication."Document Line No.");
[Link]("Allocation Entry No.", 0);
REPEAT
[Link]("Resource No.",
ServLaborApplication."Resource No.");
IF [Link] THEN BEGIN
[Link](ServLaborApplicationLoc);
[Link]("Allocation Entry No.",'>0');
IF [Link] THEN BEGIN
[Link](TRUE);
[Link];
END ELSE BEGIN
IF [Link] > 1 THEN BEGIN
REPEAT
[Link];
[Link](TRUE);
UNTIL [Link] <= 1;
[Link];
END;
END;
END;
UNTIL [Link] = 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 [Link]("Resource No.") THEN BEGIN
[Link](Blocked, FALSE);
[Link];
[Link](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.";
[Link] := FALSE;
[Link](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
DoReplan@1002 : Boolean;
Hours@1006 : Decimal;
LaborAllocEntry2@1001 : Record 25006271;
ServSchedAddInMgt@1004 : Codeunit 25006203;
Travel@25006000 : Boolean;
BEGIN
IF ShowDialog THEN
IF NOT CONFIRM(Text161) THEN
EXIT;

IF NOT [Link]([Link]) THEN BEGIN

MESSAGE(Text121);
EXIT;
END;

IF NOT CheckUserRightsAdv(1, LaborAllocEntry) THEN

EXIT;

IF AllocationStatus1 = AllocationStatus1::Pending THEN BEGIN

IF ([Link] = [Link]::Pending) AND NOT
ShowDialog THEN
EXIT;

IF [Link] <> [Link]::"In Progress" THEN

ERROR(Text162);

Hours := LaborAllocEntry."Quantity (Hours)";

ReasonCodeGlobal := LaborAllocEntry."Reason Code";
DoReplan := FALSE;
AllocationStatus := AllocationStatus::Pending;
ChangeAllocationStatus := TRUE;
Travel := [Link];

WriteAllocationEntries(LaborAllocEntry."Resource No.", StartingDateTime,

Hours,
LaborAllocEntry."Source Type",
LaborAllocEntry."Source Subtype",
LaborAllocEntry."Source ID", 1,
LaborAllocEntry."Entry No.", DoReplan, AllocationStatus, FALSE,Travel);

// Cancel Start Allocations for Applied Entries too

[Link];
[Link]("Applies-to Entry No.", LaborAllocEntry."Entry
No.");
IF [Link] THEN
[Link](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
[Link];
[Link]("Service Ledger Entry No.","Entry No.");
IF [Link] THEN
REPEAT
IF [Link](DetServLedgEntry."Resource No.") THEN BEGIN
[Link](Blocked, FALSE);
[Link];
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");
[Link] := FALSE;
[Link](TRUE);
END;
UNTIL [Link]=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

16.05.2014 Elva Baltic P21 #S0101 MMG7.00

Added function:
CancelAllocation

14.05.2014 Elva Baltic P21 #S0102 MMG7.00

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

14.03.2014 Elva Baltic P8 #S0003 MMG7.00

* 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
[Link], 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 COMMIT before [Link]

04.06.2013 EDMS P8
new function CalcEndDTOnlyWorktime
15.04.2013 EDMS P8
* Fix on-hold part should be separated of finished, influence into behavior
of work ClearAllocationEntry in function MovementIncSplit

09.04.2013 EDMS P8
* fix new created allocation should not create additional AppEntries for
Lines

03.04.2013 P8
* set for page runmodal:
[Link](TRUE); //03.04.2013 P8
* removed unnecessary GetScheduleViewCode

19.03.2013 EDMS P8
fix for split process

01.03.2013 EDMS P8
* FIX resource insert/remove for order

2012.05.07 EDMS P8
* As far splited entries became more useful then most routines must be
recoded so that it could be runed in modes: