eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.PAY_FR_SICK_PAY_PROCESSING dependencies on HR_UTILITY

Line 89: hr_utility.set_location('initialise_processing_rules ',10);

85: --
86: PROCEDURE initialise_processing_rules IS
87: BEGIN
88:
89: hr_utility.set_location('initialise_processing_rules ',10);
90: --
91: --
92: -- Garantie au net processing rules.
93: --

Line 197: hr_utility.set_location('initialise_processing_rules ',100);

193: g_iter_rules(cs_FINAL + 1).sick_adj := 'Y';
194: g_iter_rules(cs_FINAL + 1).gi_adj := 'Y';
195: g_iter_rules(cs_FINAL + 1).gross_ijss_adj := 'Y';
196: --
197: hr_utility.set_location('initialise_processing_rules ',100);
198:
199: END initialise_processing_rules;
200: --
201: --

Line 207: hr_utility.set_location('initialise_guarantee_lookup ',10);

203: -- to a corresponding LOOKUP_CODE within the LOOKUP_TYPE of FR_GI_TYPES.
204: --
205: PROCEDURE initialise_guarantee_lookups IS
206: BEGIN
207: hr_utility.set_location('initialise_guarantee_lookup ',10);
208: g_guarantee_type_lookups(cs_GN) := 'GN';
209: g_guarantee_type_lookups(cs_LE) := 'LE';
210: g_guarantee_type_lookups(cs_CA_G_ADJ) := 'CA_G_ADJ';
211: g_guarantee_type_lookups(cs_CA_G_NOADJ) := 'CA_G_NOADJ';

Line 215: hr_utility.set_location('initialise_guarantee_lookup ',100);

211: g_guarantee_type_lookups(cs_CA_G_NOADJ) := 'CA_G_NOADJ';
212: g_guarantee_type_lookups(cs_CA_N) := 'CA_N';
213: g_guarantee_type_lookups(cs_NO_G) := 'NO_G';
214:
215: hr_utility.set_location('initialise_guarantee_lookup ',100);
216: END initialise_guarantee_lookups;
217: --
218: --
219: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 280: hr_utility.set_location('External Procedure ',10);

276: ,p_absence IN OUT NOCOPY t_absence_arch
277: ,p_coverages IN OUT NOCOPY t_coverages) IS
278: BEGIN
279:
280: hr_utility.set_location('External Procedure ',10);
281: pay_fr_sickness_calc.CALC_SICKNESS(p_mode,p_asg,p_absence,p_coverages);
282:
283: hr_utility.set_location('External Procedure ',100);
284: END external_procedure;

Line 283: hr_utility.set_location('External Procedure ',100);

279:
280: hr_utility.set_location('External Procedure ',10);
281: pay_fr_sickness_calc.CALC_SICKNESS(p_mode,p_asg,p_absence,p_coverages);
282:
283: hr_utility.set_location('External Procedure ',100);
284: END external_procedure;
285: --
286: --
287: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 321: hr_utility.set_location('Process Control info ',10);

317: -- 1. ALL guarantees have a net amount so pick the best one for processing.
318: -- 2. The guarantee with no net amount is currently being processed so do nothing.
319: -- 3. Process the guarantee with no net amount.
320: --
321: hr_utility.set_location('Process Control info ',10);
322: l_idx := g_coverages.FIRST;
323:
324: LOOP
325:

Line 329: hr_utility.set_location('Process Control info Inside Loop',l_idx);

325:
326: --
327: -- Find the first type which has not been processed.
328: --
329: hr_utility.set_location('Process Control info Inside Loop',l_idx);
330: l_calculate := (NVL(g_coverages(l_idx).processed_flag,'N') = 'Y');
331:
332: --
333: --

Line 356: hr_utility.set_location('Process Control info inside not calculate',20);

352: --
353: --
354: -- The processing to find the net for this guarantee is already in progress.
355: --
356: hr_utility.set_location('Process Control info inside not calculate',20);
357:
358: IF NVL(g_ctl.g_idx,-1) = l_idx THEN
359: NULL;
360: --

Line 369: hr_utility.set_location('Process Control info after cs_process',30);

365:
366: g_ctl.p_mode := cs_PROCESS;
367: g_ctl.g_idx := l_idx;
368: g_ctl.iter := 1;
369: hr_utility.set_location('Process Control info after cs_process',30);
370: END IF;
371:
372: ELSE
373: hr_utility.set_location('Process Control info',40);

Line 373: hr_utility.set_location('Process Control info',40);

369: hr_utility.set_location('Process Control info after cs_process',30);
370: END IF;
371:
372: ELSE
373: hr_utility.set_location('Process Control info',40);
374: l_mode := 'C';
375: external_procedure(l_mode, g_asg, g_absence, g_coverages);
376:
377: l_idx := g_coverages.FIRST;

Line 385: hr_utility.set_location('Process Control info',50);

381: --
382: -- Find the best method.
383: --
384: l_best := (NVL(g_coverages(l_idx).best_method,'N') = 'Y');
385: hr_utility.set_location('Process Control info',50);
386:
387: --
388: --
389: -- Finish looping if All have been checked OR there is a best coverage

