/*****************************************************************************

FORMULA NAME: BASIC_SALARY_EARN

FORMULA TYPE: Payroll

DESCRIPTION:
This is the formula for processing a flat amount earning element. The formula
assumes that the amounts and periodicity are available in element entries.
For a Salary element, the Salary and Periodicity are available in element entry,
that is created by Oracle Fusion Compensation.
This formula is created by Global Earnings template.

Formula Results :

l_value Direct Result for Earnings Pay Value.

l_reduce Direct Result for Earnings Reduce Regular Earnings.
mesg Warning message will be issued for this assignment.

Version Author Date Description

------- --------------- ----------- ---------------------------
1 Bhavesh 01-May-20 Created.
2 Rachit 15-Mar-21 Updated

*******************************************************************************/

/* Database Item Defaults */

DEFAULT FOR amount is 0

DEFAULT FOR mesg is ' '
DEFAULT FOR ENTRY_LEVEL IS 'AP'
DEFAULT FOR PAYROLL_PERIOD_TYPE IS ' '
DEFAULT FOR PAY_EARN_PERIOD_START is '0001/01/01 00:00:00' (date)
DEFAULT FOR PAY_EARN_PERIOD_END is '4712/12/31 00:00:00' (date)
DEFAULT FOR REDUCE_REGULAR_EARNINGS_ASG_RUN is 0
DEFAULT FOR REDUCE_REGULAR_EARNINGS_TRM_RUN IS 0
DEFAULT FOR KW_REDUCE_REGULAR_ABSENCE_EARNINGS_ASG_RUN is 0
DEFAULT FOR KW_REDUCE_REGULAR_ABSENCE_HOURS_ASG_RUN is 0
DEFAULT FOR BASIC_SALARY_SECONDARY_CLASSIFICATION IS ' '
DEFAULT FOR ASG_HR_ASG_ID is 0
DEFAULT FOR TERM_HR_TERM_ID is 0
DEFAULT FOR pay_value is 0
DEFAULT FOR ENTRY_CREATOR_TYPE IS ' '
DEFAULT FOR NET is 0
DEFAULT FOR PRORATION_METHOD IS 'X'
DEFAULT FOR PRORATION_CONVERSION_RULE IS 'X'
DEFAULT FOR PRORATE_START is '0001/01/01 00:00:00' (date)
DEFAULT FOR PRORATE_END is '0001/01/01 00:00:00' (date)
DEFAULT FOR reporting_unit IS 'X'
DEFAULT FOR WORK_UNITS_CONVERSION_RULE IS 'ANNUALIZED RATE CONVERSION'
DEFAULT FOR PERIODICITY_CONVERSION_RULE IS 'ANNUALIZED RATE CONVERSION'

/* Evosys Customization */
DEFAULT FOR ACP_TERMINATION_DATE is'4712/12/31 00:00:00' (date)
DEFAULT FOR ACP_HIRE_DATE IS '0001/01/01 00:00:00' (date)
DEFAULT FOR mesg3 is ' '
DEFAULT FOR mesg4 is ' '
Default for PER_ASG_REL_ATTRIBUTE_NUMBER1 is 0
Default for PER_ASG_REL_ATTRIBUTE1 is 'XX'
Default for ANNUAL_LEAVE_ENTITLEMENT_DAYS_ASG_MTD is 0
Default for Total_working_days_in_a_Month is 0

/* Evosys Customization */
/* Inputs */
INPUTS ARE amount (number),
periodicity (text),
reduce_regular (text),
pay_value(number),
new_guess(number),
additional_amount(number),
guess(number),
first_run(number),
net(number),
proration_method(text),
WORK_UNITS_CONVERSION_RULE(text),
PRORATION_CONVERSION_RULE(text),
PERIODICITY_CONVERSION_RULE(text),
reporting_unit(text),
prorate_start,
prorate_end

if (net = 0 and net was defaulted) then (

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN)Initializing the Flat Amount Earnings

Formula')

l_amount = amount
l_value = 0
l_reduce = 0
l_reduce_hours = 0
l_reduce_abs = 0
l_reduce_hours_abs = 0
l_reduce_abs_hours = 0
l_hours = 0
l_days =0
l_actual_amount = 0
l_actual_start_date = '0001/01/01 00:00:00' (Date)
l_actual_end_date = '0001/01/01 00:00:00' (Date)

l_fte=1

l_prorate_start = prorate_start
l_prorate_end = prorate_end

/* Assigning the Values to the local variables*/

l_actual_start_date = PAY_EARN_PERIOD_START
l_actual_end_date = PAY_EARN_PERIOD_END
l_secondary_classification = BASIC_SALARY_SECONDARY_CLASSIFICATION
l_source_periodicity = periodicity

l_payroll_rel_action_id = 0
l_report_unit= reporting_unit
l_target_periodicity=PAYROLL_PERIOD_TYPE

/* Key Variable values retrival*/

l_element_entry_id = GET_CONTEXT(ELEMENT_ENTRY_ID, 0)

l_payroll_rel_action_id = GET_CONTEXT(PAYROLL_REL_ACTION_ID, 0)

l_date_earned = GET_CONTEXT(DATE_EARNED, PAY_EARN_PERIOD_END)

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) l_date_earned = '||

to_char(l_date_earned))

IF l_payroll_rel_action_id = 0 THEN
(
l_msg =
GET_MESG('HRX','HRX_USETE_CONTEXT_NOT_SET','CONTEXT','PAYROLL_REL_ACTION_ID')
l_log = PAY_LOG_ERROR(l_msg)
/* dummy = 1 */
/* Formula must error out at this point */
)

/* avoid unnecessary conversion to Workhour Workday*/

IF ( l_source_periodicity = 'ORA_WORKHOUR') THEN
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) set source periodicity Workhour')
l_source_periodicity = 'Workhour'
)

ELSE IF ( l_source_periodicity = 'ORA_WEEKDAY') THEN (

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) set source periodicity Workday')
l_source_periodicity = 'Workday'
)

IF l_element_entry_id = 0 THEN
(
l_msg =
GET_MESG('HRX','HRX_USETE_CONTEXT_NOT_SET','CONTEXT','ELEMENT_ENTRY_ID')
l_log = PAY_LOG_ERROR( l_msg)
/* dummy = 1 */
/* Formula must error out at this point */
)

