def get_data(filters, leave_types):
user = frappe.session.user
allocation_records_based_on_to_date = get_leave_allocation_records(filters.to_date)
allocation_records_based_on_from_date = get_leave_allocation_records(filters.from_date)
active_employees = frappe.get_all("Employee",
filters = { "status": "Active", "company": filters.company},
fields = ["name", "employee_name", "department", "user_id"])
data = []
for employee in active_employees:
leave_approvers = [l.leave_approver for l in frappe.db.sql("""select leave_approver from `tabEmployee Leave Approver` where parent = %s""",
(employee.name),as_dict=True)]
if (len(leave_approvers) and user in leave_approvers) or (user in ["Administrator", employee.user_id]) or ("HR Manager" in frappe.get_roles(user)):
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(employee.name, leave_type,
filters.from_date, filters.to_date)
# opening balance
opening = get_leave_balance_on(employee.name, leave_type, filters.from_date,
allocation_records_based_on_from_date.get(employee.name, frappe._dict()))
# closing balance
closing = get_leave_balance_on(employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(employee.name, frappe._dict()))
row += [opening, leaves_taken, closing]
data.append(row)
return data
def get_data(filters, leave_types):
user = frappe.session.user
allocation_records_based_on_to_date = get_leave_allocation_records(filters.to_date)
allocation_records_based_on_from_date = get_leave_allocation_records(filters.from_date)
active_employees = frappe.get_all("Employee",
filters = { "status": "Active", "company": filters.company},
fields = ["name", "employee_name", "department", "user_id"])
data = []
for employee in active_employees:
leave_approvers = get_approvers(employee.department)
if (len(leave_approvers) and user in leave_approvers) or (user in ["Administrator", employee.user_id]) or ("HR Manager" in frappe.get_roles(user)):
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(employee.name, leave_type,
filters.from_date, filters.to_date)
# opening balance
opening = get_leave_balance_on(employee.name, leave_type, filters.from_date,
allocation_records_based_on_from_date.get(employee.name, frappe._dict()))
# closing balance
closing = get_leave_balance_on(employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(employee.name, frappe._dict()))
row += [opening, leaves_taken, closing]
data.append(row)
return data
def get_data(filters, leave_types):
dates = frappe.db.sql(
'''select
year_start_date, year_end_date
from
`tabFiscal Year`
where name = %s''', filters.fiscal_year)
start_date = dates[0][0]
end_date = dates[0][1]
allocation_records_based_on_to_date_prev_year = get_leave_allocation_records(
frappe.utils.add_days(start_date, -1))
allocation_records_based_on_to_date = get_leave_allocation_records(
end_date)
allocation_records_based_on_from_date = get_leave_allocation_records(
start_date)
active_employees = frappe.get_all(
"Employee",
filters={
"status": "Active",
"company": filters.company
},
fields=["name", "employee_name", "department", "user_id"])
data = []
for employee in active_employees:
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, leave_type, start_date, end_date)
#prev_year_opening
prev_year_end_date = frappe.utils.add_days(start_date, -1)
prev_year_opening = get_leave_balance_on(
employee.name, leave_type, prev_year_end_date,
allocation_records_based_on_to_date_prev_year.get(
employee.name, frappe._dict()))
# opening balance
opening = get_total_allocated_leaves(employee.name, leave_type,
end_date)
added_leave_bal = 0
if (opening - prev_year_opening) > 0:
added_leave_bal = opening - prev_year_opening
# closing balance
closing = get_leave_balance_on(
employee.name, leave_type, end_date,
allocation_records_based_on_to_date.get(
employee.name, frappe._dict()))
row += [prev_year_opening, added_leave_bal, leaves_taken, closing]
data.append(row)
return data
def get_data(filters, leave_types):
user = frappe.session.user
allocation_records_based_on_to_date = get_leave_allocation_records(filters.to_date)
allocation_records_based_on_from_date = get_leave_allocation_records(filters.from_date)
active_employees = frappe.get_all("Employee",
filters = { "status": "Active", "company": filters.company},
fields = ["name", "employee_name", "department", "user_id"])
data = []
for employee in active_employees:
leave_approvers = get_approvers(employee.department)
if (len(leave_approvers) and user in leave_approvers) or (user in ["Administrator", employee.user_id]) or ("HR Manager" in frappe.get_roles(user)):
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(employee.name, leave_type,
filters.from_date, filters.to_date)
# opening balance
opening = 0
closing = 0
conditions = (" and leave_type= '"+str(leave_type)+"' and employee='%s' " % employee.name) if employee else ""
leave_allocation_records = frappe.db.sql("""select employee, leave_type, total_leaves_allocated, total_leaves_encashed, from_date, to_date from `tabLeave Allocation` where from_date >= %s and to_date <= %s and docstatus=1 {0}""".format(conditions), (filters.from_date, filters.to_date), as_dict=1)
allocated_leaves = frappe._dict()
for d in leave_allocation_records:
opening = d.total_leaves_allocated
# allocated_leaves.setdefault(d.employee, frappe._dict()).setdefault(d.leave_type, frappe._dict({
# "from_date": d.from_date,
# "to_date": d.to_date,
# "total_leaves_allocated": d.total_leaves_allocated,
# "total_leaves_encashed":d.total_leaves_encashed
# }))
# opening = get_leave_balance_on(employee.name, leave_type, filters.from_date,allocation_records_based_on_from_date.get(employee.name, frappe._dict()))
# closing balance
closing = float(opening) - float(leaves_taken)
# closing = get_leave_balance_on(employee.name, leave_type, filters.to_date,
# allocation_records_based_on_to_date.get(employee.name, frappe._dict()))
row += [opening, leaves_taken, closing]
data.append(row)
return data
def get_record(self, filters):
allocation_records_based_on_to_date = get_leave_allocation_records(
filters.get('to_date'))
data, active_employees = [], frappe.get_all(
"Employee",
filters={"status": "Active"},
fields=["name", "employee_name", "department"])
for employee in active_employees:
row = [
employee.name, employee.employee_name, employee.department,
self.get_days_spent(employee.name)
]
# if leave type is selected in the filter
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, filters.get('leave_type'),
filters.get('from_date'), filters.get('to_date'))
# closing balance
closing = get_leave_balance_on(
employee.name, filters.get('leave_type'),
filters.get('to_date'),
allocation_records_based_on_to_date.get(
employee.name, frappe._dict()))
row += [leaves_taken, closing]
data.append(row)
print(data)
def get_data(filters, leave_types):
allocation_records_based_on_to_date = get_leave_allocation_records(filters.to_date)
active_employees = frappe.get_all("Employee",
filters = { "status": "Active", "company": filters.company},
fields = ["name", "employee_name", "department"])
data = []
for employee in active_employees:
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(employee.name, leave_type,
filters.from_date, filters.to_date)
# closing balance
closing = get_leave_balance_on(employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(employee.name, frappe._dict()))
row += [leaves_taken, closing]
data.append(row)
return data
def get_data(filters, leave_types):
allocation_records_based_on_to_date = get_leave_allocation_records(
filters.to_date)
active_employees = frappe.get_all(
"Employee",
filters={
"status": "Active",
"company": filters.company
},
fields=["name", "employee_name", "department"])
data = []
for employee in active_employees:
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, leave_type, filters.from_date, filters.to_date)
# closing balance
closing = get_leave_balance_on(
employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(
employee.name, frappe._dict()))
row += [leaves_taken, closing]
data.append(row)
return data
def salaries(conditions, filters, leaves):
data = []
hours = {}
ss = frappe.db.sql(
"""select * from `tabEmployee` where docstatus <2 %s order by name """
% conditions,
filters,
as_dict=1)
for add in ss:
for leave_type in leaves:
# leaves taken
leaves_taken = get_approved_leaves_for_period(
add.name, leave_type.name, filters.from_date, filters.to_date)
allocation_records = get_leave_allocation_records(
filters.to_date, add.name).get(add.name, frappe._dict())
allocation = allocation_records.get(leave_type.name,
frappe._dict())
# closing balance
closing = flt(
allocation.total_leaves_allocated) - flt(leaves_taken)
if closing <= 0:
row = [
add.name, add.employee_name, add.department,
add.designation, leave_type.name
]
if allocation.total_leaves_allocated > 0:
data.append(row)
return data
def calculate_casual_leave(doc, method):
user = frappe.session.user
start_date = doc.start_date
end_date = doc.end_date
allocation_records_based_on_to_date = get_leave_allocation_records(
end_date)
employee_name = doc.employee_name
active_employees = frappe.get_all(
"Employee", fields=["name", "employee_name", "department", "user_id"])
a = 0.0
b = 0.0
t = 0.0
leaves_taken = 0.0
for employee in active_employees:
leave_approvers = [
l.leave_approver for l in frappe.db.sql(
"""select leave_approver from `tabEmployee Leave Approver` where parent = %s""",
(employee.name),
as_dict=True)
]
if (len(leave_approvers) and user in leave_approvers) or (user in [
"Administrator", employee.user_id
]) or ("HR Manager" in frappe.get_roles(user)):
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, "Casual Leave", start_date, end_date)
a = a + leaves_taken
conditions = (" and employee_name='%s'" % employee_name)
allocation_records = frappe.db.sql("""
select total_leaves_allocated,from_date,to_date
from `tabLeave Allocation`
where leave_type="Casual Leave" and docstatus=1 {0}""".format(
conditions),
as_list=1)
salary_slip_list = frappe.db.sql("""
select start_date,end_date,pending_leaves,casual_leaves,sick_leaves
from `tabSalary Slip`
where docstatus=1 {0}""".format(conditions),
as_list=1)
if len(salary_slip_list) != 0:
length = len(salary_slip_list)
t = frappe.utils.data.flt(salary_slip_list[length - 1][3], precision=1)
doc.casual_leaves = t - a
if len(salary_slip_list) == 0:
if allocation_records[0][
1] <= start_date and start_date <= allocation_records[0][2]:
doc.casual_leaves = allocation_records[0][0] - a
def get_data(filters, leave_types):
allocation_records_based_on_to_date = get_leave_allocation_records(
filters.to_date)
active_employees = frappe.get_all(
"Employee",
filters={
"status": "Active",
"company": filters.company
},
fields=["name", "employee_name", "department"],
order_by="employee_name asc")
data = []
for employee in active_employees:
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
matched_leave_type = leave_type.lower().replace(' ', '_')
if filters.get(matched_leave_type):
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, leave_type, filters.from_date,
filters.to_date)
# closing balance
closing = get_leave_balance_on(
employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(
employee.name, frappe._dict()))
# annual leave allocated
allocation_records = allocation_records_based_on_to_date.get(
employee.name, frappe._dict())
allocation = allocation_records.get(leave_type, frappe._dict())
total_leaves_allocated = flt(allocation.total_leaves_allocated)
new_leaves_allocated = flt(allocation.new_leaves_allocated)
row += [
new_leaves_allocated, total_leaves_allocated, leaves_taken,
closing
]
data.append(row)
return data
def get_leave_balance_on(employee,
leave_type,
date,
allocation_records=None,
consider_all_leaves_in_the_allocation_period=False):
if allocation_records == None:
allocation_records = get_leave_allocation_records(date, employee).get(
employee, frappe._dict())
allocation = allocation_records.get(leave_type, frappe._dict())
if consider_all_leaves_in_the_allocation_period:
date = allocation.to_date
leaves_taken = get_approved_leaves_for_period(employee, leave_type,
allocation.from_date, date)
return flt(allocation.total_leaves_allocated) - flt(leaves_taken)
def test_get_leave_allocation_records(self):
employee = get_employee()
leave_type = create_leave_type(
leave_type_name="_Test_CF_leave_expiry",
is_carry_forward=1,
expire_carry_forwarded_leaves_after_days=90,
)
leave_type.insert()
leave_alloc = create_carry_forwarded_allocation(employee, leave_type)
details = get_leave_allocation_records(employee.name, getdate(), leave_type.name)
expected_data = {
"from_date": getdate(leave_alloc.from_date),
"to_date": getdate(leave_alloc.to_date),
"total_leaves_allocated": 30.0,
"unused_leaves": 15.0,
"new_leaves_allocated": 15.0,
"leave_type": leave_type.name,
}
self.assertEqual(details.get(leave_type.name), expected_data)
def get_leave_details(employee, date):
'''Override white listed function get_leave_details for calculate leaves details
Because after adding hourly leave funcionality leave balanace, leave used and pending leaves qouta calculted in decimals and
this add almost 10+ digits after decimal'''
allocation_records = get_leave_allocation_records(date, employee).get(
employee, frappe._dict())
leave_allocation = {}
for d in allocation_records:
allocation = allocation_records.get(d, frappe._dict())
date = allocation.to_date
leaves_taken = round(
get_leaves_for_period(employee,
d,
allocation.from_date,
date,
status="Approved"), 2)
leaves_pending = round(
get_leaves_for_period(employee,
d,
allocation.from_date,
date,
status="Open"), 2)
remaining_leaves = round(
allocation.total_leaves_allocated - leaves_taken - leaves_pending,
2)
leave_allocation[d] = {
"total_leaves": allocation.total_leaves_allocated,
"leaves_taken": leaves_taken,
"pending_leaves": leaves_pending,
"remaining_leaves": remaining_leaves
}
ret = {
'leave_allocation': leave_allocation,
'leave_approver': get_leave_approver(employee)
}
return ret
def get_data(filters, leave_types):
allocation_records_based_on_to_date = get_leave_allocation_records(filters.to_date)
active_employees = frappe.get_all("Employee",
filters = { "status": "Active", "company": filters.company},
fields = ["name", "employee_name", "department"],
order_by = "employee_name asc")
data = []
for employee in active_employees:
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
matched_leave_type = leave_type.lower().replace(' ','_')
if filters.get(matched_leave_type):
# leaves taken
leaves_taken = get_approved_leaves_for_period(employee.name, leave_type,
filters.from_date, filters.to_date)
# closing balance
closing = get_leave_balance_on(employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(employee.name, frappe._dict()))
# annual leave allocated
allocation_records = allocation_records_based_on_to_date.get(employee.name, frappe._dict())
allocation = allocation_records.get(leave_type, frappe._dict())
total_leaves_allocated = flt(allocation.total_leaves_allocated)
new_leaves_allocated = flt(allocation.new_leaves_allocated)
row += [new_leaves_allocated, total_leaves_allocated, leaves_taken, closing]
data.append(row)
return data
def get_data(filters, leave_types):
user = frappe.session.user
allocation_records_based_on_to_date = get_leave_allocation_records(
filters.to_date)
allocation_records_based_on_from_date = get_leave_allocation_records(
filters.from_date)
hr_manager = frappe.get_doc("User", frappe.session.user).get(
"roles", {"role": "HR Manager"})
if hr_manager:
emp_filters = {
"status": "Active",
"company": filters.company,
"department": filters.department
}
else:
emp_filters = {
"status": "Active",
"company": filters.company,
"department": filters.department,
"user_id": frappe.session.user
}
active_employees = frappe.get_all(
"Employee",
filters=emp_filters,
fields=["name", "employee_name", "department", "user_id"],
order_by="name desc")
data = []
for employee in active_employees:
leave_approvers = [
l.leave_approver for l in frappe.db.sql(
"""select leave_approver from `tabEmployee Leave Approver` where parent = %s""",
(employee.name),
as_dict=True)
]
if (len(leave_approvers) and user in leave_approvers) or (user in [
"Administrator", employee.user_id
]) or ("HR Manager" in frappe.get_roles(user)):
row = [employee.name, employee.employee_name, employee.department]
for leave_type in leave_types:
# leaves taken
leaves_taken = get_approved_leaves_for_period(
employee.name, leave_type, filters.from_date,
filters.to_date)
# opening balance
opening = get_leave_balance_on(
employee.name, leave_type, filters.from_date,
allocation_records_based_on_from_date.get(
employee.name, frappe._dict()))
# closing balance
closing = get_leave_balance_on(
employee.name, leave_type, filters.to_date,
allocation_records_based_on_to_date.get(
employee.name, frappe._dict()))
row += [opening, leaves_taken, closing]
data.append(row)
return data