Line 399: hr_utility.set_location('Process Control info',60);

395: -- Move onto next guarantee.
396: --
397: l_idx := g_coverages.NEXT(l_idx);
398:
399: hr_utility.set_location('Process Control info',60);
400: END LOOP;
401:
402: -- Process the best one and set mode to Final
403: g_ctl.p_mode := cs_FINAL_PROCESS;

Line 406: hr_utility.set_location('Process Control info',70);

402: -- Process the best one and set mode to Final
403: g_ctl.p_mode := cs_FINAL_PROCESS;
404: g_ctl.g_idx := l_idx;
405: g_ctl.iter := 1;
406: hr_utility.set_location('Process Control info',70);
407:
408: END IF;
409:
410: hr_utility.set_location('Process Control info',100);

Line 410: hr_utility.set_location('Process Control info',100);

406: hr_utility.set_location('Process Control info',70);
407:
408: END IF;
409:
410: hr_utility.set_location('Process Control info',100);
411: END process_control_info;
412:
413: --
414: --

Line 447: hr_utility.set_location('Initialise Absence',10);

443: --
444: --
445: -- Get the absence ID linked to the element entry being processed.
446: --
447: hr_utility.set_location('Initialise Absence',10);
448: -- Added lines for CPAM Processing
449: IF pay_fr_sickness_calc.g_absence_calc.initiator = 'CPAM' THEN
450: g_absence.ID := pay_fr_sickness_calc.g_absence_calc.ID;
451: ELSE

Line 457: hr_utility.set_location('Initialise Absence',20);

453: FETCH csr_absence_id INTO g_absence.ID;
454: CLOSE csr_absence_id;
455: END IF;
456: --
457: hr_utility.set_location('Initialise Absence',20);
458: --
459: -- Initialise information required to process the absence.
460: --
461: l_mode := 'I';

Line 462: hr_utility.set_location('Initialise Absence',30);

458: --
459: -- Initialise information required to process the absence.
460: --
461: l_mode := 'I';
462: hr_utility.set_location('Initialise Absence',30);
463: external_procedure(l_mode, g_asg, g_absence, g_coverages);
464: hr_utility.set_location('Initialise Absence',40);
465: --
466: --

Line 464: hr_utility.set_location('Initialise Absence',40);

460: --
461: l_mode := 'I';
462: hr_utility.set_location('Initialise Absence',30);
463: external_procedure(l_mode, g_asg, g_absence, g_coverages);
464: hr_utility.set_location('Initialise Absence',40);
465: --
466: --
467: -- Initialise the control information.
468: --

Line 470: hr_utility.set_location('Initialise Absence',100);

466: --
467: -- Initialise the control information.
468: --
469: process_control_info();
470: hr_utility.set_location('Initialise Absence',100);
471: END initialise_absence;
472: --
473: --
474: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 485: hr_utility.set_location('Reset Data Str',100);

481: BEGIN
482: g_ctl := blank_ctl;
483: g_absence := blank_absence;
484: g_coverages := blank_coverages;
485: hr_utility.set_location('Reset Data Str',100);
486: END reset_data_structures;
487: --
488: --
489: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 533: hr_utility.set_location('Initialise Assignment',10);

529: --
530: --
531: -- Retrieve information for processing the new absence.
532: --
533: hr_utility.set_location('Initialise Assignment',10);
534: initialise_absence(p_element_entry_id, p_date_earned);
535: hr_utility.set_location('Initialise Assignment',100);
536: END initialise_assignment;
537: --

Line 535: hr_utility.set_location('Initialise Assignment',100);

531: -- Retrieve information for processing the new absence.
532: --
533: hr_utility.set_location('Initialise Assignment',10);
534: initialise_absence(p_element_entry_id, p_date_earned);
535: hr_utility.set_location('Initialise Assignment',100);
536: END initialise_assignment;
537: --
538: --
539: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 574: hr_utility.set_location('Initialise',10);

570: -- initialise the information for the absence.
571: -- bug 99999999 added action_start_date check as g_asg not being initialized
572: -- in retropay covering multiple periods
573: --
574: hr_utility.set_location('Initialise',10);
575: IF NOT (NVL(g_asg.assignment_id, -1) = p_assignment_id
576: and (g_asg.action_start_date = p_action_start_date) ) THEN
577: initialise_assignment(p_assignment_id,
578: p_net_pay,

Line 592: hr_utility.set_location('Initialise ',20);

588: p_action_end_date,
589: p_ded_ref_salary,
590: p_lg_ref_salary );
591: l_initialised := TRUE;
592: hr_utility.set_location('Initialise ',20);
593: --
594: --
595: -- A new absence is being processed so initialise the information for the absence.
596: --

Line 601: hr_utility.set_location('Initialise',30);