was_payroll_rel_action_id=0
If wsa_exists('WAS_REL_ACTION_ID','NUMBER' ) then
( was_payroll_rel_action_id = WSA_GET('WAS_REL_ACTION_ID',0) )

/* for ADD REPORT WORK UNIT CHECK BEFORE REDUCE REGULAR */

GLB_REPORT_UNIT_KEY = 'REPORT_UNIT_'||ENTRY_LEVEL||'-'||
TO_CHAR(l_element_entry_id)||'-'|| TO_CHAR(l_payroll_rel_action_id)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_REPORT_UNIT_KEY ' ||
GLB_REPORT_UNIT_KEY)
if( was_payroll_rel_action_id <> l_payroll_rel_action_id )then
(
 l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Payroll Rel Action ID in WAS : '||
TO_CHAR(was_payroll_rel_action_id))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Payroll Rel Action ID in Current run :
'||TO_CHAR(l_payroll_rel_action_id))

WSA_DELETE('proration_method')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear proration_method in WSA')
/* for ADD REPORT WORK UNIT CHECK BEFORE REDUCE REGULAR */
WSA_DELETE(GLB_REPORT_UNIT_KEY)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear l_report_unit in WSA')

WSA_DELETE('WORK_UNITS_CONVERSION_RULE')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear WORK_UNITS_CONVERSION_RULE in
WSA')
WSA_DELETE('PERIODICITY_CONVERSION_RULE')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear PERIODICITY_CONVERSION_RULE in
WSA')
WSA_DELETE('PRORATION_CONVERSION_RULE')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear PRORATION_CONVERSION_RULE in
WSA')
WSA_DELETE('source_periodicity')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear source_periodicity in WSA')
WSA_DELETE('target_periodicity')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Clear target_periodicity in WSA')
wsa_set('WAS_REL_ACTION_ID' ,GET_CONTEXT(PAYROLL_REL_ACTION_ID, 0))
)

if (proration_method was not defaulted) then (

IF (WSA_EXISTS('proration_method','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for proration_method')
wsa_proration_method = WSA_GET('proration_method', EMPTY_TEXT_NUMBER)
)
wsa_proration_method[l_element_entry_id] = proration_method
WSA_SET('proration_method',wsa_proration_method)
)
/* for ADD REPORT WORK UNIT CHECK BEFORE REDUCE REGULAR */
WSA_SET(GLB_REPORT_UNIT_KEY, l_report_unit)

IF (WSA_EXISTS('WORK_UNITS_CONVERSION_RULE','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for
WORK_UNITS_CONVERSION_RULE')
was_WORK_UNITS_CONVERSION_RULE = WSA_GET('WORK_UNITS_CONVERSION_RULE',
EMPTY_TEXT_NUMBER)
)
was_WORK_UNITS_CONVERSION_RULE[l_element_entry_id] = WORK_UNITS_CONVERSION_RULE
WSA_SET('WORK_UNITS_CONVERSION_RULE',was_WORK_UNITS_CONVERSION_RULE)

IF (WSA_EXISTS('PERIODICITY_CONVERSION_RULE','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for
PERIODICITY_CONVERSION_RULE')
was_PERIODICITY_CONVERSION_RULE = WSA_GET('PERIODICITY_CONVERSION_RULE',
EMPTY_TEXT_NUMBER)
)
 was_PERIODICITY_CONVERSION_RULE[l_element_entry_id] = PERIODICITY_CONVERSION_RULE
WSA_SET('PERIODICITY_CONVERSION_RULE',was_PERIODICITY_CONVERSION_RULE)

if (PRORATION_CONVERSION_RULE ='X') then (

PRORATION_CONVERSION_RULE=WORK_UNITS_CONVERSION_RULE
)

IF (WSA_EXISTS('PRORATION_CONVERSION_RULE','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for
PRORATION_CONVERSION_RULE')
was_proration_rate_formula = WSA_GET('PRORATION_CONVERSION_RULE',
EMPTY_TEXT_NUMBER)
)
was_proration_rate_formula[l_element_entry_id] = PRORATION_CONVERSION_RULE
WSA_SET('PRORATION_CONVERSION_RULE',was_proration_rate_formula)

/* If pay value is already set, no further processing required for pay value */
IF (pay_value = 0 and pay_value was defaulted ) THEN
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) l_source_periodicity :'||
l_source_periodicity)

/* Element Template will convert hourly/daily into workhour/workday*/

if (l_source_periodicity='Hourly') then (
l_source_periodicity='WORKHOUR'
)

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) ENTRY LEVEL IS ' ||ENTRY_LEVEL)

IF ( ENTRY_LEVEL = 'AP') THEN
(
l_term_assignment_id = TERM_HR_TERM_ID
SET_INPUT('HR_ASSIGN_ID',l_term_assignment_id)
)
ELSE IF ( ENTRY_LEVEL = 'PA') THEN (
l_term_assignment_id = ASG_HR_ASG_ID
SET_INPUT('HR_ASSIGN_ID',l_term_assignment_id)
)

/** if it is 1$ per Unit, then how many $$ for Pay Period.. The $$ amount is the
number of Units Worked **/

if (l_report_unit = 'ORA_WORKDAYS') then (

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) rate conversion formula is :'||

WORK_UNITS_CONVERSION_RULE)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) target periodicity is :'||
l_target_periodicity)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) reporting unit :'||l_report_unit)

CALL_FORMULA('RATE_CONVERTER',
1 > 'SOURCE_AMOUNT',
WORK_UNITS_CONVERSION_RULE> 'method',
'WORKDAY' > 'SOURCE_PERIODICITY',
l_target_periodicity > 'TARGET_PERIODICITY',
l_date_earned > 'effdate',
l_actual_start_date > 'start_date',
 l_actual_end_date > 'end_date',
l_days < 'TARGET_AMOUNT' DEFAULT 0
)

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) reporting unit is days :'||

TO_CHAR(l_days))

else if (l_report_unit='ORA_HOURSWORK') then (

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) rate conversion formula is :'||
WORK_UNITS_CONVERSION_RULE)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) target periodicity is :'||
l_target_periodicity)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) reporting unit :'||l_report_unit)