597: ELSIF NOT ( NVL(g_absence.element_entry_id, -1) = p_element_entry_id) THEN
598: g_asg.sick_net := p_net_pay;
599: initialise_absence(p_element_entry_id, p_date_earned);
600: l_initialised := TRUE;
601: hr_utility.set_location('Initialise',30);
602:
603: ELSIF NOT (g_absence.date_earned = p_date_earned) THEN
604:
605: initialise_assignment(p_assignment_id,

Line 621: hr_utility.set_location('Initialise',40);

617: p_ded_ref_salary,
618: p_lg_ref_salary );
619:
620: l_initialised := TRUE;
621: hr_utility.set_location('Initialise',40);
622:
623: END IF;
624:
625: --

Line 629: hr_utility.set_location('Initialise',100);

625: --
626: --
627: -- Return indicator identifying if initialisation occured.
628: --
629: hr_utility.set_location('Initialise',100);
630: RETURN l_initialised;
631: END initialise;
632: --
633: --

Line 640: hr_utility.set_location('Increment Iteration',10);

636: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
637: --
638: PROCEDURE increment_iteration IS
639: BEGIN
640: hr_utility.set_location('Increment Iteration',10);
641: g_ctl.iter := g_ctl.iter + 1;
642: hr_utility.set_location('Increment Iteration',100);
643: END increment_iteration;
644: --

Line 642: hr_utility.set_location('Increment Iteration',100);

638: PROCEDURE increment_iteration IS
639: BEGIN
640: hr_utility.set_location('Increment Iteration',10);
641: g_ctl.iter := g_ctl.iter + 1;
642: hr_utility.set_location('Increment Iteration',100);
643: END increment_iteration;
644: --
645: --
646: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 653: hr_utility.set_location('Final Processing',10);

649: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
650: --
651: FUNCTION final_processing RETURN BOOLEAN IS
652: BEGIN
653: hr_utility.set_location('Final Processing',10);
654: RETURN (g_ctl.p_mode = cs_FINAL_PROCESS);
655: END final_processing;
656: --
657: --

Line 665: hr_utility.set_location('g_type',10);

661: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
662: --
663: FUNCTION g_type RETURN NUMBER IS
664: BEGIN
665: hr_utility.set_location('g_type',10);
666:
667: IF final_processing THEN
668:
669: RETURN cs_FINAL;

Line 671: hr_utility.set_location('g_type',11);

667: IF final_processing THEN
668:
669: RETURN cs_FINAL;
670: ELSE
671: hr_utility.set_location('g_type',11);
672: RETURN g_coverages(g_ctl.g_idx).g_type;
673:
674: END IF;
675: END g_type;

Line 696: hr_utility.set_location('Stop Processing',10);

692: --
693: --
694: -- Simple case where the processing is stopped at a specified iteration.
695: --
696: hr_utility.set_location('Stop Processing',10);
697: hr_utility.set_location('Stop Processing Iterate No is'|| to_char(g_ctl.iter) , 15);
698: IF g_rules(g_type).stop IS NOT NULL THEN
699: RETURN (g_rules(g_type).stop = g_ctl.iter);
700: --

Line 697: hr_utility.set_location('Stop Processing Iterate No is'|| to_char(g_ctl.iter) , 15);

693: --
694: -- Simple case where the processing is stopped at a specified iteration.
695: --
696: hr_utility.set_location('Stop Processing',10);
697: hr_utility.set_location('Stop Processing Iterate No is'|| to_char(g_ctl.iter) , 15);
698: IF g_rules(g_type).stop IS NOT NULL THEN
699: RETURN (g_rules(g_type).stop = g_ctl.iter);
700: --
701: --

Line 705: hr_utility.set_location('Stop Processing',20);

701: --
702: -- Check to see if the currently calculated net pay is close enough to the target net.
703: --
704: ELSE
705: hr_utility.set_location('Stop Processing',20);
706: l_target_net := nvl(g_coverages(g_ctl.g_idx).net,0);
707: hr_utility.set_location('Stop Processing'||l_target_net || p_net_pay,25);
708: RETURN (l_target_net + cs_MARGIN >= p_net_pay AND l_target_net - cs_MARGIN <= p_net_pay);
709: END IF;

Line 707: hr_utility.set_location('Stop Processing'||l_target_net || p_net_pay,25);

703: --
704: ELSE
705: hr_utility.set_location('Stop Processing',20);
706: l_target_net := nvl(g_coverages(g_ctl.g_idx).net,0);
707: hr_utility.set_location('Stop Processing'||l_target_net || p_net_pay,25);
708: RETURN (l_target_net + cs_MARGIN >= p_net_pay AND l_target_net - cs_MARGIN <= p_net_pay);
709: END IF;
710: hr_utility.set_location('Stop Processing',100);
711: END stop_processing;

Line 710: hr_utility.set_location('Stop Processing',100);

706: l_target_net := nvl(g_coverages(g_ctl.g_idx).net,0);
707: hr_utility.set_location('Stop Processing'||l_target_net || p_net_pay,25);
708: RETURN (l_target_net + cs_MARGIN >= p_net_pay AND l_target_net - cs_MARGIN <= p_net_pay);
709: END IF;
710: hr_utility.set_location('Stop Processing',100);
711: END stop_processing;
712: --
713: --
714: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 730: hr_utility.set_location('Set Adjustment',10);

726: l_diff NUMBER;
727: l_sick_adj NUMBER;
728: l_init NUMBER;
729: BEGIN
730: hr_utility.set_location('Set Adjustment',10);
731: --
732: --
733: -- Get the target net for the current guarantee.
734: --

Line 739: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,15);

735: l_target_net := nvl(g_coverages(g_ctl.g_idx).net,0);
736:
737: select decode(l_target_net,0,1,l_target_net) into l_init from dual;
738:
739: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,15);
740: hr_utility.set_location('Set Adjustment init: ' || l_init,17);
741:
742: --
743: --

Line 740: hr_utility.set_location('Set Adjustment init: ' || l_init,17);

736:
737: select decode(l_target_net,0,1,l_target_net) into l_init from dual;
738:
739: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,15);
740: hr_utility.set_location('Set Adjustment init: ' || l_init,17);
741:
742: --
743: --
744: -- There has not been an adjustment so set an initial value.

Line 747: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,18);

743: --
744: -- There has not been an adjustment so set an initial value.
745: --
746: IF g_coverages(g_ctl.g_idx).sick_adj IS NULL THEN
747: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,18);
748:
749: l_dummy := pay_iterate.initialise(g_absence.element_entry_id, l_init, -1 * l_init, l_init);
750: l_sick_adj := pay_iterate.get_interpolation_guess(g_absence.element_entry_id, 0);
751: hr_utility.set_location('Set Adjustment',20);

Line 751: hr_utility.set_location('Set Adjustment',20);

747: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,18);
748:
749: l_dummy := pay_iterate.initialise(g_absence.element_entry_id, l_init, -1 * l_init, l_init);
750: l_sick_adj := pay_iterate.get_interpolation_guess(g_absence.element_entry_id, 0);
751: hr_utility.set_location('Set Adjustment',20);
752: --
753: --
754: -- Refine the adjustment.
755: --

Line 757: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,25);

753: --
754: -- Refine the adjustment.
755: --
756: ELSE
757: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,25);
758:
759: l_diff := l_target_net - p_net_pay;
760:
761: hr_utility.set_location('Set Adjustment diff: ' || l_diff,25);

Line 761: hr_utility.set_location('Set Adjustment diff: ' || l_diff,25);

757: hr_utility.set_location('Set Adjustment target net: ' || l_target_net,25);
758:
759: l_diff := l_target_net - p_net_pay;
760:
761: hr_utility.set_location('Set Adjustment diff: ' || l_diff,25);
762:
763: l_sick_adj := pay_iterate.get_interpolation_guess(g_absence.element_entry_id, l_diff);
764: hr_utility.set_location('Set Adjustment',30);
765: END IF;

Line 764: hr_utility.set_location('Set Adjustment',30);

760:
761: hr_utility.set_location('Set Adjustment diff: ' || l_diff,25);
762:
763: l_sick_adj := pay_iterate.get_interpolation_guess(g_absence.element_entry_id, l_diff);
764: hr_utility.set_location('Set Adjustment',30);
765: END IF;
766: --
767: --
768: -- Set the sickness adjustment.

Line 771: hr_utility.set_location('Set Adjustment',100);

767: --
768: -- Set the sickness adjustment.
769: --
770: g_coverages(g_ctl.g_idx).sick_adj := l_sick_adj;
771: hr_utility.set_location('Set Adjustment',100);
772: END;
773: --
774: --
775: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 782: hr_utility.set_location('Set Net Pay',10);

778: --
779: PROCEDURE set_net_pay
780: (p_net_pay NUMBER) IS
781: BEGIN
782: hr_utility.set_location('Set Net Pay',10);
783: g_coverages(g_ctl.g_idx).net := p_net_pay;
784: END set_net_pay;
785: --
786: --

Line 793: hr_utility.set_location('Adjustment Needed',10);

789: -- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
790: --
791: FUNCTION adjustment_needed RETURN BOOLEAN IS
792: BEGIN
793: hr_utility.set_location('Adjustment Needed',10);
794:
795: RETURN (g_iter_rules(g_type + LEAST(NVL(g_rules(g_type).repeat,g_ctl.iter), g_ctl.iter)).sick_adj = 'Y');
796:
797:

Line 825: -- hr_utility.trace_on(NULL,'REQID');

821: ,p_stop_processing OUT NOCOPY VARCHAR2) RETURN NUMBER IS
822:
823: BEGIN
824:
825: -- hr_utility.trace_on(NULL,'REQID');
826: hr_utility.set_location('Iterate',10);
827:
828: hr_utility.set_location('base net' || g_asg.base_net,10);
829: hr_utility.set_location('sick net' || g_asg.sick_net,10);

Line 826: hr_utility.set_location('Iterate',10);

822:
823: BEGIN
824:
825: -- hr_utility.trace_on(NULL,'REQID');
826: hr_utility.set_location('Iterate',10);
827:
828: hr_utility.set_location('base net' || g_asg.base_net,10);
829: hr_utility.set_location('sick net' || g_asg.sick_net,10);
830: hr_utility.set_location('present net'|| p_net_pay,10);