CALL_FORMULA('RATE_CONVERTER',
1 > 'SOURCE_AMOUNT',
WORK_UNITS_CONVERSION_RULE> 'method',
'WORKHOUR' > 'SOURCE_PERIODICITY',
l_target_periodicity > 'TARGET_PERIODICITY',
l_date_earned > 'effdate',
l_actual_start_date > 'start_date',
l_actual_end_date > 'end_date',
l_hours < 'TARGET_AMOUNT' DEFAULT 0
)

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) reporting unit is hours :'||

TO_CHAR(l_hours))

IF (l_source_periodicity = 'PRD') THEN

(
l_value = l_amount
)
else
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Amount : '||TO_CHAR(l_amount))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN)Source Periodicity : '||
l_source_periodicity)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN)Target periodicity : '||
l_target_periodicity)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Parameter Initialization for Rate
Converter Call')
CALL_FORMULA('RATE_CONVERTER',
l_amount > 'SOURCE_AMOUNT',
PERIODICITY_CONVERSION_RULE> 'method',
l_source_periodicity > 'SOURCE_PERIODICITY',
l_target_periodicity > 'TARGET_PERIODICITY',
l_date_earned > 'effdate',
l_actual_start_date > 'start_date',
l_actual_end_date > 'end_date',
l_convert_amount < 'TARGET_AMOUNT' DEFAULT 0
)
l_value=l_convert_amount
 l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Convert amount :'||
TO_CHAR(l_convert_amount))
)

) /* for IF of pay_value = 0 */
else
(
l_value = pay_value
)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Value : '||TO_CHAR(l_value))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) l_hours : '||TO_CHAR(l_hours))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) l_days : '||TO_CHAR(l_days))

/* Reduce Regular earnings due to Absence payments - Processing begins */

IF (ENTRY_CREATOR_TYPE = 'SP') THEN
(

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN)
KW_REDUCE_REGULAR_ABSENCE_EARNINGS_ASG_RUN entered: ')
/* Use the appropriate balance based on the employment level for the given
element.*/
IF ( ENTRY_LEVEL = 'PA') THEN
(
l_reduce_abs_days = KW_REDUCE_REGULAR_ABSENCE_DAYS_ASG_RUN
l_reduce_abs_hours = KW_REDUCE_REGULAR_ABSENCE_HOURS_ASG_RUN
l_reduce_abs = KW_REDUCE_REGULAR_ABSENCE_EARNINGS_ASG_RUN
)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce_abs ='||
to_char(l_reduce_abs))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce abs hours='||
to_char(l_reduce_abs_hours))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce abs days='||
to_char(l_reduce_abs_days))

/* Check prorate start date and prorate end date to decide if there is a proration
event. If there is a event, Reduce regular will be processed in the proration
formula and will be skipped in base formula */
IF ((prorate_start was not defaulted or prorate_end was not defaulted) and
(prorate_start<>PAY_EARN_PERIOD_START or prorate_end <>PAY_EARN_PERIOD_END)) then
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) This Element have proration,
Reduce Regular moved to Proration Formula')
/* Preparing Key for Absence Reduce Earnings and Absence Reduce Hours */

GLB_ABS_EARN_REDUCE_KEY = ENTRY_LEVEL||'-'||TO_CHAR(l_element_entry_id)||'-'||
TO_CHAR(l_payroll_rel_action_id)||'_ABSENCE'
l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_ABS_EARN_REDUCE_KEY '||
GLB_ABS_EARN_REDUCE_KEY)

GLB_ABS_EARN_REDUCE_EARNING_KEY = 'EARNING_'||GLB_ABS_EARN_REDUCE_KEY
l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_ABS_EARN_REDUCE_EARNING_KEY ' ||
GLB_ABS_EARN_REDUCE_EARNING_KEY)

GLB_ABS_EARN_REDUCE_EARNING_DAYS_KEY = 'DAY_'||GLB_ABS_EARN_REDUCE_KEY
l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_ABS_EARN_REDUCE_EARNING_DAYS_KEY '
||GLB_ABS_EARN_REDUCE_EARNING_DAYS_KEY)
 GLB_ABS_EARN_REDUCE_EARNING_HOURS_KEY = 'HOUR_'||GLB_ABS_EARN_REDUCE_KEY
l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_ABS_EARN_REDUCE_EARNING_HOURS_KEY
' ||GLB_ABS_EARN_REDUCE_EARNING_HOURS_KEY)

/* Setting Payvalue and hours in WSA*/

WSA_SET(GLB_ABS_EARN_REDUCE_EARNING_KEY,l_reduce_abs)

WSA_SET(GLB_ABS_EARN_REDUCE_EARNING_HOURS_KEY,l_reduce_abs_hours)

WSA_SET(GLB_ABS_EARN_REDUCE_EARNING_DAYS_KEY,l_reduce_abs_days)
)
else
(
if (l_report_unit='ORA_HOURSWORK') then
(
If l_reduce_abs_hours <= l_hours Then
(
l_hours = l_hours - l_reduce_abs_hours
)
Else
(
l_reduce_abs_hours = l_hours
l_hours = 0
/* mesg = 'Insufficient hours to reduce for Absence hours' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)
if (l_report_unit = 'ORA_WORKDAYS') then
(
If l_reduce_abs_days <= l_days Then
(
l_days = l_days - l_reduce_abs_days
)
Else
(
l_reduce_abs_days = l_days
l_days = 0
/* mesg = 'Insufficient days to reduce for Absence days' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)
If l_reduce_abs <= l_value then
(
l_value = l_value - l_reduce_abs
)
Else
(
l_reduce_abs = l_value
l_value = 0
/* mesg = 'Insufficient earnings to reduce for Absence Payment' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)
)
/* Reduce Regular Absences processing ends */
 /* Reduce Regular earnings by Vacation element (created using a earning
classfication) */

/****************************************************************************
This logic will be executed when the employee's regular salary needs
to be reduced. For example, this may happen when employee might have taken
Vacation Pay or Sick Pay and it reduces the regular salary.
The regular salary element being reduced, is created via Compensation and in
addition
it's secondary classification cannot be REGULAR_NOT_WORKED, for
the formula to pick up for reducing it. The vacation element(reducing element) is
typically
Units X Rate earning element. Reducing due to Absences element is covered below
this section.
****************************************************************************/

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) REDUCE_REGULAR_EARNINGS_ASG_RUN

before: ')
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Secondary classification = ' ||
l_secondary_classification )
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) creator_type = ' ||
ENTRY_CREATOR_TYPE )
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce Regular Calculation Begins')