Line 828: hr_utility.set_location('base net' || g_asg.base_net,10);

824:
825: -- hr_utility.trace_on(NULL,'REQID');
826: hr_utility.set_location('Iterate',10);
827:
828: hr_utility.set_location('base net' || g_asg.base_net,10);
829: hr_utility.set_location('sick net' || g_asg.sick_net,10);
830: hr_utility.set_location('present net'|| p_net_pay,10);
831:
832: --

Line 829: hr_utility.set_location('sick net' || g_asg.sick_net,10);

825: -- hr_utility.trace_on(NULL,'REQID');
826: hr_utility.set_location('Iterate',10);
827:
828: hr_utility.set_location('base net' || g_asg.base_net,10);
829: hr_utility.set_location('sick net' || g_asg.sick_net,10);
830: hr_utility.set_location('present net'|| p_net_pay,10);
831:
832: --
833: --

Line 830: hr_utility.set_location('present net'|| p_net_pay,10);

826: hr_utility.set_location('Iterate',10);
827:
828: hr_utility.set_location('base net' || g_asg.base_net,10);
829: hr_utility.set_location('sick net' || g_asg.sick_net,10);
830: hr_utility.set_location('present net'|| p_net_pay,10);
831:
832: --
833: --
834: -- Checking for a change in assignment or absnece and initialising the processing

Line 854: hr_utility.set_location('Iterate',20);

850: p_lg_ref_salary ) THEN
851:
852: increment_iteration;
853:
854: hr_utility.set_location('Iterate',20);
855: --
856: --
857: -- Processing the guarantee that pays the best net.
858: --

Line 864: hr_utility.set_location('Iterate',30);

860: --
861: --
862: -- Check to see if processing should stop.
863: --
864: hr_utility.set_location('Iterate',30);
865: IF stop_processing(p_net_pay) THEN
866: reset_data_structures;
867: hr_utility.set_location('Iterate',40);
868: p_stop_processing := 'Y';

Line 867: hr_utility.set_location('Iterate',40);

863: --
864: hr_utility.set_location('Iterate',30);
865: IF stop_processing(p_net_pay) THEN
866: reset_data_structures;
867: hr_utility.set_location('Iterate',40);
868: p_stop_processing := 'Y';
869: END IF;
870: --
871: --

Line 880: hr_utility.set_location('net pay' || p_net_pay,18);

876: IF (g_coverages(g_ctl.g_idx).g_type = 30 and g_ctl.iter= 2) then
877:
878: IF ((nvl(g_coverages(g_ctl.g_idx).gi_payment1,0) + nvl(g_coverages(g_ctl.g_idx).gi_payment2,0)) = 0) then
879: set_net_pay(nvl(p_net_pay,0) + nvl(g_absence.ijss_net,0)+nvl(g_absence.ijss_payment,0));
880: hr_utility.set_location('net pay' || p_net_pay,18);
881: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,20);
882: ELSE
883: set_net_pay(nvl(p_net_pay,0)+ nvl(g_coverages(g_ctl.g_idx).ijss_net_adjustment,0));
884: hr_utility.set_location('net pay' || p_net_pay,19);

Line 881: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,20);

877:
878: IF ((nvl(g_coverages(g_ctl.g_idx).gi_payment1,0) + nvl(g_coverages(g_ctl.g_idx).gi_payment2,0)) = 0) then
879: set_net_pay(nvl(p_net_pay,0) + nvl(g_absence.ijss_net,0)+nvl(g_absence.ijss_payment,0));
880: hr_utility.set_location('net pay' || p_net_pay,18);
881: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,20);
882: ELSE
883: set_net_pay(nvl(p_net_pay,0)+ nvl(g_coverages(g_ctl.g_idx).ijss_net_adjustment,0));
884: hr_utility.set_location('net pay' || p_net_pay,19);
885: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,21);

Line 884: hr_utility.set_location('net pay' || p_net_pay,19);

880: hr_utility.set_location('net pay' || p_net_pay,18);
881: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,20);
882: ELSE
883: set_net_pay(nvl(p_net_pay,0)+ nvl(g_coverages(g_ctl.g_idx).ijss_net_adjustment,0));
884: hr_utility.set_location('net pay' || p_net_pay,19);
885: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,21);
886:
887: END IF;
888:

Line 885: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,21);

881: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,20);
882: ELSE
883: set_net_pay(nvl(p_net_pay,0)+ nvl(g_coverages(g_ctl.g_idx).ijss_net_adjustment,0));
884: hr_utility.set_location('net pay' || p_net_pay,19);
885: hr_utility.set_location(' totnet pay' || g_coverages(g_ctl.g_idx).net,21);
886:
887: END IF;
888:
889: END IF;

Line 895: hr_utility.set_location('Iterate',70);

891: IF stop_processing(p_net_pay) then
892:
893: set_net_pay(p_net_pay);
894: g_coverages(g_ctl.g_idx).processed_flag := 'Y';
895: hr_utility.set_location('Iterate',70);
896:
897: ELSIF adjustment_needed THEN
898:
899: set_adjustment(p_net_pay);

Line 900: hr_utility.set_location('Iterate',50);

896:
897: ELSIF adjustment_needed THEN
898:
899: set_adjustment(p_net_pay);
900: hr_utility.set_location('Iterate',50);
901:
902: END IF;
903:
904: --

Line 910: hr_utility.set_location('Iterate',80);

906: -- Check to see if there are any more guarantees that need to be processed to get their net amount.
907: --
908: process_control_info();
909:
910: hr_utility.set_location('Iterate',80);
911:
912: END IF;
913:
914: END IF;

Line 920: hr_utility.set_location('Iterate',90);

916: --
917: --
918: -- Simply return a value NB. declared as a function so it cab be used via a formula function.
919: --
920: hr_utility.set_location('Iterate',90);
921: -- hr_utility.trace_off;
922:
923: RETURN 0;
924: EXCEPTION

Line 921: -- hr_utility.trace_off;

917: --
918: -- Simply return a value NB. declared as a function so it cab be used via a formula function.
919: --
920: hr_utility.set_location('Iterate',90);
921: -- hr_utility.trace_off;
922:
923: RETURN 0;
924: EXCEPTION
925: WHEN OTHERS THEN

Line 926: hr_utility.set_location('iterate',-10);

922:
923: RETURN 0;
924: EXCEPTION
925: WHEN OTHERS THEN
926: hr_utility.set_location('iterate',-10);
927: hr_utility.trace(SQLCODE);
928: hr_utility.trace(SQLERRM);
929: -- hr_utility.trace_off;
930: RAISE;

Line 927: hr_utility.trace(SQLCODE);

923: RETURN 0;
924: EXCEPTION
925: WHEN OTHERS THEN
926: hr_utility.set_location('iterate',-10);
927: hr_utility.trace(SQLCODE);
928: hr_utility.trace(SQLERRM);
929: -- hr_utility.trace_off;
930: RAISE;
931:

Line 928: hr_utility.trace(SQLERRM);

924: EXCEPTION
925: WHEN OTHERS THEN
926: hr_utility.set_location('iterate',-10);
927: hr_utility.trace(SQLCODE);
928: hr_utility.trace(SQLERRM);
929: -- hr_utility.trace_off;
930: RAISE;
931:
932:

Line 929: -- hr_utility.trace_off;

925: WHEN OTHERS THEN
926: hr_utility.set_location('iterate',-10);
927: hr_utility.trace(SQLCODE);
928: hr_utility.trace(SQLERRM);
929: -- hr_utility.trace_off;
930: RAISE;
931:
932:
933: END iterate;

Line 991: -- hr_utility.trace_on(NULL,'REQID');

987: --
988: --
989: -- Pass values for the IJSS payment when appropriate.
990: --
991: -- hr_utility.trace_on(NULL,'REQID');
992:
993: hr_utility.set_location('Indirects',10);
994:
995:

Line 993: hr_utility.set_location('Indirects',10);

989: -- Pass values for the IJSS payment when appropriate.
990: --
991: -- hr_utility.trace_on(NULL,'REQID');
992:
993: hr_utility.set_location('Indirects',10);
994:
995:
996: IF g_iter_rules(g_type + LEAST(NVL(g_rules(g_type).repeat,g_ctl.iter), g_ctl.iter)).ijss_payment = 'Y' THEN
997:

Line 1000: hr_utility.set_location('Indirects',11);

996: IF g_iter_rules(g_type + LEAST(NVL(g_rules(g_type).repeat,g_ctl.iter), g_ctl.iter)).ijss_payment = 'Y' THEN
997:
998: p_ijss_net := NVL(g_absence.ijss_net, 0);
999: p_ijss_payment := NVL(g_absence.ijss_payment, 0);
1000: hr_utility.set_location('Indirects',11);
1001: p_ijss_gross1 := NVL(g_coverages(g_ctl.g_idx).ijss_gross1, 0);
1002: p_ijss_gross2 := NVL(g_coverages(g_ctl.g_idx).ijss_gross2, 0);
1003: hr_utility.set_location('Indirects',12);
1004: p_ijss_gross1_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate1, 0);

Line 1003: hr_utility.set_location('Indirects',12);

999: p_ijss_payment := NVL(g_absence.ijss_payment, 0);
1000: hr_utility.set_location('Indirects',11);
1001: p_ijss_gross1 := NVL(g_coverages(g_ctl.g_idx).ijss_gross1, 0);
1002: p_ijss_gross2 := NVL(g_coverages(g_ctl.g_idx).ijss_gross2, 0);
1003: hr_utility.set_location('Indirects',12);
1004: p_ijss_gross1_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate1, 0);
1005: p_ijss_gross2_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate2, 0);
1006: hr_utility.set_location('Indirects',13);
1007: p_ijss_gross1_base := NVL(g_coverages(g_ctl.g_idx).ijss_gross_days1, 0);

Line 1006: hr_utility.set_location('Indirects',13);