IF (l_secondary_classification <> 'Standard Earnings Regular Not Worked' AND

ENTRY_CREATOR_TYPE = 'SP') THEN
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) REDUCE_REGULAR_EARNINGS_ASG_RUN
entered: ')
/* Use the appropriate balance based on the employment level for the given
element.*/
IF ( ENTRY_LEVEL = 'PA') THEN
(
l_reduce_days = REDUCE_REGULAR_DAYS_ASG_RUN
l_reduce_hours = REDUCE_REGULAR_HOURS_ASG_RUN
l_reduce = REDUCE_REGULAR_EARNINGS_ASG_RUN
)
ELSE IF ( ENTRY_LEVEL = 'AP') THEN
(
l_reduce_days = REDUCE_REGULAR_DAYS_TRM_RUN
l_reduce_hours = REDUCE_REGULAR_HOURS_TRM_RUN
l_reduce = REDUCE_REGULAR_EARNINGS_TRM_RUN
)
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce ='||to_char(l_reduce))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce hours='||
to_char(l_reduce_hours))
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Reduce days='||to_char(l_reduce_days))
/* Check prorate start date and prorate end date to decide if there is a
proration event. If there is a event, Reduce regular will be processed in the
proration formula and will be skipped in base formula */
IF((prorate_start was not defaulted or prorate_end was not defaulted) and
(prorate_start<>PAY_EARN_PERIOD_START or prorate_end <>PAY_EARN_PERIOD_END)) then
(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) This Element have proration,
Reduce Regular moved to Proration Formula')
/* Preparing Key for Reduce Earnings and Hours */

GLB_EARN_REDUCE_KEY = ENTRY_LEVEL||'-'||TO_CHAR(l_element_entry_id)||'-'||
TO_CHAR(l_payroll_rel_action_id)
 l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_EARN_REDUCE_KEY '||
GLB_EARN_REDUCE_KEY)

GLB_EARN_REDUCE_EARNING_KEY = 'EARNING_'||GLB_EARN_REDUCE_KEY
l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_EARN_REDUCE_EARNING_KEY ' ||
GLB_EARN_REDUCE_EARNING_KEY)

GLB_EARN_REDUCE_HOURS_KEY = 'HOUR_'|| GLB_EARN_REDUCE_KEY

l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_EARN_REDUCE_HOURS_KEY ' ||
GLB_EARN_REDUCE_HOURS_KEY)

GLB_EARN_REDUCE_DAYS_KEY = 'DAY_'|| GLB_EARN_REDUCE_KEY

l_log =PAY_INTERNAL_LOG_WRITE('(GLBEARN) GLB_EARN_REDUCE_DAYS_KEY ' ||
GLB_EARN_REDUCE_DAYS_KEY)

/* Setting Payvalue and hours in WSA*/

WSA_SET(GLB_EARN_REDUCE_EARNING_KEY,l_reduce)
WSA_SET(GLB_EARN_REDUCE_HOURS_KEY,l_reduce_hours)
WSA_SET(GLB_EARN_REDUCE_DAYS_KEY,l_reduce_days)

)
else
(
if (l_report_unit='ORA_HOURSWORK') then
(
If l_reduce_hours <= l_hours Then
(
l_hours = l_hours - l_reduce_hours
)
Else
(
l_reduce_hours = l_hours
l_hours = 0
/* mesg = 'Insufficient hours to reduce' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)
if (l_report_unit = 'ORA_WORKDAYS') then
(
If l_reduce_days <= l_days Then
(
l_days = l_days - l_reduce_days
)
Else
(
l_reduce_days = l_days
l_days = 0
/* mesg = 'Insufficient days to reduce ' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)
If l_reduce <= l_value then
(
l_value = l_value - l_reduce
)
Else
(
 l_reduce = l_value
l_value = 0
/* mesg = 'Insufficient earnings to reduce' */
mesg = GET_MESG('PAY','PAY_RED_REG_LIMIT')
l_log = PAY_LOG_WARNING('PAY:PAY_RED_REG_LIMIT')
)
)

)
/*
** Before setting each array in the Working Storage Area
** We need to first check if each one already exists, and if so, retrieve it to
add the new values.
*/
IF (WSA_EXISTS('source_periodicity','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for
source_periodicity')
wsa_source_periodicity = WSA_GET('source_periodicity', EMPTY_TEXT_NUMBER)
)
wsa_source_periodicity[l_element_entry_id] = l_source_periodicity
WSA_SET('source_periodicity',wsa_source_periodicity)

IF (WSA_EXISTS('target_periodicity','TEXT_NUMBER')) THEN
(
log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) - Array found for
target_periodicity')
wsa_target_periodicity = WSA_GET('target_periodicity', EMPTY_TEXT_NUMBER)
)
wsa_target_periodicity[l_element_entry_id] = l_target_periodicity
WSA_SET('target_periodicity',wsa_target_periodicity)

l_log = PAY_INTERNAL_LOG_WRITE('(GLBEARN) Derived value : '||TO_CHAR(l_value))

/*********************************** Evosys added logic starts here

************************************************/
full_month_amount = 0
l_weekly_off = ' '
l_text = ' '
l_ph_days_flag = ' '
l_weekly_off_flag = ' '
l_value_set = ' '
l_abs_count = 0
l_person_id = GET_CONTEXT(PERSON_ID, 0)
working_days = 0
Total_working_days_in_a_Month = 0
mesg4 = 'New' + to_Char(prorate_start) + to_Char(prorate_end) + 'pay-start' +
to_char(PAY_EARN_PERIOD_START) + 'pay-end' + to_char(PAY_EARN_PERIOD_END)

/*IF (prorate_start was not defaulted or prorate_end was not defaulted) then
(*/
l_hr_term_id = ASG_HR_ASG_ID
SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',PAY_EARN_PERIOD_END)
SET_INPUT ('mode','PER_ASG_PEOPLE_GROUP_SEGMENT11')
EXECUTE('XX_GET_HR_DATA')
weekly_off = GET_OUTPUT('X_OUTPUT_TEXT', l_text)
weekly_off = UPPER(substr(weekly_off, 0, 3))
pro_days = days_between(prorate_end,prorate_start)
w_count = 0

l_log = PAY_INTERNAL_LOG_WRITE('basic Salary Formula : PAY_EARN_PERIOD_START : '||

TO_CHAR(PAY_EARN_PERIOD_START,'DD/MM/YYYY'))
l_log = PAY_INTERNAL_LOG_WRITE('basic Salary Formula : PAY_EARN_PERIOD_END : '||
TO_CHAR(PAY_EARN_PERIOD_END,'DD/MM/YYYY'))
l_log = PAY_INTERNAL_LOG_WRITE('basic Salary Formula : prorate_start : '||
TO_CHAR(prorate_start,'DD/MM/YYYY'))
l_log = PAY_INTERNAL_LOG_WRITE('basic Salary Formula : prorate_end : '||
TO_CHAR(prorate_end,'DD/MM/YYYY'))

/* this IF condition checks for PRORATIOIN CASE 1 */