1002: p_ijss_gross2 := NVL(g_coverages(g_ctl.g_idx).ijss_gross2, 0);
1003: hr_utility.set_location('Indirects',12);
1004: p_ijss_gross1_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate1, 0);
1005: p_ijss_gross2_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate2, 0);
1006: hr_utility.set_location('Indirects',13);
1007: p_ijss_gross1_base := NVL(g_coverages(g_ctl.g_idx).ijss_gross_days1, 0);
1008: p_ijss_gross2_base := NVL(g_coverages(g_ctl.g_idx).ijss_gross_days2, 0);
1009: hr_utility.set_location('Indirects',14);
1010: p_ijss_gross1_fromdate := g_coverages(g_ctl.g_idx).ijss_from_date1;

Line 1009: hr_utility.set_location('Indirects',14);

1005: p_ijss_gross2_rate := NVL(g_coverages(g_ctl.g_idx).ijss_gross_rate2, 0);
1006: hr_utility.set_location('Indirects',13);
1007: p_ijss_gross1_base := NVL(g_coverages(g_ctl.g_idx).ijss_gross_days1, 0);
1008: p_ijss_gross2_base := NVL(g_coverages(g_ctl.g_idx).ijss_gross_days2, 0);
1009: hr_utility.set_location('Indirects',14);
1010: p_ijss_gross1_fromdate := g_coverages(g_ctl.g_idx).ijss_from_date1;
1011: p_ijss_gross2_fromdate := g_coverages(g_ctl.g_idx).ijss_from_date2;
1012: p_ijss_gross1_todate := g_coverages(g_ctl.g_idx).ijss_to_date1;
1013: p_ijss_gross2_todate := g_coverages(g_ctl.g_idx).ijss_to_date2;

Line 1014: hr_utility.set_location('Indirects',15);

1010: p_ijss_gross1_fromdate := g_coverages(g_ctl.g_idx).ijss_from_date1;
1011: p_ijss_gross2_fromdate := g_coverages(g_ctl.g_idx).ijss_from_date2;
1012: p_ijss_gross1_todate := g_coverages(g_ctl.g_idx).ijss_to_date1;
1013: p_ijss_gross2_todate := g_coverages(g_ctl.g_idx).ijss_to_date2;
1014: hr_utility.set_location('Indirects',15);
1015: p_ijss_estmtd := NVL(g_absence.ijss_estimated, 'N');
1016: hr_utility.set_location('Indirects',16);
1017:
1018: ELSE

Line 1016: hr_utility.set_location('Indirects',16);

1012: p_ijss_gross1_todate := g_coverages(g_ctl.g_idx).ijss_to_date1;
1013: p_ijss_gross2_todate := g_coverages(g_ctl.g_idx).ijss_to_date2;
1014: hr_utility.set_location('Indirects',15);
1015: p_ijss_estmtd := NVL(g_absence.ijss_estimated, 'N');
1016: hr_utility.set_location('Indirects',16);
1017:
1018: ELSE
1019: p_ijss_net := 0;
1020: p_ijss_payment := 0;

Line 1031: hr_utility.set_location('Indirects',20);

1027: p_ijss_estmtd := 'U';
1028:
1029: END IF;
1030:
1031: hr_utility.set_location('Indirects',20);
1032:
1033: --
1034: --
1035: -- Pass value for the guaranteed income payment when appropriate.

Line 1072: hr_utility.set_location('Indirects',30);

1068:
1069:
1070: END IF;
1071:
1072: hr_utility.set_location('Indirects',30);
1073:
1074: --
1075: --
1076: -- Pass value for the sickness adjustment when appropriate.

Line 1089: hr_utility.set_location('Indirects',40);

1085: p_sick_adj := 0;
1086:
1087: END IF;
1088:
1089: hr_utility.set_location('Indirects',40);
1090:
1091: --
1092: --
1093: -- Pass value for the sickness deduction when appropriate.

Line 1111: hr_utility.set_location('Indirects',60);

1107: p_sick_deduct_base := 0;
1108:
1109: END IF;
1110:
1111: hr_utility.set_location('Indirects',60);
1112:
1113: --
1114: --
1115: -- Pass value for the guaranteed income adjustment when appropriate.

Line 1143: hr_utility.set_location('Indirects',65);

1139: p_gross_ijss_adj := 0;
1140:
1141: END IF;
1142:
1143: hr_utility.set_location('Indirects',65);
1144:
1145: --
1146: --
1147: -- Trigger the auditing when processing the final result NB. it is not needed when

Line 1160: hr_utility.set_location('Indirects',70);

1156: p_audit := 'N';
1157: -- Assign 0 to p_net
1158: p_net := 0;
1159: END IF;
1160: hr_utility.set_location('Indirects',70);
1161: --
1162: --
1163: -- Pass the ID for the absence.
1164: --

Line 1171: hr_utility.set_location('Indirects',100);

1167: --
1168: -- Simply return a value NB. declared as a function so it cab be used via a formula function.
1169: --
1170:
1171: hr_utility.set_location('Indirects',100);
1172:
1173: -- hr_utility.trace_off;
1174:
1175:

Line 1173: -- hr_utility.trace_off;