if(prorate_start = PAY_EARN_PERIOD_START AND prorate_end <> PAY_EARN_PERIOD_END)
then
(
while(prorate_start <= prorate_end) LOOP
(
dow1 = get_date_day_of_Week(to_date(to_char(prorate_start,'DD-MM-
YYYY'),'DD-MM-YYYY'))
if(dow1 = weekly_off) then
(
w_count = w_count + 1
)
prorate_start = add_days(prorate_start,1)
)

start_date = PAY_EARN_PERIOD_START
p_diff = days_between(prorate_end,start_date) + 1

p_days1 = p_diff - w_count

l_log676= ess_log_write('p_days1 1st half before else --> '+to_Char(p_days1))

p1 = (l_value/26) * p_days1
l_log6726= ess_log_write('p1 1st half --> '+to_Char(p1))

p_days_old = p_days1

mesg4 = mesg4 + 'p1--' + to_char(ROUND(p1,2))

L_value = p1
mesg4 = mesg4 + 'L_value--' + to_char(ROUND(L_value,2))
/*
l_start_date = PAY_EARN_PERIOD_START
l_end_date = prorate_end

l_log11126 = ess_log_write('l_start_date ----> ' + TO_CHAR(l_start_date))

l_log11136 = ess_log_write('l_end_date ----> ' + TO_CHAR(l_end_date))
l_log11116 = ess_log_write(' Entering While loop')

while(l_start_date <= l_end_date) LOOP

(
l_log111246 = ess_log_write('WHILE l_start_date ----> ' +
to_char(l_start_date))

l_hr_term_id = ASG_HR_ASG_ID
SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',l_start_date)
SET_INPUT ('mode','GET_PAY_AVAILABILITY_ANNUAL')
EXECUTE('XX_GET_HR_DATA')
 l_day_duration = GET_OUTPUT('X_OUTPUT_NUMBER', -2)
l_log111356 = ess_log_write('l_day_duration ----> ' +
to_char(l_day_duration))

L_P_DATE = To_char(l_start_date,'YYYY/MM/DD')
L_flag = GET_VALUE_SET('XXDH_PUBLIC_HOLIDAY_VS','|=P_DATE='''||
L_P_DATE||'''')
l_log1113576 = ess_log_write('PUBLIC HOLIDAY L_flag ----> ' + L_flag)

*/

/* this IF condition checks for PRORATIOIN CASE 2 */

if(prorate_start <> PAY_EARN_PERIOD_START AND prorate_end = PAY_EARN_PERIOD_END)
then
(
w_count = 0
l_Month_Start = PAY_EARN_PERIOD_START
log353=ess_log_write('l_Month_Start -----> ' + to_Char(l_Month_Start))

l_Month_End = PAY_EARN_PERIOD_END
log353=ess_log_write('l_Month_End -----> ' + to_Char(l_Month_End))

while (l_Month_Start <= l_Month_End) LOOP

(
dow1 = get_date_day_of_Week(to_date(to_char(l_Month_Start,'DD-MM-
YYYY'),'DD-MM-YYYY'))
IF (dow1 = weekly_off) THEN
(
w_count = w_count + 1
)
l_Month_Start = add_days(l_Month_Start,1)
log353=ess_log_write('l_Month_Start add_days(l_Month_Start,1)
-----> ' + to_Char(l_Month_Start))
)

L_days_in_Month = TO_NUMBER(TO_CHAR(PAY_EARN_PERIOD_END, 'DD' ))

log332 = ess_log_write('L_days_in_Month in basic -----> ' +
to_Char(L_days_in_Month))

l_Working_Days = L_days_in_Month - w_count

log356=ess_log_write('l_Working_Days in basic -----> ' +
to_Char(l_Working_Days))

pay_days = 0

p_reference = prorate_end
log676921=Ess_log_write(' p_reference CASE2 --> ' +
to_char(p_reference))

pro2_days = days_between(p_reference,prorate_start) + 1
log67692=Ess_log_write(' pro2_days CASE2 --> ' + to_char(pro2_days))

pro_start = prorate_start
log67639=Ess_log_write(' pro_start CASE2 --> ' + to_char(pro_start))
 w_count = 0

while (pro_start < p_reference) LOOP

(
dow1 = get_date_day_of_Week(to_date(to_char(pro_start,'DD-MM-
YYYY'),'DD-MM-YYYY'))
if(dow1 = weekly_off) then
(
w_count = w_count + 1
log67269=Ess_log_write(' w_count CASE2 --> ' +
to_char(w_count))
)
pro_start = add_days(pro_start,1)
)

pay_days = pro2_days - w_count

log6769=Ess_log_write(' pay_days = New working days , basic --> ' +
to_char(pay_days))

Total_working_days_in_a_Month = 0

working_Old_days = l_Working_Days - pay_days

log6769=Ess_log_write(' working_Old_days , basic --> ' +
to_char(pay_days))

Total_working_days_in_a_Month = working_Old_days + pay_days

log6769=Ess_log_write(' Total_working_days_in_a_Month , basic --> ' +
to_char(Total_working_days_in_a_Month))

if (Total_working_days_in_a_Month = 26) THEN

(
pay_days = pay_days
log6769=Ess_log_write(' If Basic salary changes then New Days if
Total_working_days_in_a_Month = 26 --> ' + to_char(pay_days))
)
ELSE
(
pay_days = 26 - working_Old_days
log6769=Ess_log_write(' If Basic salary changes then New Days if
Total_working_days_in_a_Month <> 26 --> --> ' + to_char(pay_days))
)

p1 = (l_value/26) * pay_days
log67629=Ess_log_write(' p1 CASE2 --> ' + to_char(p1))
mesg4 = mesg4 + 'p1--' + to_char(ROUND(p1,2))
L_value = p1
mesg4 = mesg4 + 'L_value--' + to_char(ROUND(L_value,2))
mesg4 = mesg4 + '_l_value_' || to_char(p1)||'days2'||to_char(pay_days) +
'weekly_off' + weekly_off
mesg4 = mesg4 + 'p_ref--' +to_char(p_reference) + 'pro2_days--' +
to_char(pro2_days) + 'w_count--' + to_char(w_count)
)
mesg4 = mesg4 + 'main if'
/*)*/

mesg = 'Basic Salary -->'

mesg3 = 'W_days_logic'

/* Proration during termination Logic */

L_Agreed_Notice_Days = 0
l_number = 0
L_Work_Full_Notice_Period = ' '
l_date1 = '0001/01/01 00:00:00' (date)

if ACP_TERMINATION_DATE was not defaulted then

l_eff_date = least (ACP_TERMINATION_DATE,PAY_EARN_PERIOD_END)
else
l_eff_date = PAY_EARN_PERIOD_END

l_hr_term_id = ASG_HR_ASG_ID

/* Logic to get notice start date from HR data ff*/

SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',l_eff_date)
SET_INPUT ('mode','PER_ASG_REL_ATTRIBUTE_DATE1')
EXECUTE('XX_GET_HR_DATA')
l_notice_start_date = GET_OUTPUT('X_OUTPUT', l_date1)
mesg = mesg + ' l_notice_start_date:' + to_char(l_notice_start_date)

/* Logic to get notice End date from HR data ff*/

SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',l_eff_date)
SET_INPUT ('mode','PER_ASG_REL_ATTRIBUTE_DATE2')
EXECUTE('XX_GET_HR_DATA')
l_notice_end_date = GET_OUTPUT('X_OUTPUT', l_date1)
mesg = mesg + ' l_notice_end_date:' + to_char(l_notice_end_date)

/* Logic to get contract type from HR data ff*/

L_Contract_type=' '
SET_INPUT ('hr_id', ASG_HR_ASG_ID)
SET_INPUT ('eff_date', PAY_EARN_PERIOD_END)
SET_INPUT ('mode','PER_ASG_CONTRACT_TYPE')
EXECUTE('XX_GET_HR_DATA')
L_Contract_type = GET_OUTPUT('X_OUTPUT_TEXT',l_text)
mesg = mesg + '__Contract_type__' + (L_Contract_type)

/* Logic to get Termination action name from HR data ff*/

L_Termination_Action='XX'
SET_INPUT ('hr_id', ASG_HR_ASG_ID)
SET_INPUT ('eff_date', PAY_EARN_PERIOD_END)
SET_INPUT ('mode','PER_PER_TERMINATION_ACTION_NAME')
EXECUTE('XX_GET_HR_DATA')
L_Termination_Action = GET_OUTPUT('X_OUTPUT_TEXT', l_text)
mesg = mesg + '_Action_' + (L_Termination_Action)

/* Logic to get Contract end date from HR data ff*/

L_contract_End_date='0001/01/01 00:00:00' (Date)
SET_INPUT ('hr_id', ASG_HR_ASG_ID)
SET_INPUT ('eff_date', PAY_EARN_PERIOD_END)
SET_INPUT ('mode','PER_ASG_CONTRACT_END_DATE')
EXECUTE('XX_GET_HR_DATA')
L_contract_End_date = GET_OUTPUT('X_OUTPUT',l_date1)
mesg = mesg + '__Contract_End_date__' + to_char(L_contract_End_date)
mesg = mesg + 'hire_date' + to_char(ACP_HIRE_DATE) + 'term_date' +
to_char(ACP_TERMINATION_DATE)
/* Worked days calculation logic added */
l_hr_term_id = ASG_HR_ASG_ID
SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',PAY_EARN_PERIOD_END)
SET_INPUT ('mode','PER_ASG_PEOPLE_GROUP_SEGMENT11')
EXECUTE('XX_GET_HR_DATA')
l_weekly_off = GET_OUTPUT('X_OUTPUT_TEXT', l_text)
l_weekly_off = UPPER(substr(l_weekly_off, 0, 3))
l_date_start = PAY_EARN_PERIOD_START
l_person_id = GET_CONTEXT(PERSON_ID, 0)
l_abs_count = 0
l_day_duration = -2
L_P_DATE = ' '
L_flag = ' '
l_abs_count = 0
l_pay_start_date = PAY_EARN_PERIOD_START

/* this IF condition checks for PRORATIOIN CASE 1 and CASE 2 for WEEK OFF COUNT Ans
Annual */
if(prorate_start was not defaulted OR prorate_end was not defaulted) then
(
l_start_date = prorate_start
l_end_date = prorate_end

l_log1112 = ess_log_write('l_start_date ----> ' + To_char(l_start_date))

l_log1113 = ess_log_write('l_end_date ----> ' + To_char(l_end_date))
l_log1111 = ess_log_write(' Entering While loop')

/* this IF condition checks for PRORATIOIN CASE 1 WEEKOFF */

if(l_start_date >= l_end_date) THEN
(
WHILE (l_pay_start_date <= l_end_date) LOOP
(
l_log11124 = ess_log_write('WHILE l_start_date ----> ' +
to_char(l_pay_start_date))

l_hr_term_id = ASG_HR_ASG_ID
SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',l_pay_start_date)
SET_INPUT ('mode','GET_PAY_AVAILABILITY_ANNUAL')
EXECUTE('XX_GET_HR_DATA')
l_day_duration = GET_OUTPUT('X_OUTPUT_NUMBER', -2)
l_log11135 = ess_log_write('l_day_duration ----> ' +
to_char(l_day_duration))

L_P_DATE = To_char(l_pay_start_date,'YYYY/MM/DD')
L_flag = GET_VALUE_SET('XXDH_PUBLIC_HOLIDAY_VS','|=P_DATE='''||
L_P_DATE||'''')
l_log111357 = ess_log_write('PUBLIC HOLIDAY L_flag ----> ' + L_flag)

/* if l_day_duration = 0 means, That day is weekoff or public

holiday*/
If l_day_duration = 0 then
(
/* CHECKING every date FOR WEEKLY OFF FLAG YES OR NO and : l_PH =
yes or no and l_weeklyoff = yes or no */
dow2 = get_date_day_of_Week(to_date(to_char(l_pay_start_date,'DD-
MM-YYYY'),'DD-MM-YYYY'))
 l_log111357 = ess_log_write(' DAY OF WEEK dow2 ----> ' + dow2)

if(dow2 = weekly_off) then

l_weekly_off_flag = 'YES'
else
l_ph_days_flag = 'YES'

/* IF it is weekoff and public holiday*/

if ((dow2 = weekly_off) AND (L_flag = 'PH')) THEN
(
l_ph_days_flag = 'YES'
l_weekly_off_flag = 'YES'
)

l_log1113577 = ess_log_write('After checking: l_weekly_off_flag

----> ' + l_weekly_off_flag)
l_log11135778 = ess_log_write('After checking: l_ph_days_flag ---->
' + l_ph_days_flag)
)

/* if l_day_duration = 1 means, That day is working day*/

If l_day_duration = 1 then
(
l_ph_days_flag = 'NO'
l_weekly_off_flag = 'NO'
)

/* CHECKING FOR ANNUAL LEAVE COUNT FROM VALUE SET*/

l_value_set = GET_VALUE_SET('Dhaman_Annual_leave_count_vs','|
=P_PERSON_ID='''||TO_CHAR(l_person_id)||''''||'|P_DATE='''||
TO_CHAR(l_pay_start_date,'YYYY/MM/DD')||'''')
l_log21113577897 = ess_log_write('l_value_set ----> ' + l_value_set)

IF(l_weekly_off_flag = 'NO' AND l_ph_days_flag = 'NO' AND

ISNULL(l_value_set) = 'Y') THEN
(
l_abs_count = l_abs_count + 1
l_log111357789 = ess_log_write('l_abs_count ----> ' +
to_char(l_abs_count))
)
l_pay_start_date = ADD_DAYS(l_pay_start_date,1)
)
)
else /* this ELSE condition checks for PRORATIOIN CASE 2 WEEKOFF */
(
WHILE (l_start_date <= l_end_date) LOOP
(
l_log11124 = ess_log_write('WHILE l_start_date ----> ' +
to_char(l_start_date))

l_hr_term_id = ASG_HR_ASG_ID
SET_INPUT ('hr_id', l_hr_term_id)
SET_INPUT ('eff_date',l_start_date)
SET_INPUT ('mode','GET_PAY_AVAILABILITY_ANNUAL')
EXECUTE('XX_GET_HR_DATA')
l_day_duration = GET_OUTPUT('X_OUTPUT_NUMBER', -2)
l_log11135 = ess_log_write('l_day_duration ----> ' +
to_char(l_day_duration))
 L_P_DATE = To_char(l_start_date,'YYYY/MM/DD')
L_flag = GET_VALUE_SET('XXDH_PUBLIC_HOLIDAY_VS','|=P_DATE='''||
L_P_DATE||'''')
l_log111357 = ess_log_write('PUBLIC HOLIDAY L_flag ----> ' + L_flag)

/* if l_day_duration = 0 means, That day is weekoff or public holiday*/

If l_day_duration = 0 then
(
/* CHECKING every date FOR WEEKLY OFF FLAG YES OR NO and : l_PH = yes
or no and l_weeklyoff = yes or no */
dow2 = get_date_day_of_Week(to_date(to_char(l_start_date,'DD-MM-
YYYY'),'DD-MM-YYYY'))
l_log111357 = ess_log_write(' DAY OF WEEK dow2 ----> ' + dow2)

if(dow2 = weekly_off) then

l_weekly_off_flag = 'YES'
else
l_ph_days_flag = 'YES'

/* IF it is weekoff and public holiday*/

if ((dow2 = weekly_off) AND (L_flag = 'PH')) THEN
(
l_ph_days_flag = 'YES'
l_weekly_off_flag = 'YES'
)

l_log1113577 = ess_log_write('After checking: l_weekly_off_flag ----> '

+ l_weekly_off_flag)
l_log11135778 = ess_log_write('After checking: l_ph_days_flag ----> ' +
l_ph_days_flag)
)

/* if l_day_duration = 1 means, That day is working day*/

If l_day_duration = 1 then
(
l_ph_days_flag = 'NO'
l_weekly_off_flag = 'NO'
)

/* CHECKING FOR ANNUAL LEAVE COUNT FROM VALUE SET*/

l_value_set = GET_VALUE_SET('Dhaman_Annual_leave_count_vs','|
=P_PERSON_ID='''||TO_CHAR(l_person_id)||''''||'|P_DATE='''||
TO_CHAR(l_start_date,'YYYY/MM/DD')||'''')
l_log21113577897 = ess_log_write('l_value_set ----> ' + l_value_set)

IF(l_weekly_off_flag = 'NO' AND l_ph_days_flag = 'NO' AND

ISNULL(l_value_set) = 'Y') THEN
(
l_abs_count = l_abs_count + 1
l_log111357789 = ess_log_write('l_abs_count ----> ' +
to_char(l_abs_count))
)
l_start_date = ADD_DAYS(l_start_date,1)
)

l_annual_days = l_abs_count
l_log1113577897 = ess_log_write('l_annual_days after the while loop ----> ' +
to_char(l_annual_days))
)

ELSE /* this ELSE condition checks for NO PRORATIOIN ANNUAL DAYS IN MONTH COUNT
*/
(
l_annual_days = ANNUAL_LEAVE_ENTITLEMENT_DAYS_ASG_MTD

work_days = 26
dow = ' '
l_date_start_index = PAY_EARN_PERIOD_START

mesg3 = mesg3 + ' test_if' +to_char(ACP_HIRE_DATE)

/* this IF condition checks for HIRE DATE DURING CURRENT PAY PERIOD */
If (ACP_HIRE_DATE >= PAY_EARN_PERIOD_START AND ACP_HIRE_DATE <=
PAY_EARN_PERIOD_END) then
(

EXECUTE('Working Days for Hire')

work_days = GET_OUTPUT('working_days', 0)
l_Log3212 = ess_log_write(' Hire month , Work days ----> ' +
TO_CHAR(work_days))

mesg = GET_OUTPUT('mesg', 'xx')

working_days = work_days
mesg = mesg + 'H__Working days__'+to_char(work_days)
l_value = (((amount)/12/26) * working_days) /*daily rate for 26 days*/
l_Log32124 = ess_log_write(' Hire month , L_Value daily rate for 26 days
----> ' + TO_CHAR(l_value))

full_month_amount = (l_value * 26)/work_days

l_Log3219 = ess_log_write(' Hire month , FUll Month Amount ----> ' +
TO_CHAR(full_month_amount))

mesg = mesg + 'H__amount__' +to_char(amount)

/*
mesg = mesg + 'H_l_value_' +to_char(l_value)
mesg = mesg + 'H_full_month_amount_' +to_char(full_month_amount)
*/
)/* this ELSE IF condition checks for TERMINATION DATE DURING CURRENT PAY PERIOD
*/
ELSE IF (ACP_TERMINATION_DATE >= PAY_EARN_PERIOD_START AND ACP_TERMINATION_DATE <=
PAY_EARN_PERIOD_END) THEN
(
EXECUTE('Working Days for Termination')
work_days = GET_OUTPUT('working_days', 0)

l_value = ((amount)/12/26) /*daily rate for 26 days*/

full_month_amount = (l_value * 26)
Final_Full_Month = (l_value * 26)

If (l_annual_days > 0) THEN

(
work_days = work_days - l_annual_days
)
working_days = work_days
 l_value = (l_value * work_days)

/*mesg = mesg + 'here work_days:'+to_char(work_days)*/

/*mesg = mesg + ' l_value:' +to_char(l_value)*/
/*mesg = mesg + 'T__l_value__' +to_char(l_value)*/
/*mesg = mesg + 'T__full_month_amount__' +to_char(full_month_amount)*/
)
ELSE /* this ELSE condition checks for Other normal condions with and without
Proration */
(
L_Per_Days = 0

/* this IF condition checks for PRORATION AND DEDUCT ANNUAL LEAVES PAY */

If (prorate_start was not defaulted OR prorate_end was not defaulted)THEN

(
log5654 = ess_log_write (' Entered the last else IF ')

/* this IF condition checks for PRORATION CASE 1 ANNUAL LEAVE DEDUCTION

*/
If(prorate_start = PAY_EARN_PERIOD_START OR prorate_end <>
PAY_EARN_PERIOD_END) then
(
L_log122212 = ess_log_write ('p_days1 1st Half --> '
+to_Char(p_days1))
L_Per_Days = l_Value/p_days1
L_log1212 = ess_log_write ('L_Per_Days 1st Half --> '
+to_Char(L_Per_Days))

L_value = l_Value - (l_annual_days*L_Per_Days)

L_log1712 = ess_log_write ('L_value 1st Half --> '
+to_Char(L_value))

) /* this IF condition checks for PRORATION CASE 2 ANNUAL LEAVE

DEDUCTION */
Else IF(prorate_start <> PAY_EARN_PERIOD_START AND prorate_end =
PAY_EARN_PERIOD_END)THEN
(
L_log122112 = ess_log_write ('pay_days 2nd Half --> '
+to_Char(pay_days))
L_Per_Days = l_Value/pay_days
L_log1112 = ess_log_write ('L_Per_Days 2nd Half --> '
+to_Char(L_Per_Days))

L_value = l_Value - (l_annual_days*L_Per_Days)

L_log1710 = ess_log_write ('L_value 2nd Half --> '
+to_Char(L_value))

)
)
Else /* this ELSE condition checks for NO PRORATION ANNUAL LEAVE DEDUCTION
*/
(
log5654 = ess_log_write (' Entered the last ELSEs ELSE NORMAL CASE ')
l_value = ((amount)/12/26) /*daily rate for 26 days*/
L_log179812 = ess_log_write ('L_value NO PORRATION l_value =
((amount)/12/26) DAILY RATE --> ' +to_Char(L_value))
 full_month_amount = (l_value * 26)
l_value = full_month_amount
L_log17129876 = ess_log_write ('L_value NO PORRATION l_value
full_month_amount --> ' +to_Char(l_value))

L_log1010 = ess_log_write ('l_annual_days Normal --> '

+to_Char(l_annual_days))

l_value = full_month_amount * (26 - l_annual_days)/26

L_log1010 = ess_log_write ('L_value Normal --> ' +to_Char(l_value))

IF (prorate_end = PAY_EARN_PERIOD_END OR prorate_end was defaulted ) THEN

(
l_log = PAY_INTERNAL_LOG_WRITE('full_month_amount -----> '||
TO_CHAR(full_month_amount))
full_month_amount = amount/12
l_log1113577897 = ess_log_write('l_annual_days ----> ' +
to_char(l_annual_days))
)

working_days = 26 - l_annual_days

)
l_annual_leave_days_paid = l_annual_days

RETURN l_value ,
l_hours ,
l_days ,
l_reduce ,
l_reduce_hours ,
l_reduce_days ,
l_reduce_abs ,
l_reduce_abs_hours ,
l_reduce_abs_days ,
mesg ,
full_month_amount ,
l_annual_leave_days_paid,
mesg3,
working_days,
mesg4,
Final_Full_Month
)

ELSE /* Grossup Processing Begin */

(
l_log = PAY_INTERNAL_LOG_WRITE('(GLBGRUP) Entering GrossupMode ')
l_value = 0
if (first_run = 1) then
( result2 = new_guess )
else
(result2 = guess + additional_amount )
guess = result2
l_value = result2
L_LOG = PAY_INTERNAL_LOG_WRITE('(GLBGRUP) EXITING FLAT AMOUNT FORMULA ')
return l_value
)

/* End Formula Text */