1169: --
1170:
1171: hr_utility.set_location('Indirects',100);
1172:
1173: -- hr_utility.trace_off;
1174:
1175:
1176: RETURN 0;
1177: EXCEPTION

Line 1179: hr_utility.set_location('iterate ',-10);

1175:
1176: RETURN 0;
1177: EXCEPTION
1178: WHEN OTHERS THEN
1179: hr_utility.set_location('iterate ',-10);
1180: hr_utility.trace(SQLCODE);
1181: hr_utility.trace(SQLERRM);
1182: -- hr_utility.trace_off;
1183: RAISE;

Line 1180: hr_utility.trace(SQLCODE);

1176: RETURN 0;
1177: EXCEPTION
1178: WHEN OTHERS THEN
1179: hr_utility.set_location('iterate ',-10);
1180: hr_utility.trace(SQLCODE);
1181: hr_utility.trace(SQLERRM);
1182: -- hr_utility.trace_off;
1183: RAISE;
1184:

Line 1181: hr_utility.trace(SQLERRM);

1177: EXCEPTION
1178: WHEN OTHERS THEN
1179: hr_utility.set_location('iterate ',-10);
1180: hr_utility.trace(SQLCODE);
1181: hr_utility.trace(SQLERRM);
1182: -- hr_utility.trace_off;
1183: RAISE;
1184:
1185: END indirects;

Line 1182: -- hr_utility.trace_off;

1178: WHEN OTHERS THEN
1179: hr_utility.set_location('iterate ',-10);
1180: hr_utility.trace(SQLCODE);
1181: hr_utility.trace(SQLERRM);
1182: -- hr_utility.trace_off;
1183: RAISE;
1184:
1185: END indirects;
1186: --

Line 1217: -- hr_utility.trace_on(NULL,'REQID');

1213: --
1214: --
1215: -- Return the audit values.
1216: --
1217: -- hr_utility.trace_on(NULL,'REQID');
1218: p_parent_abs_id := NVL(g_absence.parent_absence_id,0);
1219: p_guarantee_type := NVL(g_guarantee_type_lookups(g_coverages(g_ctl.audit_g_idx).g_type),'U');
1220: p_cagr_id := NVL(g_coverages(g_ctl.audit_g_idx).cagr_id,0);
1221: p_gi_payment := NVL(g_coverages(g_ctl.audit_g_idx).gi_payment1,0) + NVL(g_coverages(g_ctl.audit_g_idx).gi_payment2,0);

Line 1240: hr_utility.set_location('Audit',10);

1236: end if;
1237: --
1238: -- All the coverages have been audited so stop.
1239: --
1240: hr_utility.set_location('Audit',10);
1241: IF g_ctl.audit_g_idx = g_coverages.LAST THEN
1242: /* Assign 0 for Rate input */
1243: p_net := 0;
1244: p_audit := 'N';

Line 1261: hr_utility.set_location('Audit',100);

1257: -- Simply return a value NB. declared as a function so it cab be used via a formula function.
1258: --
1259: RETURN 0;
1260:
1261: hr_utility.set_location('Audit',100);
1262: -- hr_utility.trace_off;
1263: END audit;
1264:
1265: FUNCTION get_guarantee_id(

Line 1262: -- hr_utility.trace_off;

1258: --
1259: RETURN 0;
1260:
1261: hr_utility.set_location('Audit',100);
1262: -- hr_utility.trace_off;
1263: END audit;
1264:
1265: FUNCTION get_guarantee_id(
1266: P_type IN VARCHAR2 ) RETURN NUMBER is

Line 1284: hr_utility.set_location('Get Guarantee ID',50);

1280: -- Find the best method.
1281: --
1282: l_best := (NVL(g_guarantee_type_lookups(l_idx),'U') = p_type) ;
1283:
1284: hr_utility.set_location('Get Guarantee ID',50);
1285:
1286: --
1287: --
1288: -- Finish looping if All have been checked OR there is a best coverage

Line 1298: hr_utility.set_location('Get Gurantee ID',60);

1294: -- Move onto next guarantee.
1295: --
1296: l_idx := g_guarantee_type_lookups.NEXT(l_idx);
1297:
1298: hr_utility.set_location('Get Gurantee ID',60);
1299:
1300: END LOOP;
1301:
1302: IF(l_best) then

Line 1320: hr_utility.set_location('PAY_FR_SICK_PAY_PROCESSING',50);

1316: --
1317: --
1318: -- Setup the processing rules which control how each type of income guarantee is processed.
1319: --
1320: hr_utility.set_location('PAY_FR_SICK_PAY_PROCESSING',50);
1321: initialise_processing_rules;
1322: --
1323: --
1324: -- Setup the mapping between internal constants identifying each guarantee type with an

Line 1329: hr_utility.set_location('PAY_FR_SICK_PAY_PROCESSING',100);

1325: -- external reference (LOOKUP_CODE).
1326: --
1327: initialise_guarantee_lookups;
1328:
1329: hr_utility.set_location('PAY_FR_SICK_PAY_PROCESSING',100);
1330: END pay_fr_sick_pay_processing;