code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.mapper import get_mapped_doc
from hrms.controllers.employee_boarding_controller import EmployeeBoardingController
class IncompleteTaskError(frappe.ValidationError):
pass
class EmployeeOnboarding(EmployeeBoardingController):
def validate(self):
super().validate()
self.set_employee()
self.validate_duplicate_employee_onboarding()
def set_employee(self):
if not self.employee:
self.employee = frappe.db.get_value("Employee", {"job_applicant": self.job_applicant}, "name")
def validate_duplicate_employee_onboarding(self):
emp_onboarding = frappe.db.exists(
"Employee Onboarding", {"job_applicant": self.job_applicant, "docstatus": ("!=", 2)}
)
if emp_onboarding and emp_onboarding != self.name:
frappe.throw(
_("Employee Onboarding: {0} already exists for Job Applicant: {1}").format(
frappe.bold(emp_onboarding), frappe.bold(self.job_applicant)
)
)
def validate_employee_creation(self):
if self.docstatus != 1:
frappe.throw(_("Submit this to create the Employee record"))
else:
for activity in self.activities:
if not activity.required_for_employee_creation:
continue
else:
task_status = frappe.db.get_value("Task", activity.task, "status")
if task_status not in ["Completed", "Cancelled"]:
frappe.throw(
_("All the mandatory tasks for employee creation are not completed yet."),
IncompleteTaskError,
)
def on_submit(self):
super().on_submit()
def on_update_after_submit(self):
self.create_task_and_notify_user()
def on_cancel(self):
super().on_cancel()
@frappe.whitelist()
def mark_onboarding_as_completed(self):
for activity in self.activities:
frappe.db.set_value("Task", activity.task, "status", "Completed")
frappe.db.set_value("Project", self.project, "status", "Completed")
self.boarding_status = "Completed"
self.save()
@frappe.whitelist()
def make_employee(source_name, target_doc=None):
doc = frappe.get_doc("Employee Onboarding", source_name)
doc.validate_employee_creation()
def set_missing_values(source, target):
target.personal_email = frappe.db.get_value("Job Applicant", source.job_applicant, "email_id")
target.status = "Active"
doc = get_mapped_doc(
"Employee Onboarding",
source_name,
{
"Employee Onboarding": {
"doctype": "Employee",
"field_map": {
"first_name": "employee_name",
"employee_grade": "grade",
},
}
},
target_doc,
set_missing_values,
)
return doc
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding/employee_onboarding.py
|
Python
|
agpl-3.0
| 2,645
|
frappe.listview_settings["Employee Onboarding"] = {
add_fields: ["boarding_status", "employee_name", "date_of_joining", "department"],
filters: [["boarding_status", "=", "Pending"]],
get_indicator: function (doc) {
return [
__(doc.boarding_status),
frappe.utils.guess_colour(doc.boarding_status),
"status,=," + doc.boarding_status,
];
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding/employee_onboarding_list.js
|
JavaScript
|
agpl-3.0
| 358
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Onboarding Template", {
setup: function (frm) {
frm.set_query("department", function () {
return {
filters: {
company: frm.doc.company,
},
};
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding_template/employee_onboarding_template.js
|
JavaScript
|
agpl-3.0
| 328
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeeOnboardingTemplate(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding_template/employee_onboarding_template.py
|
Python
|
agpl-3.0
| 216
|
def get_data():
return {
"fieldname": "employee_onboarding_template",
"transactions": [
{"items": ["Employee Onboarding"]},
],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding_template/employee_onboarding_template_dashboard.py
|
Python
|
agpl-3.0
| 140
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Performance Feedback", {
onload(frm) {
frm.trigger("set_reviewer");
},
refresh(frm) {
frm.trigger("set_filters");
},
employee(frm) {
frm.set_value("appraisal", "");
},
appraisal(frm) {
if (frm.doc.employee) {
frm.call("set_feedback_criteria", () => {
frm.refresh_field("feedback_ratings");
});
}
},
set_filters(frm) {
frm.set_query("appraisal", () => {
return {
filters: {
employee: frm.doc.employee,
},
};
});
frm.set_query("reviewer", () => {
return {
filters: {
employee: ["!=", frm.doc.employee],
},
};
});
},
set_reviewer(frm) {
if (!frm.doc.reviewer) {
frappe.db
.get_value("Employee", { user_id: frappe.session.user }, "name")
.then((employee_record) => {
const session_employee = employee_record?.message?.name;
if (session_employee) frm.set_value("reviewer", session_employee);
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_performance_feedback/employee_performance_feedback.js
|
JavaScript
|
agpl-3.0
| 1,063
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import flt, get_link_to_form
from hrms.hr.doctype.appraisal_cycle.appraisal_cycle import validate_active_appraisal_cycle
from hrms.hr.utils import validate_active_employee
from hrms.mixins.appraisal import AppraisalMixin
class EmployeePerformanceFeedback(Document, AppraisalMixin):
def validate(self):
validate_active_appraisal_cycle(self.appraisal_cycle)
self.validate_employee()
self.validate_appraisal()
self.validate_total_weightage("feedback_ratings", "Feedback Ratings")
self.set_total_score()
def on_submit(self):
self.update_avg_feedback_score_in_appraisal()
def on_cancel(self):
self.update_avg_feedback_score_in_appraisal()
def validate_employee(self):
if self.employee == self.reviewer:
frappe.throw(
_("Employees cannot give feedback to themselves. Use {0} instead: {1}").format(
frappe.bold(_("Self Appraisal")), get_link_to_form("Appraisal", self.appraisal)
)
)
validate_active_employee(self.employee)
validate_active_employee(self.reviewer)
def validate_appraisal(self):
employee = frappe.db.get_value("Appraisal", self.appraisal, "employee")
if employee != self.employee:
frappe.throw(
_("Appraisal {0} does not belong to Employee {1}").format(self.appraisal, self.employee)
)
def set_total_score(self):
total = 0
for entry in self.feedback_ratings:
score = flt(entry.rating) * 5 * flt(entry.per_weightage / 100)
total += flt(score)
self.total_score = flt(total, self.precision("total_score"))
def update_avg_feedback_score_in_appraisal(self):
if not self.appraisal:
return
appraisal = frappe.get_doc("Appraisal", self.appraisal)
appraisal.calculate_avg_feedback_score(update=True)
@frappe.whitelist()
def set_feedback_criteria(self):
if not self.appraisal:
return
template = frappe.db.get_value("Appraisal", self.appraisal, "appraisal_template")
template = frappe.get_doc("Appraisal Template", template)
self.set("feedback_ratings", [])
for entry in template.rating_criteria:
self.append(
"feedback_ratings",
{
"criteria": entry.criteria,
"per_weightage": entry.per_weightage,
},
)
return self
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_performance_feedback/employee_performance_feedback.py
|
Python
|
agpl-3.0
| 2,371
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
{% include 'hrms/hr/employee_property_update.js' %}
frappe.ui.form.on('Employee Promotion', {
refresh: function(frm) {
}
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_promotion/employee_promotion.js
|
JavaScript
|
agpl-3.0
| 251
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import getdate
from hrms.hr.utils import update_employee_work_history, validate_active_employee
class EmployeePromotion(Document):
def validate(self):
validate_active_employee(self.employee)
def before_submit(self):
if getdate(self.promotion_date) > getdate():
frappe.throw(
_("Employee Promotion cannot be submitted before Promotion Date"),
frappe.DocstatusTransitionError,
)
def on_submit(self):
employee = frappe.get_doc("Employee", self.employee)
employee = update_employee_work_history(employee, self.promotion_details, date=self.promotion_date)
if self.revised_ctc:
employee.ctc = self.revised_ctc
employee.save()
def on_cancel(self):
employee = frappe.get_doc("Employee", self.employee)
employee = update_employee_work_history(employee, self.promotion_details, cancel=True)
if self.revised_ctc:
employee.ctc = self.current_ctc
employee.save()
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_promotion/employee_promotion.py
|
Python
|
agpl-3.0
| 1,121
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeePropertyHistory(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_property_history/employee_property_history.py
|
Python
|
agpl-3.0
| 213
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Referral", {
refresh: function (frm) {
if (frm.doc.docstatus === 1 && frm.doc.status === "Pending") {
frm.add_custom_button(__("Reject Employee Referral"), function () {
frappe.confirm(
__("Are you sure you want to reject the Employee Referral?"),
function () {
frm.doc.status = "Rejected";
frm.dirty();
frm.save_or_update();
},
function () {
window.close();
},
);
});
frm.add_custom_button(__("Create Job Applicant"), function () {
frm.events.create_job_applicant(frm);
}).addClass("btn-primary");
}
// To check whether Payment is done or not
if (frm.doc.docstatus === 1 && frm.doc.status === "Accepted") {
frappe.db
.get_list("Additional Salary", {
filters: {
ref_docname: cur_frm.doc.name,
docstatus: 1,
},
fields: ["count(name) as additional_salary_count"],
})
.then((data) => {
let additional_salary_count = data[0].additional_salary_count;
if (frm.doc.is_applicable_for_referral_bonus && !additional_salary_count) {
frm.add_custom_button(__("Create Additional Salary"), function () {
frm.events.create_additional_salary(frm);
}).addClass("btn-primary");
}
});
}
},
create_job_applicant: function (frm) {
frappe.model.open_mapped_doc({
method: "hrms.hr.doctype.employee_referral.employee_referral.create_job_applicant",
frm: frm,
});
},
create_additional_salary: function (frm) {
frappe.call({
method: "hrms.hr.doctype.employee_referral.employee_referral.create_additional_salary",
args: {
doc: frm.doc,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_referral/employee_referral.js
|
JavaScript
|
agpl-3.0
| 1,922
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import get_link_to_form
from hrms.hr.utils import validate_active_employee
class EmployeeReferral(Document):
def validate(self):
validate_active_employee(self.referrer)
self.set_full_name()
self.set_referral_bonus_payment_status()
def set_full_name(self):
self.full_name = " ".join(filter(None, [self.first_name, self.last_name]))
def set_referral_bonus_payment_status(self):
if not self.is_applicable_for_referral_bonus:
self.referral_payment_status = ""
else:
if not self.referral_payment_status:
self.referral_payment_status = "Unpaid"
@frappe.whitelist()
def create_job_applicant(source_name, target_doc=None):
emp_ref = frappe.get_doc("Employee Referral", source_name)
# just for Api call if some set status apart from default Status
status = emp_ref.status
if emp_ref.status in ["Pending", "In process"]:
status = "Open"
job_applicant = frappe.new_doc("Job Applicant")
job_applicant.source = "Employee Referral"
job_applicant.employee_referral = emp_ref.name
job_applicant.status = status
job_applicant.designation = emp_ref.for_designation
job_applicant.applicant_name = emp_ref.full_name
job_applicant.email_id = emp_ref.email
job_applicant.phone_number = emp_ref.contact_no
job_applicant.resume_attachment = emp_ref.resume
job_applicant.resume_link = emp_ref.resume_link
job_applicant.save()
frappe.msgprint(
_("Job Applicant {0} created successfully.").format(
get_link_to_form("Job Applicant", job_applicant.name)
),
title=_("Success"),
indicator="green",
)
emp_ref.db_set("status", "In Process")
return job_applicant
@frappe.whitelist()
def create_additional_salary(doc):
import json
if isinstance(doc, str):
doc = frappe._dict(json.loads(doc))
if not frappe.db.exists("Additional Salary", {"ref_docname": doc.name}):
additional_salary = frappe.new_doc("Additional Salary")
additional_salary.employee = doc.referrer
additional_salary.company = frappe.db.get_value("Employee", doc.referrer, "company")
additional_salary.overwrite_salary_structure_amount = 0
additional_salary.ref_doctype = doc.doctype
additional_salary.ref_docname = doc.name
return additional_salary
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_referral/employee_referral.py
|
Python
|
agpl-3.0
| 2,387
|
def get_data():
return {
"fieldname": "employee_referral",
"non_standard_fieldnames": {"Additional Salary": "ref_docname"},
"transactions": [
{"items": ["Job Applicant", "Additional Salary"]},
],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_referral/employee_referral_dashboard.py
|
Python
|
agpl-3.0
| 211
|
frappe.listview_settings["Employee Referral"] = {
add_fields: ["status"],
get_indicator: function (doc) {
if (doc.status == "Pending") {
return [__(doc.status), "grey", "status,=," + doc.status];
} else if (doc.status == "In Process") {
return [__(doc.status), "orange", "status,=," + doc.status];
} else if (doc.status == "Accepted") {
return [__(doc.status), "green", "status,=," + doc.status];
} else if (doc.status == "Rejected") {
return [__(doc.status), "red", "status,=," + doc.status];
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_referral/employee_referral_list.js
|
JavaScript
|
agpl-3.0
| 527
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Separation", {
setup: function (frm) {
frm.add_fetch("employee_separation_template", "company", "company");
frm.add_fetch("employee_separation_template", "department", "department");
frm.add_fetch("employee_separation_template", "designation", "designation");
frm.add_fetch("employee_separation_template", "employee_grade", "employee_grade");
},
refresh: function (frm) {
if (frm.doc.employee) {
frm.add_custom_button(
__("Employee"),
function () {
frappe.set_route("Form", "Employee", frm.doc.employee);
},
__("View"),
);
}
if (frm.doc.project) {
frm.add_custom_button(
__("Project"),
function () {
frappe.set_route("Form", "Project", frm.doc.project);
},
__("View"),
);
frm.add_custom_button(
__("Task"),
function () {
frappe.set_route("List", "Task", { project: frm.doc.project });
},
__("View"),
);
}
},
employee_separation_template: function (frm) {
frm.set_value("activities", "");
if (frm.doc.employee_separation_template) {
frappe.call({
method: "hrms.controllers.employee_boarding_controller.get_onboarding_details",
args: {
parent: frm.doc.employee_separation_template,
parenttype: "Employee Separation Template",
},
callback: function (r) {
if (r.message) {
$.each(r.message, function (i, d) {
var row = frappe.model.add_child(
frm.doc,
"Employee Boarding Activity",
"activities",
);
$.extend(row, d);
});
}
refresh_field("activities");
},
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation/employee_separation.js
|
JavaScript
|
agpl-3.0
| 1,733
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from hrms.controllers.employee_boarding_controller import EmployeeBoardingController
class EmployeeSeparation(EmployeeBoardingController):
def validate(self):
super().validate()
def on_submit(self):
super().on_submit()
def on_update_after_submit(self):
self.create_task_and_notify_user()
def on_cancel(self):
super().on_cancel()
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation/employee_separation.py
|
Python
|
agpl-3.0
| 467
|
frappe.listview_settings["Employee Separation"] = {
add_fields: ["boarding_status", "employee_name", "department"],
filters: [["boarding_status", "=", "Pending"]],
get_indicator: function (doc) {
return [
__(doc.boarding_status),
frappe.utils.guess_colour(doc.boarding_status),
"status,=," + doc.boarding_status,
];
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation/employee_separation_list.js
|
JavaScript
|
agpl-3.0
| 339
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Separation Template", {
refresh: function (frm) {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation_template/employee_separation_template.js
|
JavaScript
|
agpl-3.0
| 207
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeeSeparationTemplate(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation_template/employee_separation_template.py
|
Python
|
agpl-3.0
| 216
|
def get_data():
return {
"fieldname": "employee_separation_template",
"transactions": [
{"items": ["Employee Separation"]},
],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_separation_template/employee_separation_template_dashboard.py
|
Python
|
agpl-3.0
| 140
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class EmployeeSkill(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_skill/employee_skill.py
|
Python
|
agpl-3.0
| 219
|
// Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Skill Map", {
// refresh: function(frm) {
// }
designation: (frm) => {
frm.set_value("employee_skills", null);
if (frm.doc.designation) {
frappe.db.get_doc("Designation", frm.doc.designation).then((designation) => {
designation.skills.forEach((designation_skill) => {
let row = frappe.model.add_child(frm.doc, "Employee Skill", "employee_skills");
row.skill = designation_skill.skill;
row.proficiency = 1;
});
refresh_field("employee_skills");
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_skill_map/employee_skill_map.js
|
JavaScript
|
agpl-3.0
| 651
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class EmployeeSkillMap(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_skill_map/employee_skill_map.py
|
Python
|
agpl-3.0
| 222
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class EmployeeTraining(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_training/employee_training.py
|
Python
|
agpl-3.0
| 222
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
{% include 'hrms/hr/employee_property_update.js' %}
frappe.ui.form.on('Employee Transfer', {
refresh: function(frm) {
}
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_transfer/employee_transfer.js
|
JavaScript
|
agpl-3.0
| 250
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import getdate
from hrms.hr.utils import update_employee_work_history
class EmployeeTransfer(Document):
def before_submit(self):
if getdate(self.transfer_date) > getdate():
frappe.throw(
_("Employee Transfer cannot be submitted before Transfer Date"),
frappe.DocstatusTransitionError,
)
def on_submit(self):
employee = frappe.get_doc("Employee", self.employee)
if self.create_new_employee_id:
new_employee = frappe.copy_doc(employee)
new_employee.name = None
new_employee.employee_number = None
new_employee = update_employee_work_history(
new_employee, self.transfer_details, date=self.transfer_date
)
if self.new_company and self.company != self.new_company:
new_employee.internal_work_history = []
new_employee.date_of_joining = self.transfer_date
new_employee.company = self.new_company
# move user_id to new employee before insert
if employee.user_id and not self.validate_user_in_details():
new_employee.user_id = employee.user_id
employee.db_set("user_id", "")
new_employee.insert()
self.db_set("new_employee_id", new_employee.name)
# relieve the old employee
employee.db_set("relieving_date", self.transfer_date)
employee.db_set("status", "Left")
else:
employee = update_employee_work_history(employee, self.transfer_details, date=self.transfer_date)
if self.new_company and self.company != self.new_company:
employee.company = self.new_company
employee.date_of_joining = self.transfer_date
employee.save()
def on_cancel(self):
employee = frappe.get_doc("Employee", self.employee)
if self.create_new_employee_id:
if self.new_employee_id:
frappe.throw(
_("Please delete the Employee {0} to cancel this document").format(
f"<a href='/app/Form/Employee/{self.new_employee_id}'>{self.new_employee_id}</a>"
)
)
# mark the employee as active
employee.status = "Active"
employee.relieving_date = ""
else:
employee = update_employee_work_history(
employee, self.transfer_details, date=self.transfer_date, cancel=True
)
if self.new_company != self.company:
employee.company = self.company
employee.save()
def validate_user_in_details(self):
for item in self.transfer_details:
if item.fieldname == "user_id" and item.new != item.current:
return True
return False
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_transfer/employee_transfer.py
|
Python
|
agpl-3.0
| 2,560
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from frappe.model.document import Document
class EmploymentType(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employment_type/employment_type.py
|
Python
|
agpl-3.0
| 212
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Exit Interview", {
refresh: function (frm) {
if (
!frm.doc.__islocal &&
!frm.doc.questionnaire_email_sent &&
frappe.boot.user.can_write.includes("Exit Interview")
) {
frm.add_custom_button(__("Send Exit Questionnaire"), function () {
frm.trigger("send_exit_questionnaire");
});
}
},
employee: function (frm) {
frappe.db.get_value("Employee", frm.doc.employee, "relieving_date", (message) => {
if (!message.relieving_date) {
frappe.throw({
message: __("Please set the relieving date for employee {0}", [
'<a href="/app/employee/' +
frm.doc.employee +
'">' +
frm.doc.employee +
"</a>",
]),
title: __("Relieving Date Missing"),
});
}
});
},
send_exit_questionnaire: function (frm) {
frappe.call({
method: "hrms.hr.doctype.exit_interview.exit_interview.send_exit_questionnaire",
args: {
interviews: [frm.doc],
},
callback: function (r) {
if (!r.exc) {
frm.refresh_field("questionnaire_email_sent");
}
},
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/exit_interview/exit_interview.js
|
JavaScript
|
agpl-3.0
| 1,188
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import get_link_to_form
from erpnext.setup.doctype.employee.employee import get_employee_email
class ExitInterview(Document):
def validate(self):
self.validate_relieving_date()
self.validate_duplicate_interview()
self.set_employee_email()
def validate_relieving_date(self):
if not frappe.db.get_value("Employee", self.employee, "relieving_date"):
frappe.throw(
_("Please set the relieving date for employee {0}").format(
get_link_to_form("Employee", self.employee)
),
title=_("Relieving Date Missing"),
)
def validate_duplicate_interview(self):
doc = frappe.db.exists(
"Exit Interview", {"employee": self.employee, "name": ("!=", self.name), "docstatus": ("!=", 2)}
)
if doc:
frappe.throw(
_("Exit Interview {0} already exists for Employee: {1}").format(
get_link_to_form("Exit Interview", doc), frappe.bold(self.employee)
),
frappe.DuplicateEntryError,
)
def set_employee_email(self):
employee = frappe.get_doc("Employee", self.employee)
self.email = get_employee_email(employee)
def on_submit(self):
if self.status != "Completed":
frappe.throw(_("Only Completed documents can be submitted"))
self.update_interview_date_in_employee()
def on_cancel(self):
self.update_interview_date_in_employee()
self.db_set("status", "Cancelled")
def update_interview_date_in_employee(self):
if self.docstatus == 1:
frappe.db.set_value("Employee", self.employee, "held_on", self.date)
elif self.docstatus == 2:
frappe.db.set_value("Employee", self.employee, "held_on", None)
@frappe.whitelist()
def send_exit_questionnaire(interviews):
interviews = get_interviews(interviews)
validate_questionnaire_settings()
email_success = []
email_failure = []
for exit_interview in interviews:
interview = frappe.get_doc("Exit Interview", exit_interview.get("name"))
if interview.get("questionnaire_email_sent"):
continue
employee = frappe.get_doc("Employee", interview.employee)
email = get_employee_email(employee)
context = interview.as_dict()
context.update(employee.as_dict())
template_name = frappe.db.get_single_value("HR Settings", "exit_questionnaire_notification_template")
template = frappe.get_doc("Email Template", template_name)
if email:
frappe.sendmail(
recipients=email,
subject=template.subject,
message=frappe.render_template(template.response, context),
reference_doctype=interview.doctype,
reference_name=interview.name,
)
interview.db_set("questionnaire_email_sent", 1)
interview.notify_update()
email_success.append(email)
else:
email_failure.append(get_link_to_form("Employee", employee.name))
show_email_summary(email_success, email_failure)
def get_interviews(interviews):
import json
if isinstance(interviews, str):
interviews = json.loads(interviews)
if not len(interviews):
frappe.throw(_("At least one interview has to be selected."))
return interviews
def validate_questionnaire_settings():
settings = frappe.db.get_value(
"HR Settings",
"HR Settings",
["exit_questionnaire_web_form", "exit_questionnaire_notification_template"],
as_dict=True,
)
if not settings.exit_questionnaire_web_form or not settings.exit_questionnaire_notification_template:
frappe.throw(
_("Please set {0} and {1} in {2}.").format(
frappe.bold(_("Exit Questionnaire Web Form")),
frappe.bold(_("Notification Template")),
get_link_to_form("HR Settings", "HR Settings"),
),
title=_("Settings Missing"),
)
def show_email_summary(email_success, email_failure):
message = ""
if email_success:
message += _("Sent Successfully: {0}").format(", ".join(email_success))
if message and email_failure:
message += "<br><br>"
if email_failure:
message += _("Sending Failed due to missing email information for employee(s): {1}").format(
", ".join(email_failure)
)
frappe.msgprint(message, title=_("Exit Questionnaire"), indicator="blue", is_minimizable=True, wide=True)
|
2302_79757062/hrms
|
hrms/hr/doctype/exit_interview/exit_interview.py
|
Python
|
agpl-3.0
| 4,200
|
frappe.listview_settings["Exit Interview"] = {
has_indicator_for_draft: 1,
get_indicator: function (doc) {
let status_color = {
Pending: "orange",
Scheduled: "yellow",
Completed: "green",
Cancelled: "red",
};
return [__(doc.status), status_color[doc.status], "status,=," + doc.status];
},
onload: function (listview) {
if (frappe.boot.user.can_write.includes("Exit Interview")) {
listview.page.add_action_item(__("Send Exit Questionnaires"), function () {
const interviews = listview.get_checked_items();
frappe.call({
method: "hrms.hr.doctype.exit_interview.exit_interview.send_exit_questionnaire",
freeze: true,
args: {
interviews: interviews,
},
});
});
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/exit_interview/exit_interview_list.js
|
JavaScript
|
agpl-3.0
| 737
|
<h2>Exit Questionnaire</h2>
<br>
<p>
Dear {{ employee_name }},
<br><br>
Thank you for the contribution you have made during your time at {{ company }}. We value your opinion and welcome the feedback on your experience working with us.
Request you to take out a few minutes to fill up this Exit Questionnaire.
{% set web_form = frappe.db.get_value('HR Settings', 'HR Settings', 'exit_questionnaire_web_form') %}
{% set web_form_link = frappe.utils.get_url(uri=frappe.db.get_value('Web Form', web_form, 'route')) %}
<br><br>
<a class="btn btn-primary" href="{{ web_form_link }}" target="_blank">{{ _('Submit Now') }}</a>
</p>
|
2302_79757062/hrms
|
hrms/hr/doctype/exit_interview/exit_questionnaire_notification_template.html
|
HTML
|
agpl-3.0
| 636
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class ExpectedSkillSet(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/expected_skill_set/expected_skill_set.py
|
Python
|
agpl-3.0
| 222
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.provide("hrms.hr");
frappe.provide("erpnext.accounts.dimensions");
frappe.ui.form.on("Expense Claim", {
setup: function (frm) {
frm.set_query("employee_advance", "advances", function () {
return {
filters: [
["docstatus", "=", 1],
["employee", "=", frm.doc.employee],
["paid_amount", ">", 0],
["status", "not in", ["Claimed", "Returned", "Partly Claimed and Returned"]],
],
};
});
frm.set_query("expense_approver", function () {
return {
query: "hrms.hr.doctype.department_approver.department_approver.get_approvers",
filters: {
employee: frm.doc.employee,
doctype: frm.doc.doctype,
},
};
});
frm.set_query("account_head", "taxes", function () {
return {
filters: [
["company", "=", frm.doc.company],
[
"account_type",
"in",
["Tax", "Chargeable", "Income Account", "Expenses Included In Valuation"],
],
],
};
});
frm.set_query("payable_account", function () {
return {
filters: {
report_type: "Balance Sheet",
account_type: "Payable",
company: frm.doc.company,
is_group: 0,
},
};
});
frm.set_query("task", function () {
return {
filters: {
project: frm.doc.project,
},
};
});
frm.set_query("employee", function () {
return {
query: "erpnext.controllers.queries.employee_query",
};
});
},
onload: function (frm) {
erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
if (frm.doc.docstatus == 0) {
return frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_mandatory_approval",
args: {
doctype: frm.doc.doctype,
},
callback: function (r) {
if (!r.exc && r.message) {
frm.toggle_reqd("expense_approver", true);
}
},
});
}
},
refresh: function (frm) {
frm.trigger("toggle_fields");
frm.trigger("add_ledger_buttons");
if (
frm.doc.docstatus === 1 &&
frm.doc.status !== "Paid" &&
frappe.model.can_create("Payment Entry")
) {
frm.add_custom_button(
__("Payment"),
function () {
frm.events.make_payment_entry(frm);
},
__("Create"),
);
}
},
validate: function (frm) {
frm.trigger("calculate_total");
},
add_ledger_buttons: function (frm) {
if (frm.doc.docstatus > 0 && frm.doc.approval_status !== "Rejected") {
frm.add_custom_button(
__("Accounting Ledger"),
function () {
frappe.route_options = {
voucher_no: frm.doc.name,
company: frm.doc.company,
from_date: frm.doc.posting_date,
to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
group_by: "",
show_cancelled_entries: frm.doc.docstatus === 2,
};
frappe.set_route("query-report", "General Ledger");
},
__("View"),
);
}
if (!frm.doc.__islocal && frm.doc.docstatus === 1) {
let entry_doctype, entry_reference_doctype, entry_reference_name;
if (frm.doc.__onload.make_payment_via_journal_entry) {
entry_doctype = "Journal Entry";
entry_reference_doctype = "Journal Entry Account.reference_type";
entry_reference_name = "Journal Entry.reference_name";
} else {
entry_doctype = "Payment Entry";
entry_reference_doctype = "Payment Entry Reference.reference_doctype";
entry_reference_name = "Payment Entry Reference.reference_name";
}
if (
cint(frm.doc.total_amount_reimbursed) > 0 &&
frappe.model.can_read(entry_doctype)
) {
// nosemgrep: frappe-semgrep-rules.rules.frappe-cur-frm-usage
frm.add_custom_button(
__("Bank Entries"),
function () {
frappe.route_options = {
party_type: "Employee",
party: frm.doc.employee,
company: frm.doc.company,
};
frappe.set_route("List", entry_doctype);
},
__("View"),
);
}
}
},
calculate_total: function (frm) {
let total_claimed_amount = 0;
let total_sanctioned_amount = 0;
frm.doc.expenses.forEach((row) => {
total_claimed_amount += row.amount;
total_sanctioned_amount += row.sanctioned_amount;
});
frm.set_value(
"total_claimed_amount",
flt(total_claimed_amount, precision("total_claimed_amount")),
);
frm.set_value(
"total_sanctioned_amount",
flt(total_sanctioned_amount, precision("total_sanctioned_amount")),
);
},
calculate_grand_total: function (frm) {
var grand_total =
flt(frm.doc.total_sanctioned_amount) +
flt(frm.doc.total_taxes_and_charges) -
flt(frm.doc.total_advance_amount);
frm.set_value("grand_total", grand_total);
frm.refresh_fields();
},
grand_total: function (frm) {
frm.trigger("update_employee_advance_claimed_amount");
},
update_employee_advance_claimed_amount: function (frm) {
let amount_to_be_allocated = frm.doc.grand_total;
$.each(frm.doc.advances || [], function (i, advance) {
if (amount_to_be_allocated >= advance.unclaimed_amount) {
advance.allocated_amount = frm.doc.advances[i].unclaimed_amount;
amount_to_be_allocated -= advance.allocated_amount;
} else {
advance.allocated_amount = amount_to_be_allocated;
amount_to_be_allocated = 0;
}
frm.refresh_field("advances");
});
},
make_payment_entry: function (frm) {
let method = "hrms.overrides.employee_payment_entry.get_payment_entry_for_employee";
if (frm.doc.__onload && frm.doc.__onload.make_payment_via_journal_entry) {
method = "hrms.hr.doctype.expense_claim.expense_claim.make_bank_entry";
}
return frappe.call({
method: method,
args: {
dt: frm.doc.doctype,
dn: frm.doc.name,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
company: function (frm) {
erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
var expenses = frm.doc.expenses;
for (var i = 0; i < expenses.length; i++) {
var expense = expenses[i];
if (!expense.expense_type) {
continue;
}
frappe.call({
method: "hrms.hr.doctype.expense_claim.expense_claim.get_expense_claim_account_and_cost_center",
args: {
expense_claim_type: expense.expense_type,
company: frm.doc.company,
},
callback: function (r) {
if (r.message) {
expense.default_account = r.message.account;
expense.cost_center = r.message.cost_center;
}
},
});
}
},
is_paid: function (frm) {
frm.trigger("toggle_fields");
},
toggle_fields: function (frm) {
frm.toggle_reqd("mode_of_payment", frm.doc.is_paid);
},
employee: function (frm) {
frm.events.get_advances(frm);
},
cost_center: function (frm) {
frm.events.set_child_cost_center(frm);
},
validate: function (frm) {
frm.events.set_child_cost_center(frm);
},
set_child_cost_center: function (frm) {
(frm.doc.expenses || []).forEach(function (d) {
if (!d.cost_center) {
d.cost_center = frm.doc.cost_center;
}
});
},
get_taxes: function (frm) {
if (!frm.doc.taxes.length) return;
frappe.call({
method: "calculate_taxes",
doc: frm.doc,
callback: () => {
refresh_field("taxes");
frm.trigger("update_employee_advance_claimed_amount");
},
});
},
get_advances: function (frm) {
frappe.model.clear_table(frm.doc, "advances");
if (frm.doc.employee) {
return frappe.call({
method: "hrms.hr.doctype.expense_claim.expense_claim.get_advances",
args: {
employee: frm.doc.employee,
},
callback: function (r, rt) {
if (r.message) {
$.each(r.message, function (i, d) {
var row = frappe.model.add_child(
frm.doc,
"Expense Claim Advance",
"advances",
);
row.employee_advance = d.name;
row.posting_date = d.posting_date;
row.advance_account = d.advance_account;
row.advance_paid = d.paid_amount;
row.unclaimed_amount = flt(d.paid_amount) - flt(d.claimed_amount);
row.allocated_amount = 0;
});
refresh_field("advances");
}
},
});
}
},
});
frappe.ui.form.on("Expense Claim Detail", {
expense_type: function (frm, cdt, cdn) {
var d = locals[cdt][cdn];
if (!frm.doc.company) {
d.expense_type = "";
frappe.msgprint(__("Please set the Company"));
this.frm.refresh_fields();
return;
}
if (!d.expense_type) {
return;
}
return frappe.call({
method: "hrms.hr.doctype.expense_claim.expense_claim.get_expense_claim_account_and_cost_center",
args: {
expense_claim_type: d.expense_type,
company: frm.doc.company,
},
callback: function (r) {
if (r.message) {
d.default_account = r.message.account;
d.cost_center = r.message.cost_center;
}
},
});
},
amount: function (frm, cdt, cdn) {
var child = locals[cdt][cdn];
frappe.model.set_value(cdt, cdn, "sanctioned_amount", child.amount);
},
sanctioned_amount: function (frm, cdt, cdn) {
frm.trigger("calculate_total");
frm.trigger("get_taxes");
frm.trigger("calculate_grand_total");
},
cost_center: function (frm, cdt, cdn) {
erpnext.utils.copy_value_in_all_rows(frm.doc, cdt, cdn, "expenses", "cost_center");
},
});
frappe.ui.form.on("Expense Claim Advance", {
employee_advance: function (frm, cdt, cdn) {
var child = locals[cdt][cdn];
if (!frm.doc.employee) {
frappe.msgprint(__("Select an employee to get the employee advance."));
frm.doc.advances = [];
refresh_field("advances");
} else {
return frappe.call({
method: "hrms.hr.doctype.expense_claim.expense_claim.get_advances",
args: {
employee: frm.doc.employee,
advance_id: child.employee_advance,
},
callback: function (r, rt) {
if (r.message) {
child.employee_advance = r.message[0].name;
child.posting_date = r.message[0].posting_date;
child.advance_account = r.message[0].advance_account;
child.advance_paid = r.message[0].paid_amount;
child.unclaimed_amount =
flt(r.message[0].paid_amount) - flt(r.message[0].claimed_amount);
child.allocated_amount =
flt(r.message[0].paid_amount) - flt(r.message[0].claimed_amount);
frm.trigger("calculate_grand_total");
refresh_field("advances");
}
},
});
}
},
});
frappe.ui.form.on("Expense Taxes and Charges", {
account_head: function (frm, cdt, cdn) {
var child = locals[cdt][cdn];
if (child.account_head && !child.description) {
// set description from account head
child.description = child.account_head.split(" - ").slice(0, -1).join(" - ");
refresh_field("taxes");
}
},
calculate_total_tax: function (frm, cdt, cdn) {
var child = locals[cdt][cdn];
child.total = flt(frm.doc.total_sanctioned_amount) + flt(child.tax_amount);
frm.trigger("calculate_tax_amount", cdt, cdn);
},
calculate_tax_amount: function (frm) {
frm.doc.total_taxes_and_charges = 0;
(frm.doc.taxes || []).forEach(function (d) {
frm.doc.total_taxes_and_charges += d.tax_amount;
});
frm.trigger("calculate_grand_total");
},
rate: function (frm, cdt, cdn) {
var child = locals[cdt][cdn];
if (!child.amount) {
child.tax_amount = flt(frm.doc.total_sanctioned_amount) * (flt(child.rate) / 100);
}
frm.trigger("calculate_total_tax", cdt, cdn);
},
tax_amount: function (frm, cdt, cdn) {
frm.trigger("calculate_total_tax", cdt, cdn);
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim/expense_claim.js
|
JavaScript
|
agpl-3.0
| 11,401
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.mapper import get_mapped_doc
from frappe.query_builder.functions import Sum
from frappe.utils import cstr, flt, get_link_to_form
import erpnext
from erpnext.accounts.doctype.sales_invoice.sales_invoice import get_bank_cash_account
from erpnext.accounts.general_ledger import make_gl_entries
from erpnext.controllers.accounts_controller import AccountsController
import hrms
from hrms.hr.utils import set_employee_name, share_doc_with_approver, validate_active_employee
from hrms.mixins.pwa_notifications import PWANotificationsMixin
class InvalidExpenseApproverError(frappe.ValidationError):
pass
class ExpenseApproverIdentityError(frappe.ValidationError):
pass
class ExpenseClaim(AccountsController, PWANotificationsMixin):
def onload(self):
self.get("__onload").make_payment_via_journal_entry = frappe.db.get_single_value(
"Accounts Settings", "make_payment_via_journal_entry"
)
def after_insert(self):
self.notify_approver()
def validate(self):
validate_active_employee(self.employee)
set_employee_name(self)
self.validate_sanctioned_amount()
self.calculate_total_amount()
self.validate_advances()
self.set_expense_account(validate=True)
self.calculate_taxes()
self.set_status()
if self.task and not self.project:
self.project = frappe.db.get_value("Task", self.task, "project")
def set_status(self, update=False):
status = {"0": "Draft", "1": "Submitted", "2": "Cancelled"}[cstr(self.docstatus or 0)]
precision = self.precision("grand_total")
if self.docstatus == 1:
if self.approval_status == "Approved":
if (
# set as paid
self.is_paid
or (
flt(self.total_sanctioned_amount) > 0
and (
# grand total is reimbursed
(flt(self.grand_total, precision) == flt(self.total_amount_reimbursed, precision))
# grand total (to be paid) is 0 since linked advances already cover the claimed amount
or (flt(self.grand_total, precision) == 0)
)
)
):
status = "Paid"
elif flt(self.total_sanctioned_amount) > 0:
status = "Unpaid"
elif self.approval_status == "Rejected":
status = "Rejected"
if update:
self.db_set("status", status)
self.publish_update()
self.notify_update()
else:
self.status = status
def on_update(self):
share_doc_with_approver(self, self.expense_approver)
self.publish_update()
self.notify_approval_status()
def after_delete(self):
self.publish_update()
def before_submit(self):
if not self.payable_account and not self.is_paid:
frappe.throw(_("Payable Account is mandatory to submit an Expense Claim"))
def publish_update(self):
employee_user = frappe.db.get_value("Employee", self.employee, "user_id", cache=True)
hrms.refetch_resource("hrms:my_claims", employee_user)
def on_submit(self):
if self.approval_status == "Draft":
frappe.throw(_("""Approval Status must be 'Approved' or 'Rejected'"""))
self.update_task_and_project()
self.make_gl_entries()
update_reimbursed_amount(self)
self.update_claimed_amount_in_employee_advance()
def on_cancel(self):
self.update_task_and_project()
self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
if self.payable_account:
self.make_gl_entries(cancel=True)
update_reimbursed_amount(self)
self.update_claimed_amount_in_employee_advance()
self.publish_update()
def update_claimed_amount_in_employee_advance(self):
for d in self.get("advances"):
frappe.get_doc("Employee Advance", d.employee_advance).update_claimed_amount()
def update_task_and_project(self):
if self.task:
task = frappe.get_doc("Task", self.task)
ExpenseClaim = frappe.qb.DocType("Expense Claim")
task.total_expense_claim = (
frappe.qb.from_(ExpenseClaim)
.select(Sum(ExpenseClaim.total_sanctioned_amount))
.where(
(ExpenseClaim.docstatus == 1)
& (ExpenseClaim.project == self.project)
& (ExpenseClaim.task == self.task)
)
).run()[0][0]
task.save()
elif self.project:
frappe.get_doc("Project", self.project).update_project()
def make_gl_entries(self, cancel=False):
if flt(self.total_sanctioned_amount) > 0:
gl_entries = self.get_gl_entries()
make_gl_entries(gl_entries, cancel)
def get_gl_entries(self):
gl_entry = []
self.validate_account_details()
# payable entry
if self.grand_total:
gl_entry.append(
self.get_gl_dict(
{
"account": self.payable_account,
"credit": self.grand_total,
"credit_in_account_currency": self.grand_total,
"against": ",".join([d.default_account for d in self.expenses]),
"party_type": "Employee",
"party": self.employee,
"against_voucher_type": self.doctype,
"against_voucher": self.name,
"cost_center": self.cost_center,
"project": self.project,
},
item=self,
)
)
# expense entries
for data in self.expenses:
gl_entry.append(
self.get_gl_dict(
{
"account": data.default_account,
"debit": data.sanctioned_amount,
"debit_in_account_currency": data.sanctioned_amount,
"against": self.employee,
"cost_center": data.cost_center or self.cost_center,
"project": data.project or self.project,
},
item=data,
)
)
for data in self.advances:
gl_entry.append(
self.get_gl_dict(
{
"account": data.advance_account,
"credit": data.allocated_amount,
"credit_in_account_currency": data.allocated_amount,
"against": ",".join([d.default_account for d in self.expenses]),
"party_type": "Employee",
"party": self.employee,
"against_voucher_type": "Employee Advance",
"against_voucher": data.employee_advance,
}
)
)
self.add_tax_gl_entries(gl_entry)
if self.is_paid and self.grand_total:
# payment entry
payment_account = get_bank_cash_account(self.mode_of_payment, self.company).get("account")
gl_entry.append(
self.get_gl_dict(
{
"account": payment_account,
"credit": self.grand_total,
"credit_in_account_currency": self.grand_total,
"against": self.employee,
},
item=self,
)
)
gl_entry.append(
self.get_gl_dict(
{
"account": self.payable_account,
"party_type": "Employee",
"party": self.employee,
"against": payment_account,
"debit": self.grand_total,
"debit_in_account_currency": self.grand_total,
"against_voucher": self.name,
"against_voucher_type": self.doctype,
},
item=self,
)
)
return gl_entry
def add_tax_gl_entries(self, gl_entries):
# tax table gl entries
for tax in self.get("taxes"):
gl_entries.append(
self.get_gl_dict(
{
"account": tax.account_head,
"debit": tax.tax_amount,
"debit_in_account_currency": tax.tax_amount,
"against": self.employee,
"cost_center": tax.cost_center or self.cost_center,
"project": tax.project or self.project,
"against_voucher_type": self.doctype,
"against_voucher": self.name,
},
item=tax,
)
)
def validate_account_details(self):
for data in self.expenses:
if not data.cost_center:
frappe.throw(
_("Row {0}: {1} is required in the expenses table to book an expense claim.").format(
data.idx, frappe.bold(_("Cost Center"))
)
)
if self.is_paid:
if not self.mode_of_payment:
frappe.throw(_("Mode of payment is required to make a payment").format(self.employee))
def calculate_total_amount(self):
self.total_claimed_amount = 0
self.total_sanctioned_amount = 0
for d in self.get("expenses"):
self.round_floats_in(d)
if self.approval_status == "Rejected":
d.sanctioned_amount = 0.0
self.total_claimed_amount += flt(d.amount)
self.total_sanctioned_amount += flt(d.sanctioned_amount)
self.round_floats_in(self, ["total_claimed_amount", "total_sanctioned_amount"])
@frappe.whitelist()
def calculate_taxes(self):
self.total_taxes_and_charges = 0
for tax in self.taxes:
self.round_floats_in(tax)
if tax.rate:
tax.tax_amount = flt(
flt(self.total_sanctioned_amount) * flt(flt(tax.rate) / 100),
tax.precision("tax_amount"),
)
tax.total = flt(tax.tax_amount) + flt(self.total_sanctioned_amount)
self.total_taxes_and_charges += flt(tax.tax_amount)
self.round_floats_in(self, ["total_taxes_and_charges"])
self.grand_total = (
flt(self.total_sanctioned_amount)
+ flt(self.total_taxes_and_charges)
- flt(self.total_advance_amount)
)
self.round_floats_in(self, ["grand_total"])
def validate_advances(self):
self.total_advance_amount = 0
for d in self.get("advances"):
self.round_floats_in(d)
ref_doc = frappe.db.get_value(
"Employee Advance",
d.employee_advance,
["posting_date", "paid_amount", "claimed_amount", "advance_account"],
as_dict=1,
)
d.posting_date = ref_doc.posting_date
d.advance_account = ref_doc.advance_account
d.advance_paid = ref_doc.paid_amount
d.unclaimed_amount = flt(ref_doc.paid_amount) - flt(ref_doc.claimed_amount)
if d.allocated_amount and flt(d.allocated_amount) > flt(d.unclaimed_amount):
frappe.throw(
_("Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}").format(
d.idx, d.allocated_amount, d.unclaimed_amount
)
)
self.total_advance_amount += flt(d.allocated_amount)
if self.total_advance_amount:
self.round_floats_in(self, ["total_advance_amount"])
precision = self.precision("total_advance_amount")
amount_with_taxes = flt(
(flt(self.total_sanctioned_amount, precision) + flt(self.total_taxes_and_charges, precision)),
precision,
)
if flt(self.total_advance_amount, precision) > amount_with_taxes:
frappe.throw(_("Total advance amount cannot be greater than total sanctioned amount"))
def validate_sanctioned_amount(self):
for d in self.get("expenses"):
if flt(d.sanctioned_amount) > flt(d.amount):
frappe.throw(
_("Sanctioned Amount cannot be greater than Claim Amount in Row {0}.").format(d.idx)
)
def set_expense_account(self, validate=False):
for expense in self.expenses:
if not expense.default_account or not validate:
expense.default_account = get_expense_claim_account(expense.expense_type, self.company)[
"account"
]
def update_reimbursed_amount(doc):
total_amount_reimbursed = get_total_reimbursed_amount(doc)
doc.total_amount_reimbursed = total_amount_reimbursed
frappe.db.set_value("Expense Claim", doc.name, "total_amount_reimbursed", total_amount_reimbursed)
doc.set_status(update=True)
def get_total_reimbursed_amount(doc):
if doc.is_paid:
# No need to check for cancelled state here as it will anyways update status as cancelled
return doc.grand_total
else:
amount_via_jv = frappe.db.get_value(
"Journal Entry Account",
{"reference_name": doc.name, "docstatus": 1},
"sum(debit_in_account_currency - credit_in_account_currency)",
)
amount_via_payment_entry = frappe.db.get_value(
"Payment Entry Reference", {"reference_name": doc.name, "docstatus": 1}, "sum(allocated_amount)"
)
return flt(amount_via_jv) + flt(amount_via_payment_entry)
def get_outstanding_amount_for_claim(claim):
if isinstance(claim, str):
claim = frappe.db.get_value(
"Expense Claim",
claim,
(
"total_sanctioned_amount",
"total_taxes_and_charges",
"total_amount_reimbursed",
"total_advance_amount",
),
as_dict=True,
)
outstanding_amt = (
flt(claim.total_sanctioned_amount)
+ flt(claim.total_taxes_and_charges)
- flt(claim.total_amount_reimbursed)
- flt(claim.total_advance_amount)
)
return outstanding_amt
@frappe.whitelist()
def make_bank_entry(dt, dn):
from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account
expense_claim = frappe.get_doc(dt, dn)
default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank")
if not default_bank_cash_account:
default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Cash")
payable_amount = get_outstanding_amount_for_claim(expense_claim)
je = frappe.new_doc("Journal Entry")
je.voucher_type = "Bank Entry"
je.company = expense_claim.company
je.remark = "Payment against Expense Claim: " + dn
je.append(
"accounts",
{
"account": expense_claim.payable_account,
"debit_in_account_currency": payable_amount,
"reference_type": "Expense Claim",
"party_type": "Employee",
"party": expense_claim.employee,
"cost_center": erpnext.get_default_cost_center(expense_claim.company),
"reference_name": expense_claim.name,
},
)
je.append(
"accounts",
{
"account": default_bank_cash_account.account,
"credit_in_account_currency": payable_amount,
"balance": default_bank_cash_account.balance,
"account_currency": default_bank_cash_account.account_currency,
"cost_center": erpnext.get_default_cost_center(expense_claim.company),
"account_type": default_bank_cash_account.account_type,
},
)
return je.as_dict()
@frappe.whitelist()
def get_expense_claim_account_and_cost_center(expense_claim_type, company):
data = get_expense_claim_account(expense_claim_type, company)
cost_center = erpnext.get_default_cost_center(company)
return {"account": data.get("account"), "cost_center": cost_center}
@frappe.whitelist()
def get_expense_claim_account(expense_claim_type, company):
account = frappe.db.get_value(
"Expense Claim Account", {"parent": expense_claim_type, "company": company}, "default_account"
)
if not account:
frappe.throw(
_("Set the default account for the {0} {1}").format(
frappe.bold(_("Expense Claim Type")),
get_link_to_form("Expense Claim Type", expense_claim_type),
)
)
return {"account": account}
@frappe.whitelist()
def get_advances(employee, advance_id=None):
advance = frappe.qb.DocType("Employee Advance")
query = frappe.qb.from_(advance).select(
advance.name,
advance.purpose,
advance.posting_date,
advance.paid_amount,
advance.claimed_amount,
advance.advance_account,
)
if not advance_id:
query = query.where(
(advance.docstatus == 1)
& (advance.employee == employee)
& (advance.paid_amount > 0)
& (advance.status.notin(["Claimed", "Returned", "Partly Claimed and Returned"]))
)
else:
query = query.where(advance.name == advance_id)
return query.run(as_dict=True)
@frappe.whitelist()
def get_expense_claim(
employee_name, company, employee_advance_name, posting_date, paid_amount, claimed_amount
):
default_payable_account = frappe.get_cached_value(
"Company", company, "default_expense_claim_payable_account"
)
default_cost_center = frappe.get_cached_value("Company", company, "cost_center")
expense_claim = frappe.new_doc("Expense Claim")
expense_claim.company = company
expense_claim.employee = employee_name
expense_claim.payable_account = default_payable_account
expense_claim.cost_center = default_cost_center
expense_claim.is_paid = 1 if flt(paid_amount) else 0
expense_claim.append(
"advances",
{
"employee_advance": employee_advance_name,
"posting_date": posting_date,
"advance_paid": flt(paid_amount),
"unclaimed_amount": flt(paid_amount) - flt(claimed_amount),
"allocated_amount": flt(paid_amount) - flt(claimed_amount),
},
)
return expense_claim
def update_payment_for_expense_claim(doc, method=None):
"""
Updates payment/reimbursed amount in Expense Claim
on Payment Entry/Journal Entry cancellation/submission
"""
if doc.doctype == "Payment Entry" and not (doc.payment_type == "Pay" and doc.party):
return
payment_table = "accounts" if doc.doctype == "Journal Entry" else "references"
doctype_field = "reference_type" if doc.doctype == "Journal Entry" else "reference_doctype"
for d in doc.get(payment_table):
if d.get(doctype_field) == "Expense Claim" and d.reference_name:
expense_claim = frappe.get_doc("Expense Claim", d.reference_name)
update_reimbursed_amount(expense_claim)
if doc.doctype == "Payment Entry":
update_outstanding_amount_in_payment_entry(expense_claim, d.name)
def update_outstanding_amount_in_payment_entry(expense_claim: dict, pe_reference: str):
"""updates outstanding amount back in Payment Entry reference"""
# TODO: refactor convoluted code after erpnext payment entry becomes extensible
outstanding_amount = get_outstanding_amount_for_claim(expense_claim)
frappe.db.set_value("Payment Entry Reference", pe_reference, "outstanding_amount", outstanding_amount)
def validate_expense_claim_in_jv(doc, method=None):
"""Validates Expense Claim amount in Journal Entry"""
for d in doc.accounts:
if d.reference_type == "Expense Claim":
outstanding_amt = get_outstanding_amount_for_claim(d.reference_name)
if d.debit > outstanding_amt:
frappe.throw(
_(
"Row No {0}: Amount cannot be greater than the Outstanding Amount against Expense Claim {1}. Outstanding Amount is {2}"
).format(d.idx, d.reference_name, outstanding_amt)
)
@frappe.whitelist()
def make_expense_claim_for_delivery_trip(source_name, target_doc=None):
doc = get_mapped_doc(
"Delivery Trip",
source_name,
{"Delivery Trip": {"doctype": "Expense Claim", "field_map": {"name": "delivery_trip"}}},
target_doc,
)
return doc
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim/expense_claim.py
|
Python
|
agpl-3.0
| 17,476
|
from frappe import _
def get_data():
return {
"fieldname": "reference_name",
"internal_links": {"Employee Advance": ["advances", "employee_advance"]},
"transactions": [
{"label": _("Payment"), "items": ["Payment Entry", "Journal Entry"]},
{"label": _("Reference"), "items": ["Employee Advance"]},
],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim/expense_claim_dashboard.py
|
Python
|
agpl-3.0
| 320
|
frappe.listview_settings["Expense Claim"] = {
add_fields: ["company"],
};
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim/expense_claim_list.js
|
JavaScript
|
agpl-3.0
| 75
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class ExpenseClaimAccount(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim_account/expense_claim_account.py
|
Python
|
agpl-3.0
| 209
|
# Copyright (c) 2017, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class ExpenseClaimAdvance(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim_advance/expense_claim_advance.py
|
Python
|
agpl-3.0
| 209
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from frappe.model.document import Document
class ExpenseClaimDetail(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim_detail/expense_claim_detail.py
|
Python
|
agpl-3.0
| 216
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.ui.form.on("Expense Claim Type", {
refresh: function (frm) {
frm.fields_dict["accounts"].grid.get_field("default_account").get_query = function (
doc,
cdt,
cdn,
) {
var d = locals[cdt][cdn];
return {
filters: {
is_group: 0,
root_type: frm.doc.deferred_expense_account ? "Asset" : "Expense",
company: d.company,
},
};
};
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim_type/expense_claim_type.js
|
JavaScript
|
agpl-3.0
| 513
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.document import Document
class ExpenseClaimType(Document):
def validate(self):
self.validate_accounts()
self.validate_repeating_companies()
def validate_repeating_companies(self):
"""Error when Same Company is entered multiple times in accounts"""
accounts_list = []
for entry in self.accounts:
accounts_list.append(entry.company)
if len(accounts_list) != len(set(accounts_list)):
frappe.throw(_("Same Company is entered more than once"))
def validate_accounts(self):
for entry in self.accounts:
"""Error when Company of Ledger account doesn't match with Company Selected"""
if frappe.db.get_value("Account", entry.default_account, "company") != entry.company:
frappe.throw(
_("Account {0} does not match with Company {1}").format(
entry.default_account, entry.company
)
)
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_claim_type/expense_claim_type.py
|
Python
|
agpl-3.0
| 1,013
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class ExpenseTaxesandCharges(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/expense_taxes_and_charges/expense_taxes_and_charges.py
|
Python
|
agpl-3.0
| 228
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Full and Final Asset", {
// refresh: function(frm) {
// }
});
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_asset/full_and_final_asset.js
|
JavaScript
|
agpl-3.0
| 205
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class FullandFinalAsset(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_asset/full_and_final_asset.py
|
Python
|
agpl-3.0
| 222
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class FullandFinalOutstandingStatement(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_outstanding_statement/full_and_final_outstanding_statement.py
|
Python
|
agpl-3.0
| 237
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Full and Final Statement", {
refresh: function (frm) {
frm.events.set_queries(frm, "payables");
frm.events.set_queries(frm, "receivables");
if (frm.doc.docstatus == 1 && frm.doc.status == "Unpaid") {
frm.add_custom_button(__("Create Journal Entry"), function () {
frm.events.create_journal_entry(frm);
});
}
},
set_queries: function (frm, type) {
frm.set_query("reference_document_type", type, function () {
let modules = ["HR", "Payroll", "Loan Management"];
return {
filters: {
istable: 0,
issingle: 0,
module: ["In", modules],
},
};
});
let filters = {};
frm.set_query("reference_document", type, function (doc, cdt, cdn) {
let fnf_doc = frappe.get_doc(cdt, cdn);
frappe.model.with_doctype(fnf_doc.reference_document_type, function () {
if (frappe.model.is_tree(fnf_doc.reference_document_type)) {
filters["is_group"] = 0;
}
if (frappe.meta.has_field(fnf_doc.reference_document_type, "company")) {
filters["company"] = frm.doc.company;
}
if (frappe.meta.has_field(fnf_doc.reference_document_type, "employee")) {
filters["employee"] = frm.doc.employee;
}
});
return {
filters: filters,
};
});
},
employee: function (frm) {
frm.events.get_outstanding_statements(frm);
},
total_asset_recovery_cost: function (frm) {
frm.trigger("calculate_total_receivable_amt");
},
get_outstanding_statements: function (frm) {
if (frm.doc.employee) {
frappe.call({
method: "get_outstanding_statements",
doc: frm.doc,
callback: function () {
frm.refresh();
},
});
}
},
calculate_total_payable_amt: function (frm) {
let total_payable_amount = 0;
frm.doc.payables?.forEach(
(row) => (total_payable_amount += flt(row.amount, precision("amount", row))),
);
frm.set_value(
"total_payable_amount",
flt(total_payable_amount, precision("total_payable_amount")),
);
},
calculate_total_receivable_amt: function (frm) {
let total_asset_recovery_cost = 0;
let total_receivable_amount = 0;
frm.doc.assets_allocated?.forEach((row) => {
if (row.action === "Recover Cost") {
total_asset_recovery_cost += flt(row.cost, precision("cost", row));
}
});
frm.doc.receivables?.forEach(
(row) => (total_receivable_amount += flt(row.amount, precision("amount", row))),
);
frm.set_value(
"total_asset_recovery_cost",
flt(total_asset_recovery_cost, precision("total_asset_recovery_cost")),
);
frm.set_value(
"total_receivable_amount",
flt(
total_asset_recovery_cost + total_receivable_amount,
precision("total_receivable_amount"),
),
);
},
create_journal_entry: function (frm) {
frappe.call({
method: "create_journal_entry",
doc: frm.doc,
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
});
frappe.ui.form.on("Full and Final Outstanding Statement", {
reference_document: function (frm, cdt, cdn) {
const child = locals[cdt][cdn];
if (child.reference_document_type && child.reference_document) {
frappe.call({
method: "hrms.hr.doctype.full_and_final_statement.full_and_final_statement.get_account_and_amount",
args: {
ref_doctype: child.reference_document_type,
ref_document: child.reference_document,
},
callback: function (r) {
if (r.message) {
frappe.model.set_value(cdt, cdn, "account", r.message[0]);
frappe.model.set_value(cdt, cdn, "amount", r.message[1]);
}
},
});
}
},
amount: function (frm, cdt, cdn) {
const child_row = locals[cdt][cdn];
const table = child_row.parentfield;
if (table === "payables") {
frm.trigger("calculate_total_payable_amt");
} else {
frm.trigger("calculate_total_receivable_amt");
}
},
});
frappe.ui.form.on("Full and Final Asset", {
cost: function (frm, _cdt, _cdn) {
frm.trigger("calculate_total_receivable_amt");
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_statement/full_and_final_statement.js
|
JavaScript
|
agpl-3.0
| 4,124
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import flt, get_link_to_form, today
class FullandFinalStatement(Document):
def before_insert(self):
self.get_outstanding_statements()
def validate(self):
self.validate_relieving_date()
self.get_assets_statements()
self.set_total_asset_recovery_cost()
self.set_totals()
def before_submit(self):
self.validate_settlement("payables")
self.validate_settlement("receivables")
self.validate_assets()
def on_cancel(self):
self.ignore_linked_doctypes = ("GL Entry",)
def validate_relieving_date(self):
if not self.relieving_date:
frappe.throw(
_("Please set {0} for Employee {1}").format(
frappe.bold(_("Relieving Date")),
get_link_to_form("Employee", self.employee),
),
title=_("Missing Relieving Date"),
)
def validate_settlement(self, component_type):
for data in self.get(component_type, []):
if data.status == "Unsettled":
frappe.throw(
_("Settle all Payables and Receivables before submission"),
title=_("Unsettled Transactions"),
)
def validate_assets(self):
pending_returns = []
for data in self.assets_allocated:
if data.action == "Return":
if data.status == "Owned":
pending_returns.append(_("Row {0}: {1}").format(data.idx, frappe.bold(data.asset_name)))
elif data.action == "Recover Cost":
data.status = "Owned"
if pending_returns:
msg = _("All allocated assets should be returned before submission")
msg += "<br><br>"
msg += ", ".join(d for d in pending_returns)
frappe.throw(msg, title=_("Pending Asset Returns"))
@frappe.whitelist()
def get_outstanding_statements(self):
if not self.relieving_date:
frappe.throw(
_("Set Relieving Date for Employee: {0}").format(get_link_to_form("Employee", self.employee))
)
if not self.payables:
self.add_withheld_salary_slips()
components = self.get_payable_component()
self.create_component_row(components, "payables")
if not self.receivables:
components = self.get_receivable_component()
self.create_component_row(components, "receivables")
self.get_assets_statements()
def get_assets_statements(self):
if not len(self.get("assets_allocated", [])):
for data in self.get_assets_movement():
self.append("assets_allocated", data)
def set_total_asset_recovery_cost(self):
total_cost = 0
for data in self.assets_allocated:
if data.action == "Recover Cost":
if not data.description:
data.description = _("Asset Recovery Cost for {0}: {1}").format(
data.reference, data.asset_name
)
total_cost += flt(data.cost)
self.total_asset_recovery_cost = flt(total_cost, self.precision("total_asset_recovery_cost"))
def set_totals(self):
total_payable = sum(flt(row.amount) for row in self.payables)
total_receivable = sum(flt(row.amount) for row in self.receivables)
self.total_payable_amount = flt(total_payable, self.precision("total_payable_amount"))
self.total_receivable_amount = flt(
total_receivable + flt(self.total_asset_recovery_cost),
self.precision("total_receivable_amount"),
)
def add_withheld_salary_slips(self):
salary_slips = frappe.get_all(
"Salary Slip",
filters={
"employee": self.employee,
"status": "Withheld",
"docstatus": ("!=", 2),
},
fields=["name", "net_pay"],
)
for slip in salary_slips:
self.append(
"payables",
{
"status": "Unsettled",
"component": "Salary Slip",
"reference_document_type": "Salary Slip",
"reference_document": slip.name,
"amount": slip.net_pay,
"paid_via_salary_slip": 1,
},
)
def create_component_row(self, components, component_type):
for component in components:
self.append(
component_type,
{
"status": "Unsettled",
"reference_document_type": component if component != "Bonus" else "Additional Salary",
"component": component,
},
)
def get_payable_component(self):
return [
"Gratuity",
"Expense Claim",
"Bonus",
"Leave Encashment",
]
def get_receivable_component(self):
receivables = ["Employee Advance"]
if "lending" in frappe.get_installed_apps():
receivables.append("Loan")
return receivables
def get_assets_movement(self):
asset_movements = frappe.get_all(
"Asset Movement Item",
filters={"docstatus": 1},
fields=["asset", "from_employee", "to_employee", "parent", "asset_name"],
or_filters={"from_employee": self.employee, "to_employee": self.employee},
)
data = []
inward_movements = []
outward_movements = []
for movement in asset_movements:
if movement.to_employee and movement.to_employee == self.employee:
inward_movements.append(movement)
if movement.from_employee and movement.from_employee == self.employee:
outward_movements.append(movement)
for movement in inward_movements:
outwards_count = [movement.asset for movement in outward_movements].count(movement.asset)
inwards_counts = [movement.asset for movement in inward_movements].count(movement.asset)
if inwards_counts > outwards_count:
cost = frappe.db.get_value("Asset", movement.asset, "total_asset_cost")
data.append(
{
"reference": movement.parent,
"asset_name": movement.asset_name,
"date": frappe.db.get_value("Asset Movement", movement.parent, "transaction_date"),
"actual_cost": cost,
"cost": cost,
"action": "Return",
"status": "Owned",
}
)
return data
@frappe.whitelist()
def create_journal_entry(self):
precision = frappe.get_precision("Journal Entry Account", "debit_in_account_currency")
jv = frappe.new_doc("Journal Entry")
jv.company = self.company
jv.voucher_type = "Bank Entry"
jv.posting_date = today()
difference = self.total_payable_amount - self.total_receivable_amount
for data in self.payables:
if flt(data.amount) > 0 and not data.paid_via_salary_slip:
account_dict = {
"account": data.account,
"debit_in_account_currency": flt(data.amount, precision),
"user_remark": data.remark,
}
if data.reference_document_type == "Expense Claim":
account_dict["party_type"] = "Employee"
account_dict["party"] = self.employee
jv.append("accounts", account_dict)
for data in self.receivables:
if flt(data.amount) > 0:
account_dict = {
"account": data.account,
"credit_in_account_currency": flt(data.amount, precision),
"user_remark": data.remark,
}
if data.reference_document_type == "Employee Advance":
account_dict["party_type"] = "Employee"
account_dict["party"] = self.employee
jv.append("accounts", account_dict)
for data in self.assets_allocated:
if data.action == "Recover Cost":
jv.append(
"accounts",
{
"account": data.account,
"credit_in_account_currency": flt(data.cost, precision),
"party_type": "Employee",
"party": self.employee,
"user_remark": data.description,
},
)
jv.append(
"accounts",
{
"credit_in_account_currency": difference if difference > 0 else 0,
"debit_in_account_currency": -(difference) if difference < 0 else 0,
"reference_type": self.doctype,
"reference_name": self.name,
},
)
return jv
@frappe.whitelist()
def get_account_and_amount(ref_doctype, ref_document):
if not ref_doctype or not ref_document:
return None
if ref_doctype == "Salary Slip":
salary_details = frappe.db.get_value(
"Salary Slip", ref_document, ["payroll_entry", "net_pay"], as_dict=1
)
amount = salary_details.net_pay
payable_account = (
frappe.db.get_value("Payroll Entry", salary_details.payroll_entry, "payroll_payable_account")
if salary_details.payroll_entry
else None
)
return [payable_account, amount]
if ref_doctype == "Gratuity":
payable_account, amount = frappe.db.get_value("Gratuity", ref_document, ["payable_account", "amount"])
return [payable_account, amount]
if ref_doctype == "Expense Claim":
details = frappe.db.get_value(
"Expense Claim",
ref_document,
["payable_account", "grand_total", "total_amount_reimbursed", "total_advance_amount"],
as_dict=True,
)
payable_account = details.payable_account
amount = details.grand_total - (details.total_amount_reimbursed + details.total_advance_amount)
return [payable_account, amount]
if ref_doctype == "Loan":
details = frappe.db.get_value(
"Loan", ref_document, ["payment_account", "total_payment", "total_amount_paid"], as_dict=1
)
payment_account = details.payment_account
amount = details.total_payment - details.total_amount_paid
return [payment_account, amount]
if ref_doctype == "Employee Advance":
details = frappe.db.get_value(
"Employee Advance",
ref_document,
["advance_account", "paid_amount", "claimed_amount", "return_amount"],
as_dict=1,
)
payment_account = details.advance_account
amount = details.paid_amount - (details.claimed_amount + details.return_amount)
return [payment_account, amount]
def update_full_and_final_statement_status(doc, method=None):
"""Updates FnF status on Journal Entry Submission/Cancellation"""
status = "Paid" if doc.docstatus == 1 else "Unpaid"
for entry in doc.accounts:
if entry.reference_type == "Full and Final Statement":
fnf = frappe.get_doc("Full and Final Statement", entry.reference_name)
fnf.db_set("status", status)
fnf.notify_update()
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_statement/full_and_final_statement.py
|
Python
|
agpl-3.0
| 9,548
|
frappe.listview_settings["Full and Final Statement"] = {
get_indicator: function (doc) {
var colors = {
Draft: "red",
Unpaid: "orange",
Paid: "green",
Cancelled: "red",
};
return [__(doc.status), colors[doc.status], "status,=," + doc.status];
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/full_and_final_statement/full_and_final_statement_list.js
|
JavaScript
|
agpl-3.0
| 269
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Goal", {
refresh(frm) {
frm.trigger("set_filters");
frm.trigger("add_custom_buttons");
if (frm.doc.is_group) {
frm.set_df_property(
"progress",
"description",
__("Group goal's progress is auto-calculated based on the child goals."),
);
}
},
set_filters(frm) {
frm.set_query("parent_goal", () => {
return {
filters: {
is_group: 1,
name: ["!=", frm.doc.name],
employee: frm.doc.employee,
},
};
});
frm.set_query("kra", () => {
return {
query: "hrms.hr.doctype.appraisal.appraisal.get_kras_for_employee",
filters: {
employee: frm.doc.employee,
appraisal_cycle: frm.doc.appraisal_cycle,
},
};
});
frm.set_query("appraisal_cycle", () => {
return {
filters: {
status: ["!=", "Completed"],
company: frm.doc.company,
},
};
});
},
add_custom_buttons(frm) {
if (frm.doc.__islocal || frm.doc.status === "Completed") return;
const doc_status = frm.doc.status;
if (doc_status === "Archived") {
frm.add_custom_button(
__("Unarchive"),
() => {
frm.set_value("status", "");
frm.save();
},
__("Status"),
);
}
if (doc_status === "Closed") {
frm.add_custom_button(
__("Reopen"),
() => {
frm.set_value("status", "");
frm.save();
},
__("Status"),
);
}
if (doc_status !== "Archived") {
frm.add_custom_button(
__("Archive"),
() => {
frm.set_value("status", "Archived");
frm.save();
},
__("Status"),
);
}
if (doc_status !== "Closed") {
frm.add_custom_button(
__("Close"),
() => {
frm.set_value("status", "Closed");
frm.save();
},
__("Status"),
);
}
},
kra(frm) {
if (!frm.doc.appraisal_cycle) {
frm.set_value("kra", "");
frappe.msgprint({
message: __("Please select the Appraisal Cycle first."),
title: __("Mandatory"),
});
return;
}
if (frm.doc.__islocal || !frm.doc.is_group) return;
let msg = __(
"Changing KRA in this parent goal will align all the child goals to the same KRA, if any.",
);
msg += "<br>";
msg += __("Do you still want to proceed?");
frappe.confirm(
msg,
() => {},
() => {
frappe.db.get_value("Goal", frm.doc.name, "kra", (r) =>
frm.set_value("kra", r.kra),
);
},
);
},
is_group(frm) {
if (frm.doc.__islocal && frm.doc.is_group) {
frm.set_value("progress", 0);
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/goal/goal.js
|
JavaScript
|
agpl-3.0
| 2,573
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from pypika import CustomFunction
import frappe
from frappe import _
from frappe.query_builder.functions import Avg
from frappe.utils import cint, flt
from frappe.utils.nestedset import NestedSet
from hrms.hr.doctype.appraisal_cycle.appraisal_cycle import validate_active_appraisal_cycle
from hrms.hr.utils import validate_active_employee
class Goal(NestedSet):
nsm_parent_field = "parent_goal"
def before_insert(self):
if cint(self.is_group):
self.progress = 0
def validate(self):
if self.appraisal_cycle:
validate_active_appraisal_cycle(self.appraisal_cycle)
validate_active_employee(self.employee)
self.validate_parent_fields()
self.validate_from_to_dates(self.start_date, self.end_date)
self.validate_progress()
self.set_status()
def on_update(self):
NestedSet.on_update(self)
doc_before_save = self.get_doc_before_save()
if doc_before_save:
self.update_kra_in_child_goals(doc_before_save)
if doc_before_save.parent_goal != self.parent_goal:
# parent goal changed, update progress of old parent
self.update_parent_progress(doc_before_save.parent_goal)
self.update_parent_progress()
self.update_goal_progress_in_appraisal()
def on_trash(self):
NestedSet.on_trash(self, allow_root_deletion=True)
def after_delete(self):
self.update_parent_progress()
self.update_goal_progress_in_appraisal()
def validate_parent_fields(self):
if not self.parent_goal:
return
parent_details = frappe.db.get_value(
"Goal", self.parent_goal, ["employee", "kra", "appraisal_cycle"], as_dict=True
)
if not parent_details:
return
if self.employee != parent_details.employee:
frappe.throw(
_("Goal should be owned by the same employee as its parent goal."), title=_("Not Allowed")
)
if self.kra != parent_details.kra:
frappe.throw(
_("Goal should be aligned with the same KRA as its parent goal."), title=_("Not Allowed")
)
if self.appraisal_cycle != parent_details.appraisal_cycle:
frappe.throw(
_("Goal should belong to the same Appraisal Cycle as its parent goal."),
title=_("Not Allowed"),
)
def validate_progress(self):
if flt(self.progress) > 100:
frappe.throw(_("Goal progress percentage cannot be more than 100."))
def set_status(self, status=None):
if self.status in ["Archived", "Closed"]:
return
if flt(self.progress) == 0:
self.status = "Pending"
elif flt(self.progress) == 100:
self.status = "Completed"
elif flt(self.progress) < 100:
self.status = "In Progress"
def update_kra_in_child_goals(self, doc_before_save):
"""Aligns children's KRA to parent goal's KRA if parent goal's KRA is changed"""
if doc_before_save.kra != self.kra and self.is_group:
Goal = frappe.qb.DocType("Goal")
(frappe.qb.update(Goal).set(Goal.kra, self.kra).where(Goal.parent_goal == self.name)).run()
frappe.msgprint(_("KRA updated for all child goals."), alert=True, indicator="green")
def update_parent_progress(self, old_parent=None):
parent_goal = old_parent or self.parent_goal
if not parent_goal:
return
Goal = frappe.qb.DocType("Goal")
avg_goal_completion = (
frappe.qb.from_(Goal)
.select(Avg(Goal.progress).as_("avg_goal_completion"))
.where(
(Goal.parent_goal == parent_goal)
& (Goal.employee == self.employee)
# archived goals should not contribute to progress
& (Goal.status != "Archived")
)
).run()[0][0]
parent_goal_doc = frappe.get_doc("Goal", parent_goal)
parent_goal_doc.progress = flt(avg_goal_completion, parent_goal_doc.precision("progress"))
parent_goal_doc.ignore_permissions = True
parent_goal_doc.ignore_mandatory = True
parent_goal_doc.save()
def update_goal_progress_in_appraisal(self):
if not self.appraisal_cycle:
return
appraisal = frappe.db.get_value(
"Appraisal", {"employee": self.employee, "appraisal_cycle": self.appraisal_cycle}
)
if appraisal:
appraisal = frappe.get_doc("Appraisal", appraisal)
appraisal.set_goal_score(update=True)
@frappe.whitelist()
def get_children(doctype: str, parent: str, is_root: bool = False, **filters) -> list[dict]:
Goal = frappe.qb.DocType(doctype)
query = (
frappe.qb.from_(Goal)
.select(
Goal.name.as_("value"),
Goal.goal_name.as_("title"),
Goal.is_group.as_("expandable"),
Goal.status,
Goal.employee,
Goal.employee_name,
Goal.appraisal_cycle,
Goal.progress,
Goal.kra,
)
.where(Goal.status != "Archived")
)
if filters.get("employee"):
query = query.where(Goal.employee == filters.get("employee"))
if filters.get("appraisal_cycle"):
query = query.where(Goal.appraisal_cycle == filters.get("appraisal_cycle"))
if filters.get("goal"):
query = query.where(Goal.parent_goal == filters.get("goal"))
elif parent and not is_root:
# via expand child
query = query.where(Goal.parent_goal == parent)
else:
ifnull = CustomFunction("IFNULL", ["value", "default"])
query = query.where(ifnull(Goal.parent_goal, "") == "")
if filters.get("date_range"):
date_range = frappe.parse_json(filters.get("date_range"))
query = query.where(
(Goal.start_date.between(date_range[0], date_range[1]))
& ((Goal.end_date.isnull()) | (Goal.end_date.between(date_range[0], date_range[1])))
)
goals = query.orderby(Goal.employee, Goal.kra).run(as_dict=True)
_update_goal_completion_status(goals)
return goals
def _update_goal_completion_status(goals: list[dict]) -> list[dict]:
for goal in goals:
if goal.expandable: # group node
total_goals = frappe.db.count("Goal", dict(parent_goal=goal.value))
if total_goals:
completed = frappe.db.count("Goal", {"parent_goal": goal.value, "status": "Completed"}) or 0
# set completion status of group node
goal["completion_count"] = _("{0} of {1} Completed").format(completed, total_goals)
return goals
@frappe.whitelist()
def update_progress(progress: float, goal: str) -> None:
goal = frappe.get_doc("Goal", goal)
goal.progress = progress
goal.flags.ignore_mandatory = True
goal.save()
return goal
@frappe.whitelist()
def update_status(status: str, goals: str | list) -> None:
if isinstance(goals, str):
import json
goals = json.loads(goals)
for goal in goals:
goal = frappe.get_doc("Goal", goal)
goal.status = status
if status == "Completed":
goal.progress = 100
goal.flags.ignore_mandatory = True
goal.save()
return goals
@frappe.whitelist()
def add_tree_node():
from frappe.desk.treeview import make_tree_args
args = frappe.form_dict
args = make_tree_args(**args)
if args.parent_goal == "All Goals" or not frappe.db.exists("Goal", args.parent_goal):
args.parent_goal = None
frappe.get_doc(args).insert()
|
2302_79757062/hrms
|
hrms/hr/doctype/goal/goal.py
|
Python
|
agpl-3.0
| 6,779
|
frappe.listview_settings["Goal"] = {
add_fields: ["end_date", "status"],
get_indicator: function (doc) {
const status_color = {
Pending: "yellow",
"In Progress": "orange",
Completed: "green",
Archived: "gray",
Closed: "red",
};
return [__(doc.status), status_color[doc.status], "status,=," + doc.status];
},
formatters: {
end_date(value, df, doc) {
if (!value) return "";
if (doc.status === "Completed" || doc.status === "Archived") return "";
const d = moment(value);
const now = moment();
const color = d < now ? "red" : "green";
return `
<div
class="pill"
style="background-color: var(--bg-${color}); color: var(--text-on-${color}); font-weight:500">
${d.fromNow()}
</div>
`;
},
},
onload: function (listview) {
const status_menu = listview.page.add_custom_button_group(__("Update Status"));
const options = [
{ present: "Complete", past: "Completed" },
{ present: "Archive", past: "Archived" },
{ present: "Close", past: "Closed" },
{ present: "Unarchive", past: "Unarchived" },
{ present: "Reopen", past: "Reopened" },
];
options.forEach((option) => {
listview.page.add_custom_menu_item(status_menu, __(option.present), () =>
this.trigger_update_status_dialog(option.past, listview),
);
});
},
trigger_update_status_dialog: function (status, listview) {
const checked_items = listview.get_checked_items();
const items_to_be_updated = checked_items
.filter(
(item) =>
!item.is_group &&
get_applicable_current_statuses(status).includes(item.status),
)
.map((item) => item.name);
if (!items_to_be_updated.length) return this.trigger_error_dialogs(checked_items, status);
if (status === "Unarchived" || status === "Reopened") {
const simple_present_tense = {
Unarchived: "Unarchive",
Reopened: "Reopen",
};
frappe.confirm(
__("{0} {1} {2}?", [
simple_present_tense[status],
items_to_be_updated.length.toString(),
items_to_be_updated.length === 1 ? __("goal") : __("goals"),
]),
() => {
this.update_status("", items_to_be_updated, listview);
this.trigger_error_dialogs(checked_items, status);
},
);
} else {
frappe.confirm(
__("Mark {0} {1} as {2}?", [
items_to_be_updated.length.toString(),
items_to_be_updated.length === 1 ? __("goal") : __("goals"),
status,
]),
() => {
this.update_status(status, items_to_be_updated, listview);
this.trigger_error_dialogs(checked_items, status);
},
);
}
},
trigger_error_dialogs: function (checked_items, status) {
if (!checked_items.length) {
frappe.throw(__("No items selected"));
return;
}
if (checked_items.some((item) => item.is_group))
frappe.msgprint({
title: __("Error"),
message: __("Cannot update status of Goal groups"),
indicator: "orange",
});
const applicable_statuses = get_applicable_current_statuses(status);
if (checked_items.some((item) => !applicable_statuses.includes(item.status)))
frappe.msgprint({
title: __("Error"),
message: __("Only {0} Goals can be {1}", [
frappe.utils.comma_and(applicable_statuses),
status,
]),
indicator: "orange",
});
},
update_status: function (status, goals, listview) {
frappe
.call({
method: "hrms.hr.doctype.goal.goal.update_status",
args: {
status: status,
goals: goals,
},
})
.then((r) => {
if (!r.exc && r.message) {
frappe.show_alert({
message: __("Goals updated successfully"),
indicator: "green",
});
} else {
frappe.msgprint(__("Could not update goals"));
}
listview.clear_checked_items();
listview.refresh();
});
},
};
// Returns all possible current statuses that can be changed to the new one
const get_applicable_current_statuses = (new_status) => {
switch (new_status) {
case "Completed":
return ["Pending", "In Progress"];
case "Archived":
return ["Pending", "In Progress", "Closed"];
case "Closed":
return ["Pending", "In Progress", "Archived"];
case "Unarchived":
return ["Archived"];
case "Reopened":
return ["Closed"];
}
};
|
2302_79757062/hrms
|
hrms/hr/doctype/goal/goal_list.js
|
JavaScript
|
agpl-3.0
| 4,180
|
frappe.provide("frappe.treeview_settings");
frappe.treeview_settings["Goal"] = {
get_tree_nodes: "hrms.hr.doctype.goal.goal.get_children",
filters: [
{
fieldname: "company",
fieldtype: "Select",
options: erpnext.utils.get_tree_options("company"),
label: __("Company"),
default: erpnext.utils.get_tree_default("company"),
},
{
fieldname: "appraisal_cycle",
fieldtype: "Link",
options: "Appraisal Cycle",
label: __("Appraisal Cycle"),
get_query() {
const company =
frappe.treeview_settings["Goal"].page.fields_dict.company.get_value();
return {
filters: {
company: company,
},
};
},
},
{
fieldname: "employee",
fieldtype: "Link",
options: "Employee",
label: __("Employee"),
},
{
fieldname: "date_range",
fieldtype: "DateRange",
label: __("Date Range"),
},
],
fields: [
{
fieldtype: "Data",
fieldname: "goal_name",
label: __("Goal"),
reqd: 1,
},
{
fieldtype: "Check",
fieldname: "is_group",
label: __("Is Group"),
description: __("Child nodes can only be created under 'Group' type nodes"),
},
{
fieldtype: "Section Break",
},
{
fieldtype: "Link",
fieldname: "employee",
label: __("Employee"),
options: "Employee",
reqd: 1,
default() {
const treeview = frappe.treeview_settings["Goal"].treeview;
let employee =
treeview.tree.get_selected_node().data.employee ||
treeview.tree.session_employee ||
"";
return employee;
},
},
{
fieldtype: "Percent",
fieldname: "progress",
label: __("Progress"),
},
{
fieldtype: "Column Break",
},
{
fieldtype: "Date",
fieldname: "start_date",
label: __("Start Date"),
reqd: 1,
default: frappe.datetime.month_start(),
},
{
fieldtype: "Date",
fieldname: "end_date",
label: __("End Date"),
default: frappe.datetime.month_end(),
},
{
fieldtype: "Section Break",
label: __("Appraisal Linking"),
description: __(
"Link the cycle and tag KRA to your goal to update the appraisal's goal score based on the goal progress",
),
depends_on: "eval:doc.employee",
},
{
fieldtype: "Link",
fieldname: "appraisal_cycle",
label: __("Appraisal Cycle"),
options: "Appraisal Cycle",
get_query() {
const company =
frappe.treeview_settings["Goal"].page.fields_dict.company.get_value();
return {
filters: {
company: company,
status: ["!=", "Completed"],
},
};
},
default() {
const treeview = frappe.treeview_settings["Goal"].treeview;
let appraisal_cycle =
treeview.page.fields_dict.appraisal_cycle.get_value() ||
treeview.tree.get_selected_node().data.appraisal_cycle ||
"";
return appraisal_cycle;
},
},
{
fieldtype: "Column Break",
},
{
fieldtype: "Link",
fieldname: "kra",
label: __("KRA"),
options: "KRA",
mandatory_depends_on: "eval:doc.appraisal_cycle && !doc.parent_goal",
get_query() {
return {
query: "hrms.hr.doctype.appraisal.appraisal.get_kras_for_employee",
filters: {
employee: cur_dialog.get_value("employee"),
appraisal_cycle: cur_dialog.get_value("appraisal_cycle"),
},
};
},
default() {
const treeview = frappe.treeview_settings["Goal"].treeview;
return treeview.tree.get_selected_node().data.kra;
},
},
{
fieldtype: "Section Break",
fieldname: "description_section",
label: __("Description"),
collapsible: 1,
depends_on: "eval:doc.employee",
},
{
fieldtype: "Text Editor",
fieldname: "description",
},
],
onload(treeview) {
frappe.treeview_settings["Goal"].page = {};
$.extend(frappe.treeview_settings["Goal"].page, treeview.page);
treeview.make_tree();
// set the current session employee
frappe.db
.get_value("Employee", { user_id: frappe.session.user }, "name")
.then((employee_record) => {
treeview.tree.session_employee = employee_record?.message?.name;
});
},
onrender(node) {
// show KRA against the goal
if (node.data.kra) {
$(node.$tree_link).find(".tree-label").append(`
<span
class="pill small"
style="background-color: var(--bg-light-gray); color: var(--text-on-gray);">
${node.data.kra}
</span>
`);
}
// show goal completion status
if (node.data.completion_count !== undefined) {
$(`
<span class="balance-area pull-right text-muted small">
${node.data.completion_count}
</span>
`).insertBefore(node.$ul);
} else if (node.data && node.data.status !== undefined) {
const status_color = {
Pending: "yellow",
"In Progress": "orange",
Completed: "green",
Archived: "gray",
};
$(`
<span
class="pill small pull-right"
style="background-color: var(--bg-${status_color[node.data.status]}); color: var(--text-on-${
status_color[node.data.status]
}); font-weight:500">
${node.data.status}
</span>
`).insertBefore(node.$ul);
}
},
breadcrumb: "Performance",
get_tree_root: false,
add_tree_node: "hrms.hr.doctype.goal.goal.add_tree_node",
root_label: __("All Goals"),
ignore_fields: ["parent_goal"],
post_render(treeview) {
frappe.treeview_settings["Goal"].treeview = {};
$.extend(frappe.treeview_settings["Goal"].treeview, treeview);
},
get_label(node) {
if (node.title && node.title !== node.label) {
return (
__(node.title) + ` <span class="text-muted">(${node.data.employee_name})</span>`
);
} else {
return __(node.title || node.label);
}
},
toolbar: [
{
label: __("Update Progress"),
condition: function (node) {
return !node.root && !node.expandable;
},
click: function (node) {
const dialog = new frappe.ui.Dialog({
title: __("Update Progress"),
fields: [
{
fieldname: "progress",
fieldtype: "Percent",
in_place_edit: true,
default: node.data.progress,
},
],
primary_action: function () {
dialog.hide();
return update_progress(node, dialog.get_values()["progress"]);
},
primary_action_label: __("Update"),
});
dialog.show();
},
},
{
label: __("Mark as Completed"),
condition: function (node) {
return !node.is_root && !node.expandable && node.data.status != "Completed";
},
click: function (node) {
frappe.confirm(__("Mark {0} as Completed?", [node.label.bold()]), () =>
update_progress(node, 100),
);
},
},
],
extend_toolbar: true,
};
function update_progress(node, progress) {
return frappe
.call({
method: "hrms.hr.doctype.goal.goal.update_progress",
args: {
goal: node.data.value,
progress: progress,
},
})
.then((r) => {
if (!r.exc && r.message) {
frappe.treeview_settings["Goal"].treeview.tree.load_children(
frappe.treeview_settings["Goal"].treeview.tree.root_node,
true,
);
frappe.show_alert({
message: __("Goal updated successfully"),
indicator: "green",
});
} else {
frappe.msgprint(__("Could not update Goal"));
}
});
}
|
2302_79757062/hrms
|
hrms/hr/doctype/goal/goal_tree.js
|
JavaScript
|
agpl-3.0
| 7,065
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Grievance Type", {
// refresh: function(frm) {
// }
});
|
2302_79757062/hrms
|
hrms/hr/doctype/grievance_type/grievance_type.js
|
JavaScript
|
agpl-3.0
| 199
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class GrievanceType(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/grievance_type/grievance_type.py
|
Python
|
agpl-3.0
| 218
|
// Copyright (c) 2016, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("HR Settings", {
refresh: function (frm) {
frm.set_query("sender", () => {
return {
filters: {
enable_outgoing: 1,
},
};
});
frm.set_query("hiring_sender", () => {
return {
filters: {
enable_outgoing: 1,
},
};
});
},
});
frappe.tour["HR Settings"] = [
{
fieldname: "emp_created_by",
title: "Employee Naming By",
description: __(
"Employee can be named by Employee ID if you assign one, or via Naming Series. Select your preference here.",
),
},
{
fieldname: "standard_working_hours",
title: "Standard Working Hours",
description: __(
"Enter the Standard Working Hours for a normal work day. These hours will be used in calculations of reports such as Employee Hours Utilization and Project Profitability analysis.",
),
},
{
fieldname: "leave_and_expense_claim_settings",
title: "Leave and Expense Claim Settings",
description: __(
"Review various other settings related to Employee Leaves and Expense Claim",
),
},
];
|
2302_79757062/hrms
|
hrms/hr/doctype/hr_settings/hr_settings.js
|
JavaScript
|
agpl-3.0
| 1,146
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
# For license information, please see license.txt
import frappe
from frappe.model.document import Document
from frappe.utils import format_date
# Wether to proceed with frequency change
PROCEED_WITH_FREQUENCY_CHANGE = False
class HRSettings(Document):
def validate(self):
self.set_naming_series()
# Based on proceed flag
global PROCEED_WITH_FREQUENCY_CHANGE
if not PROCEED_WITH_FREQUENCY_CHANGE:
self.validate_frequency_change()
PROCEED_WITH_FREQUENCY_CHANGE = False
def set_naming_series(self):
from erpnext.utilities.naming import set_by_naming_series
set_by_naming_series(
"Employee",
"employee_number",
self.get("emp_created_by") == "Naming Series",
hide_name_field=True,
)
def validate_frequency_change(self):
weekly_job, monthly_job = None, None
try:
weekly_job = frappe.get_doc(
"Scheduled Job Type", "employee_reminders.send_reminders_in_advance_weekly"
)
monthly_job = frappe.get_doc(
"Scheduled Job Type", "employee_reminders.send_reminders_in_advance_monthly"
)
except frappe.DoesNotExistError:
return
next_weekly_trigger = weekly_job.get_next_execution()
next_monthly_trigger = monthly_job.get_next_execution()
if self.freq_changed_from_monthly_to_weekly():
if next_monthly_trigger < next_weekly_trigger:
self.show_freq_change_warning(next_monthly_trigger, next_weekly_trigger)
elif self.freq_changed_from_weekly_to_monthly():
if next_monthly_trigger > next_weekly_trigger:
self.show_freq_change_warning(next_weekly_trigger, next_monthly_trigger)
def freq_changed_from_weekly_to_monthly(self):
return self.has_value_changed("frequency") and self.frequency == "Monthly"
def freq_changed_from_monthly_to_weekly(self):
return self.has_value_changed("frequency") and self.frequency == "Weekly"
def show_freq_change_warning(self, from_date, to_date):
from_date = frappe.bold(format_date(from_date))
to_date = frappe.bold(format_date(to_date))
raise_exception = frappe.ValidationError
if (
frappe.flags.in_test
or frappe.flags.in_patch
or frappe.flags.in_install
or frappe.flags.in_migrate
):
raise_exception = False
frappe.msgprint(
msg=frappe._(
"Employees will miss holiday reminders from {} until {}. <br> Do you want to proceed with this change?"
).format(from_date, to_date),
title="Confirm change in Frequency",
primary_action={
"label": frappe._("Yes, Proceed"),
"client_action": "hrms.proceed_save_with_reminders_frequency_change",
},
raise_exception=raise_exception,
)
@frappe.whitelist()
def set_proceed_with_frequency_change():
"""Enables proceed with frequency change"""
global PROCEED_WITH_FREQUENCY_CHANGE
PROCEED_WITH_FREQUENCY_CHANGE = True
|
2302_79757062/hrms
|
hrms/hr/doctype/hr_settings/hr_settings.py
|
Python
|
agpl-3.0
| 2,866
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Identification Document Type", {
refresh: function (frm) {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/identification_document_type/identification_document_type.js
|
JavaScript
|
agpl-3.0
| 207
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class IdentificationDocumentType(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/identification_document_type/identification_document_type.py
|
Python
|
agpl-3.0
| 216
|
// Copyright (c) 2016, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Interest", {
refresh: function (frm) {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/interest/interest.js
|
JavaScript
|
agpl-3.0
| 187
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class Interest(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/interest/interest.py
|
Python
|
agpl-3.0
| 198
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Interview", {
refresh: function (frm) {
frm.set_query("job_applicant", function () {
let job_applicant_filters = {
status: ["!=", "Rejected"],
};
if (frm.doc.designation) {
job_applicant_filters.designation = frm.doc.designation;
}
return {
filters: job_applicant_filters,
};
});
frm.trigger("add_custom_buttons");
frappe.run_serially([
() => frm.trigger("load_skills_average_rating"),
() => frm.trigger("load_feedback"),
]);
},
add_custom_buttons: async function (frm) {
if (frm.doc.docstatus === 2 || frm.doc.__islocal) return;
if (frm.doc.status === "Pending") {
frm.add_custom_button(
__("Reschedule Interview"),
function () {
frm.events.show_reschedule_dialog(frm);
frm.refresh();
},
__("Actions"),
);
}
const has_submitted_feedback = await frappe.db.get_value(
"Interview Feedback",
{
interviewer: frappe.session.user,
interview: frm.doc.name,
docstatus: ("!=", 2),
},
"name",
)?.message?.name;
if (has_submitted_feedback) return;
const allow_feedback_submission = frm.doc.interview_details.some(
(interviewer) => interviewer.interviewer === frappe.session.user,
);
if (allow_feedback_submission) {
frm.page.set_primary_action(__("Submit Feedback"), () => {
frm.trigger("submit_feedback");
});
} else {
const button = frm.add_custom_button(__("Submit Feedback"), () => {
frm.trigger("submit_feedback");
});
button
.prop("disabled", true)
.attr("title", __("Only interviewers can submit feedback"))
.tooltip({ delay: { show: 600, hide: 100 }, trigger: "hover" });
}
},
submit_feedback: function (frm) {
frappe.call({
method: "hrms.hr.doctype.interview.interview.get_expected_skill_set",
args: {
interview_round: frm.doc.interview_round,
},
callback: function (r) {
frm.events.show_feedback_dialog(frm, r.message);
frm.refresh();
},
});
},
show_reschedule_dialog: function (frm) {
let d = new frappe.ui.Dialog({
title: "Reschedule Interview",
fields: [
{
label: "Schedule On",
fieldname: "scheduled_on",
fieldtype: "Date",
reqd: 1,
default: frm.doc.scheduled_on,
},
{
label: "From Time",
fieldname: "from_time",
fieldtype: "Time",
reqd: 1,
default: frm.doc.from_time,
},
{
label: "To Time",
fieldname: "to_time",
fieldtype: "Time",
reqd: 1,
default: frm.doc.to_time,
},
],
primary_action_label: "Reschedule",
primary_action(values) {
frm.call({
method: "reschedule_interview",
doc: frm.doc,
args: {
scheduled_on: values.scheduled_on,
from_time: values.from_time,
to_time: values.to_time,
},
}).then(() => {
frm.refresh();
d.hide();
});
},
});
d.show();
},
show_feedback_dialog: function (frm, data) {
let fields = frm.events.get_fields_for_feedback();
let d = new frappe.ui.Dialog({
title: __("Submit Feedback"),
fields: [
{
fieldname: "skill_set",
fieldtype: "Table",
label: __("Skill Assessment"),
cannot_add_rows: false,
in_editable_grid: true,
reqd: 1,
fields: fields,
data: data,
},
{
fieldname: "result",
fieldtype: "Select",
options: ["", "Cleared", "Rejected"],
label: __("Result"),
reqd: 1,
},
{
fieldname: "feedback",
fieldtype: "Small Text",
label: __("Feedback"),
},
],
size: "large",
minimizable: true,
static: true,
primary_action: function (values) {
frappe
.call({
method: "hrms.hr.doctype.interview.interview.create_interview_feedback",
args: {
data: values,
interview_name: frm.doc.name,
interviewer: frappe.session.user,
job_applicant: frm.doc.job_applicant,
},
})
.then(() => {
frm.refresh();
});
d.hide();
},
});
d.show();
d.get_close_btn().show();
},
get_fields_for_feedback: function () {
return [
{
fieldtype: "Link",
fieldname: "skill",
options: "Skill",
in_list_view: 1,
label: __("Skill"),
},
{
fieldtype: "Rating",
fieldname: "rating",
label: __("Rating"),
in_list_view: 1,
reqd: 1,
},
];
},
interview_round: function (frm) {
frm.set_value("job_applicant", "");
frm.trigger("set_applicable_interviewers");
},
job_applicant: function (frm) {
if (!frm.doc.interview_round) {
frm.set_value("job_applicant", "");
frappe.throw(__("Select Interview Round First"));
}
if (frm.doc.job_applicant && !frm.doc.designation) {
frm.add_fetch("job_applicant", "designation", "designation");
}
},
set_applicable_interviewers(frm) {
frappe.call({
method: "hrms.hr.doctype.interview.interview.get_interviewers",
args: {
interview_round: frm.doc.interview_round || "",
},
callback: function (r) {
r.message.forEach((interviewer) =>
frm.add_child("interview_details", interviewer),
);
refresh_field("interview_details");
},
});
},
load_skills_average_rating(frm) {
frappe
.call({
method: "hrms.hr.doctype.interview.interview.get_skill_wise_average_rating",
args: { interview: frm.doc.name },
})
.then((r) => {
frm.skills_average_rating = r.message;
});
},
load_feedback(frm) {
frappe
.call({
method: "hrms.hr.doctype.interview.interview.get_feedback",
args: { interview: frm.doc.name },
})
.then((r) => {
frm.feedback = r.message;
frm.events.calculate_reviews_per_rating(frm);
frm.events.render_feedback(frm);
});
},
render_feedback(frm) {
frappe.require("interview.bundle.js", () => {
const wrapper = $(frm.fields_dict.feedback_html.wrapper);
const feedback_html = frappe.render_template("interview_feedback", {
feedbacks: frm.feedback,
average_rating: flt(frm.doc.average_rating * 5, 2),
reviews_per_rating: frm.reviews_per_rating,
skills_average_rating: frm.skills_average_rating,
});
$(wrapper).empty();
$(feedback_html).appendTo(wrapper);
});
},
calculate_reviews_per_rating(frm) {
const reviews_per_rating = [0, 0, 0, 0, 0];
frm.feedback.forEach((x) => {
reviews_per_rating[Math.floor(x.total_score - 1)] += 1;
});
frm.reviews_per_rating = reviews_per_rating.map((x) =>
flt((x * 100) / frm.feedback.length, 1),
);
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview.js
|
JavaScript
|
agpl-3.0
| 6,549
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import datetime
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.query_builder.functions import Avg
from frappe.utils import cint, cstr, get_datetime, get_link_to_form, getdate, nowtime
class DuplicateInterviewRoundError(frappe.ValidationError):
pass
class Interview(Document):
def validate(self):
self.validate_duplicate_interview()
self.validate_designation()
def on_submit(self):
if self.status not in ["Cleared", "Rejected"]:
frappe.throw(
_("Only Interviews with Cleared or Rejected status can be submitted."),
title=_("Not Allowed"),
)
self.show_job_applicant_update_dialog()
def validate_duplicate_interview(self):
duplicate_interview = frappe.db.exists(
"Interview",
{"job_applicant": self.job_applicant, "interview_round": self.interview_round, "docstatus": 1},
)
if duplicate_interview:
frappe.throw(
_(
"Job Applicants are not allowed to appear twice for the same Interview round. Interview {0} already scheduled for Job Applicant {1}"
).format(
frappe.bold(get_link_to_form("Interview", duplicate_interview)),
frappe.bold(self.job_applicant),
)
)
def validate_designation(self):
applicant_designation = frappe.db.get_value("Job Applicant", self.job_applicant, "designation")
if self.designation:
if self.designation != applicant_designation:
frappe.throw(
_(
"Interview Round {0} is only for Designation {1}. Job Applicant has applied for the role {2}"
).format(self.interview_round, frappe.bold(self.designation), applicant_designation),
exc=DuplicateInterviewRoundError,
)
else:
self.designation = applicant_designation
def show_job_applicant_update_dialog(self):
job_applicant_status = self.get_job_applicant_status()
if not job_applicant_status:
return
job_application_name = frappe.db.get_value("Job Applicant", self.job_applicant, "applicant_name")
frappe.msgprint(
_("Do you want to update the Job Applicant {0} as {1} based on this interview result?").format(
frappe.bold(job_application_name), frappe.bold(job_applicant_status)
),
title=_("Update Job Applicant"),
primary_action={
"label": _("Mark as {0}").format(job_applicant_status),
"server_action": "hrms.hr.doctype.interview.interview.update_job_applicant_status",
"args": {"job_applicant": self.job_applicant, "status": job_applicant_status},
},
)
def get_job_applicant_status(self) -> str | None:
status_map = {"Cleared": "Accepted", "Rejected": "Rejected"}
return status_map.get(self.status, None)
@frappe.whitelist()
def reschedule_interview(self, scheduled_on, from_time, to_time):
if scheduled_on == self.scheduled_on and from_time == self.from_time and to_time == self.to_time:
frappe.msgprint(
_("No changes found in timings."), indicator="orange", title=_("Interview Not Rescheduled")
)
return
original_date = self.scheduled_on
original_from_time = self.from_time
original_to_time = self.to_time
self.db_set({"scheduled_on": scheduled_on, "from_time": from_time, "to_time": to_time})
self.notify_update()
recipients = get_recipients(self.name)
try:
frappe.sendmail(
recipients=recipients,
subject=_("Interview: {0} Rescheduled").format(self.name),
message=_("Your Interview session is rescheduled from {0} {1} - {2} to {3} {4} - {5}").format(
original_date,
original_from_time,
original_to_time,
self.scheduled_on,
self.from_time,
self.to_time,
),
reference_doctype=self.doctype,
reference_name=self.name,
)
except Exception:
frappe.msgprint(
_(
"Failed to send the Interview Reschedule notification. Please configure your email account."
)
)
frappe.msgprint(_("Interview Rescheduled successfully"), indicator="green")
@frappe.whitelist()
def get_interviewers(interview_round: str) -> list[str]:
return frappe.get_all("Interviewer", filters={"parent": interview_round}, fields=["user as interviewer"])
def get_recipients(name, for_feedback=0):
interview = frappe.get_doc("Interview", name)
interviewers = [d.interviewer for d in interview.interview_details]
if for_feedback:
feedback_given_interviewers = frappe.get_all(
"Interview Feedback", filters={"interview": name, "docstatus": 1}, pluck="interviewer"
)
recipients = [d for d in interviewers if d not in feedback_given_interviewers]
else:
recipients = interviewers
recipients.append(frappe.db.get_value("Job Applicant", interview.job_applicant, "email_id"))
return recipients
@frappe.whitelist()
def get_feedback(interview: str) -> list[dict]:
interview_feedback = frappe.qb.DocType("Interview Feedback")
employee = frappe.qb.DocType("Employee")
return (
frappe.qb.from_(interview_feedback)
.select(
interview_feedback.name,
interview_feedback.modified.as_("added_on"),
interview_feedback.interviewer.as_("user"),
interview_feedback.feedback,
(interview_feedback.average_rating * 5).as_("total_score"),
employee.employee_name.as_("reviewer_name"),
employee.designation.as_("reviewer_designation"),
)
.left_join(employee)
.on(interview_feedback.interviewer == employee.user_id)
.where((interview_feedback.interview == interview) & (interview_feedback.docstatus == 1))
.orderby(interview_feedback.creation)
).run(as_dict=True)
@frappe.whitelist()
def get_skill_wise_average_rating(interview: str) -> list[dict]:
skill_assessment = frappe.qb.DocType("Skill Assessment")
interview_feedback = frappe.qb.DocType("Interview Feedback")
return (
frappe.qb.select(
skill_assessment.skill,
Avg(skill_assessment.rating).as_("rating"),
)
.from_(skill_assessment)
.join(interview_feedback)
.on(skill_assessment.parent == interview_feedback.name)
.where((interview_feedback.interview == interview) & (interview_feedback.docstatus == 1))
.groupby(skill_assessment.skill)
.orderby(skill_assessment.idx)
).run(as_dict=True)
@frappe.whitelist()
def update_job_applicant_status(status: str, job_applicant: str):
try:
if not job_applicant:
frappe.throw(_("Please specify the job applicant to be updated."))
job_applicant = frappe.get_doc("Job Applicant", job_applicant)
job_applicant.status = status
job_applicant.save()
frappe.msgprint(
_("Updated the Job Applicant status to {0}").format(job_applicant.status),
alert=True,
indicator="green",
)
except Exception:
job_applicant.log_error("Failed to update Job Applicant status")
frappe.msgprint(
_("Failed to update the Job Applicant status"),
alert=True,
indicator="red",
)
def send_interview_reminder():
reminder_settings = frappe.db.get_value(
"HR Settings",
"HR Settings",
["send_interview_reminder", "interview_reminder_template", "hiring_sender_email"],
as_dict=True,
)
if not cint(reminder_settings.send_interview_reminder):
return
remind_before = cstr(frappe.db.get_single_value("HR Settings", "remind_before")) or "01:00:00"
remind_before = datetime.datetime.strptime(remind_before, "%H:%M:%S")
reminder_date_time = datetime.datetime.now() + datetime.timedelta(
hours=remind_before.hour, minutes=remind_before.minute, seconds=remind_before.second
)
interviews = frappe.get_all(
"Interview",
filters={
"scheduled_on": ["between", (datetime.datetime.now(), reminder_date_time)],
"status": "Pending",
"reminded": 0,
"docstatus": ["!=", 2],
},
)
interview_template = frappe.get_doc("Email Template", reminder_settings.interview_reminder_template)
for d in interviews:
doc = frappe.get_doc("Interview", d.name)
context = doc.as_dict()
message = frappe.render_template(interview_template.response, context)
recipients = get_recipients(doc.name)
frappe.sendmail(
sender=reminder_settings.hiring_sender_email,
recipients=recipients,
subject=interview_template.subject,
message=message,
reference_doctype=doc.doctype,
reference_name=doc.name,
)
doc.db_set("reminded", 1)
def send_daily_feedback_reminder():
reminder_settings = frappe.db.get_value(
"HR Settings",
"HR Settings",
[
"send_interview_feedback_reminder",
"feedback_reminder_notification_template",
"hiring_sender_email",
],
as_dict=True,
)
if not cint(reminder_settings.send_interview_feedback_reminder):
return
interview_feedback_template = frappe.get_doc(
"Email Template", reminder_settings.feedback_reminder_notification_template
)
interviews = frappe.get_all(
"Interview",
filters={
"status": "Under Review",
"docstatus": ["!=", 2],
"scheduled_on": ["<=", getdate()],
"to_time": ["<=", nowtime()],
},
pluck="name",
)
for interview in interviews:
recipients = get_recipients(interview, for_feedback=1)
doc = frappe.get_doc("Interview", interview)
context = doc.as_dict()
message = frappe.render_template(interview_feedback_template.response, context)
if len(recipients):
frappe.sendmail(
sender=reminder_settings.hiring_sender_email,
recipients=recipients,
subject=interview_feedback_template.subject,
message=message,
reference_doctype="Interview",
reference_name=interview,
)
@frappe.whitelist()
def get_expected_skill_set(interview_round):
return frappe.get_all(
"Expected Skill Set", filters={"parent": interview_round}, fields=["skill"], order_by="idx"
)
@frappe.whitelist()
def create_interview_feedback(data, interview_name, interviewer, job_applicant):
import json
if isinstance(data, str):
data = frappe._dict(json.loads(data))
if frappe.session.user != interviewer:
frappe.throw(_("Only Interviewer Are allowed to submit Interview Feedback"))
interview_feedback = frappe.new_doc("Interview Feedback")
interview_feedback.interview = interview_name
interview_feedback.interviewer = interviewer
interview_feedback.job_applicant = job_applicant
for d in data.skill_set:
d = frappe._dict(d)
interview_feedback.append("skill_assessment", {"skill": d.skill, "rating": d.rating})
interview_feedback.feedback = data.feedback
interview_feedback.result = data.result
interview_feedback.save()
interview_feedback.submit()
frappe.msgprint(
_("Interview Feedback {0} submitted successfully").format(
get_link_to_form("Interview Feedback", interview_feedback.name)
)
)
@frappe.whitelist()
@frappe.validate_and_sanitize_search_inputs
def get_interviewer_list(doctype, txt, searchfield, start, page_len, filters):
filters = [
["Has Role", "parent", "like", f"%{txt}%"],
["Has Role", "role", "=", "interviewer"],
["Has Role", "parenttype", "=", "User"],
]
if filters and isinstance(filters, list):
filters.extend(filters)
return frappe.get_all(
"Has Role",
limit_start=start,
limit_page_length=page_len,
filters=filters,
fields=["parent"],
as_list=1,
)
@frappe.whitelist()
def get_events(start, end, filters=None):
"""Returns events for Gantt / Calendar view rendering.
:param start: Start date-time.
:param end: End date-time.
:param filters: Filters (JSON).
"""
from frappe.desk.calendar import get_event_conditions
events = []
event_color = {
"Pending": "#fff4f0",
"Under Review": "#d3e8fc",
"Cleared": "#eaf5ed",
"Rejected": "#fce7e7",
}
conditions = get_event_conditions("Interview", filters)
# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
interviews = frappe.db.sql(
f"""
SELECT DISTINCT
`tabInterview`.name, `tabInterview`.job_applicant, `tabInterview`.interview_round,
`tabInterview`.scheduled_on, `tabInterview`.status, `tabInterview`.from_time as from_time,
`tabInterview`.to_time as to_time
from
`tabInterview`
where
(`tabInterview`.scheduled_on between %(start)s and %(end)s)
and docstatus != 2
{conditions}
""",
{"start": start, "end": end},
as_dict=True,
update={"allDay": 0},
)
for d in interviews:
subject_data = []
for field in ["name", "job_applicant", "interview_round"]:
if not d.get(field):
continue
subject_data.append(d.get(field))
color = event_color.get(d.status)
interview_data = {
"from": get_datetime(
"{scheduled_on} {from_time}".format(
scheduled_on=d.scheduled_on, from_time=d.from_time or "00:00:00"
)
),
"to": get_datetime(
"{scheduled_on} {to_time}".format(
scheduled_on=d.scheduled_on, to_time=d.to_time or "00:00:00"
)
),
"name": d.name,
"subject": "\n".join(subject_data),
"color": color if color else "#89bcde",
}
events.append(interview_data)
return events
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview.py
|
Python
|
agpl-3.0
| 12,641
|
frappe.views.calendar["Interview"] = {
field_map: {
start: "from",
end: "to",
id: "name",
title: "subject",
allDay: "allDay",
color: "color",
},
order_by: "scheduled_on",
gantt: true,
get_events_method: "hrms.hr.doctype.interview.interview.get_events",
};
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview_calendar.js
|
JavaScript
|
agpl-3.0
| 273
|
<h1>Interview Feedback Reminder</h1>
<p>
Interview Feedback for Interview {{ name }} is not submitted yet. Please submit your feedback. Thank you, good day!
</p>
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview_feedback_reminder_template.html
|
HTML
|
agpl-3.0
| 164
|
frappe.listview_settings["Interview"] = {
has_indicator_for_draft: 1,
get_indicator: function (doc) {
let status_color = {
Pending: "orange",
"Under Review": "blue",
Cleared: "green",
Rejected: "red",
};
return [__(doc.status), status_color[doc.status], "status,=," + doc.status];
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview_list.js
|
JavaScript
|
agpl-3.0
| 308
|
<h1>Interview Reminder</h1>
<p>
Interview: {{name}} is scheduled on {{scheduled_on}} from {{from_time}} to {{to_time}}
</p>
|
2302_79757062/hrms
|
hrms/hr/doctype/interview/interview_reminder_notification_template.html
|
HTML
|
agpl-3.0
| 126
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class InterviewDetail(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_detail/interview_detail.py
|
Python
|
agpl-3.0
| 220
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Interview Feedback", {
onload: function (frm) {
frm.ignore_doctypes_on_cancel_all = ["Interview"];
frm.set_query("interview", function () {
return {
filters: {
docstatus: ["!=", 2],
},
};
});
},
interview_round: function (frm) {
frappe.call({
method: "hrms.hr.doctype.interview.interview.get_expected_skill_set",
args: {
interview_round: frm.doc.interview_round,
},
callback: function (r) {
frm.set_value("skill_assessment", r.message);
},
});
},
interview: function (frm) {
frappe.call({
method: "hrms.hr.doctype.interview_feedback.interview_feedback.get_applicable_interviewers",
args: {
interview: frm.doc.interview || "",
},
callback: function (r) {
frm.set_query("interviewer", function () {
return {
filters: {
name: ["in", r.message],
},
};
});
},
});
},
interviewer: function (frm) {
if (!frm.doc.interview) {
frappe.throw(__("Select Interview first"));
frm.set_value("interviewer", "");
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_feedback/interview_feedback.js
|
JavaScript
|
agpl-3.0
| 1,180
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.query_builder.functions import Avg
from frappe.utils import flt, get_link_to_form, getdate
class InterviewFeedback(Document):
def validate(self):
self.validate_interviewer()
self.validate_interview_date()
self.validate_duplicate()
self.calculate_average_rating()
def on_submit(self):
self.update_interview_average_rating()
def on_cancel(self):
self.update_interview_average_rating()
def validate_interviewer(self):
applicable_interviewers = get_applicable_interviewers(self.interview)
if self.interviewer not in applicable_interviewers:
frappe.throw(
_("{0} is not allowed to submit Interview Feedback for the Interview: {1}").format(
frappe.bold(self.interviewer), frappe.bold(self.interview)
)
)
def validate_interview_date(self):
scheduled_date = frappe.db.get_value("Interview", self.interview, "scheduled_on")
if getdate() < getdate(scheduled_date) and self.docstatus == 1:
frappe.throw(
_("Submission of {0} before {1} is not allowed").format(
frappe.bold(_("Interview Feedback")), frappe.bold(_("Interview Scheduled Date"))
)
)
def validate_duplicate(self):
duplicate_feedback = frappe.db.exists(
"Interview Feedback",
{"interviewer": self.interviewer, "interview": self.interview, "docstatus": 1},
)
if duplicate_feedback:
frappe.throw(
_(
"Feedback already submitted for the Interview {0}. Please cancel the previous Interview Feedback {1} to continue."
).format(self.interview, get_link_to_form("Interview Feedback", duplicate_feedback))
)
def calculate_average_rating(self):
total_rating = 0
for d in self.skill_assessment:
if d.rating:
total_rating += flt(d.rating)
self.average_rating = flt(
total_rating / len(self.skill_assessment) if len(self.skill_assessment) else 0
)
def update_interview_average_rating(self):
interview_feedback = frappe.qb.DocType("Interview Feedback")
query = (
frappe.qb.from_(interview_feedback)
.where((interview_feedback.interview == self.interview) & (interview_feedback.docstatus == 1))
.select(Avg(interview_feedback.average_rating).as_("average"))
)
data = query.run(as_dict=True)
average_rating = data[0].average
interview = frappe.get_doc("Interview", self.interview)
interview.db_set("average_rating", average_rating)
interview.notify_update()
@frappe.whitelist()
def get_applicable_interviewers(interview: str) -> list[str]:
return frappe.get_all("Interview Detail", filters={"parent": interview}, pluck="interviewer")
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_feedback/interview_feedback.py
|
Python
|
agpl-3.0
| 2,736
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Interview Round", {
refresh: function (frm) {
if (!frm.doc.__islocal) {
frm.add_custom_button(__("Create Interview"), function () {
frm.events.create_interview(frm);
});
}
},
designation: function (frm) {
if (frm.doc.designation) {
frappe.db.get_doc("Designation", frm.doc.designation).then((designation) => {
frappe.model.clear_table(frm.doc, "expected_skill_set");
designation.skills.forEach((designation_skill) => {
const row = frm.add_child("expected_skill_set");
row.skill = designation_skill.skill;
});
refresh_field("expected_skill_set");
});
}
},
create_interview: function (frm) {
frappe.call({
method: "hrms.hr.doctype.interview_round.interview_round.create_interview",
args: {
doc: frm.doc,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_round/interview_round.js
|
JavaScript
|
agpl-3.0
| 1,081
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import json
import frappe
from frappe.model.document import Document
class InterviewRound(Document):
pass
@frappe.whitelist()
def create_interview(doc):
if isinstance(doc, str):
doc = json.loads(doc)
doc = frappe.get_doc(doc)
interview = frappe.new_doc("Interview")
interview.interview_round = doc.name
interview.designation = doc.designation
if doc.interviewers:
interview.interview_details = []
for d in doc.interviewers:
interview.append("interview_details", {"interviewer": d.user})
return interview
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_round/interview_round.py
|
Python
|
agpl-3.0
| 651
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Interview Type", {
// refresh: function(frm) {
// }
});
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_type/interview_type.js
|
JavaScript
|
agpl-3.0
| 199
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class InterviewType(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/interview_type/interview_type.py
|
Python
|
agpl-3.0
| 219
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class Interviewer(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/interviewer/interviewer.py
|
Python
|
agpl-3.0
| 217
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
// For license information, please see license.txt
// for communication
cur_frm.email_field = "email_id";
frappe.ui.form.on("Job Applicant", {
refresh: function (frm) {
frm.set_query("job_title", function () {
return {
filters: {
status: "Open",
},
};
});
frm.events.create_custom_buttons(frm);
frm.events.make_dashboard(frm);
},
create_custom_buttons: function (frm) {
if (!frm.doc.__islocal && frm.doc.status !== "Rejected" && frm.doc.status !== "Accepted") {
frm.add_custom_button(
__("Interview"),
function () {
frm.events.create_dialog(frm);
},
__("Create"),
);
}
if (!frm.doc.__islocal && frm.doc.status == "Accepted") {
if (frm.doc.__onload && frm.doc.__onload.job_offer) {
$('[data-doctype="Employee Onboarding"]').find("button").show();
$('[data-doctype="Job Offer"]').find("button").hide();
frm.add_custom_button(
__("Job Offer"),
function () {
frappe.set_route("Form", "Job Offer", frm.doc.__onload.job_offer);
},
__("View"),
);
} else {
$('[data-doctype="Employee Onboarding"]').find("button").hide();
$('[data-doctype="Job Offer"]').find("button").show();
frm.add_custom_button(
__("Job Offer"),
function () {
frappe.route_options = {
job_applicant: frm.doc.name,
applicant_name: frm.doc.applicant_name,
designation: frm.doc.job_opening || frm.doc.designation,
};
frappe.new_doc("Job Offer");
},
__("Create"),
);
}
}
},
make_dashboard: function (frm) {
frappe.call({
method: "hrms.hr.doctype.job_applicant.job_applicant.get_interview_details",
args: {
job_applicant: frm.doc.name,
},
callback: function (r) {
if (r.message) {
$("div").remove(".form-dashboard-section.custom");
frm.dashboard.add_section(
frappe.render_template("job_applicant_dashboard", {
data: r.message.interviews,
number_of_stars: r.message.stars,
}),
__("Interview Summary"),
);
}
},
});
},
create_dialog: function (frm) {
let d = new frappe.ui.Dialog({
title: "Enter Interview Round",
fields: [
{
label: "Interview Round",
fieldname: "interview_round",
fieldtype: "Link",
options: "Interview Round",
},
],
primary_action_label: __("Create Interview"),
primary_action(values) {
frm.events.create_interview(frm, values);
d.hide();
},
});
d.show();
},
create_interview: function (frm, values) {
frappe.call({
method: "hrms.hr.doctype.job_applicant.job_applicant.create_interview",
args: {
doc: frm.doc,
interview_round: values.interview_round,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant/job_applicant.js
|
JavaScript
|
agpl-3.0
| 2,983
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.model.naming import append_number_if_name_exists
from frappe.utils import flt, validate_email_address
from hrms.hr.doctype.interview.interview import get_interviewers
class DuplicationError(frappe.ValidationError):
pass
class JobApplicant(Document):
def onload(self):
job_offer = frappe.get_all("Job Offer", filters={"job_applicant": self.name})
if job_offer:
self.get("__onload").job_offer = job_offer[0].name
def autoname(self):
self.name = self.email_id
# applicant can apply more than once for a different job title or reapply
if frappe.db.exists("Job Applicant", self.name):
self.name = append_number_if_name_exists("Job Applicant", self.name)
def validate(self):
if self.email_id:
validate_email_address(self.email_id, True)
if self.employee_referral:
self.set_status_for_employee_referral()
if not self.applicant_name and self.email_id:
guess = self.email_id.split("@")[0]
self.applicant_name = " ".join([p.capitalize() for p in guess.split(".")])
def before_insert(self):
if self.job_title:
job_opening_status = frappe.db.get_value("Job Opening", self.job_title, "status")
if job_opening_status == "Closed":
frappe.throw(
_("Cannot create a Job Applicant against a closed Job Opening"), title=_("Not Allowed")
)
def set_status_for_employee_referral(self):
emp_ref = frappe.get_doc("Employee Referral", self.employee_referral)
if self.status in ["Open", "Replied", "Hold"]:
emp_ref.db_set("status", "In Process")
elif self.status in ["Accepted", "Rejected"]:
emp_ref.db_set("status", self.status)
@frappe.whitelist()
def create_interview(doc, interview_round):
import json
if isinstance(doc, str):
doc = json.loads(doc)
doc = frappe.get_doc(doc)
round_designation = frappe.db.get_value("Interview Round", interview_round, "designation")
if round_designation and doc.designation and round_designation != doc.designation:
frappe.throw(
_("Interview Round {0} is only applicable for the Designation {1}").format(
interview_round, round_designation
)
)
interview = frappe.new_doc("Interview")
interview.interview_round = interview_round
interview.job_applicant = doc.name
interview.designation = doc.designation
interview.resume_link = doc.resume_link
interview.job_opening = doc.job_title
interviewers = get_interviewers(interview_round)
for d in interviewers:
interview.append("interview_details", {"interviewer": d.interviewer})
return interview
@frappe.whitelist()
def get_interview_details(job_applicant):
interview_details = frappe.db.get_all(
"Interview",
filters={"job_applicant": job_applicant, "docstatus": ["!=", 2]},
fields=["name", "interview_round", "scheduled_on", "average_rating", "status"],
)
interview_detail_map = {}
meta = frappe.get_meta("Interview")
number_of_stars = meta.get_options("average_rating") or 5
for detail in interview_details:
detail.average_rating = detail.average_rating * number_of_stars if detail.average_rating else 0
interview_detail_map[detail.name] = detail
return {"interviews": interview_detail_map, "stars": number_of_stars}
@frappe.whitelist()
def get_applicant_to_hire_percentage():
total_applicants = frappe.db.count("Job Applicant")
total_hired = frappe.db.count("Job Applicant", filters={"status": "Accepted"})
return {
"value": flt(total_hired) / flt(total_applicants) * 100 if total_applicants else 0,
"fieldtype": "Percent",
}
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant/job_applicant.py
|
Python
|
agpl-3.0
| 3,715
|
{% if not jQuery.isEmptyObject(data) %}
<table class="table table-bordered small">
<thead>
<tr>
<th style="width: 14%" class="text-left">{{ __("Interview") }}</th>
<th style="width: 16%" class="text-left">{{ __("Interview Round") }}</th>
<th style="width: 12%" class="text-left">{{ __("Date") }}</th>
<th style="width: 12%" class="text-left">{{ __("Status") }}</th>
<th style="width: 14%" class="text-left">{{ __("Rating") }}</th>
</tr>
</thead>
<tbody>
{% for(const [key, value] of Object.entries(data)) { %}
<tr>
<td class="text-left">
<a href="/app/interview/{%= key %}" target="_blank">{%= key %}</a>
</td>
<td class="text-left"> {%= value["interview_round"] %} </td>
<td class="text-left"> {%= frappe.datetime.str_to_user(value["scheduled_on"]) %} </td>
<td class="text-left"> {%= value["status"] %} </td>
{% let right_class = ''; %}
{% let left_class = ''; %}
<td class="text-left">
<div class="rating">
{% for (let i = 1; i <= number_of_stars; i++) { %}
{% if (i <= value["average_rating"]) { %}
{% right_class = 'star-click'; %}
{% } else { %}
{% right_class = ''; %}
{% } %}
{% if ((i <= value["average_rating"]) || ((i - 0.5) == value["average_rating"])) { %}
{% left_class = 'star-click'; %}
{% } else { %}
{% left_class = ''; %}
{% } %}
<svg class="icon icon-md" data-rating={{i}} viewBox="0 0 24 24" fill="none">
<path class="right-half {{ right_class }}" d="M11.9987 3.00011C12.177 3.00011 12.3554 3.09303 12.4471 3.27888L14.8213 8.09112C14.8941 8.23872 15.0349 8.34102 15.1978 8.3647L20.5069 9.13641C20.917 9.19602 21.0807 9.69992 20.7841 9.9892L16.9421 13.7354C16.8243 13.8503 16.7706 14.0157 16.7984 14.1779L17.7053 19.4674C17.7753 19.8759 17.3466 20.1874 16.9798 19.9945L12.2314 17.4973C12.1586 17.459 12.0786 17.4398 11.9987 17.4398V3.00011Z" fill="var(--star-fill)" stroke="var(--star-fill)"/>
<path class="left-half {{ left_class }}" d="M11.9987 3.00011C11.8207 3.00011 11.6428 3.09261 11.5509 3.27762L9.15562 8.09836C9.08253 8.24546 8.94185 8.34728 8.77927 8.37075L3.42887 9.14298C3.01771 9.20233 2.85405 9.70811 3.1525 9.99707L7.01978 13.7414C7.13858 13.8564 7.19283 14.0228 7.16469 14.1857L6.25116 19.4762C6.18071 19.8842 6.6083 20.1961 6.97531 20.0045L11.7672 17.5022C11.8397 17.4643 11.9192 17.4454 11.9987 17.4454V3.00011Z" fill="var(--star-fill)" stroke="var(--star-fill)"/>
</svg>
{% } %}
</div>
</td>
</tr>
{% } %}
</tbody>
</table>
{% else %}
<p style="margin-top: 30px;"> {{ __("No Interview has been scheduled.") }}</p>
{% endif %}
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant/job_applicant_dashboard.html
|
HTML
|
agpl-3.0
| 2,698
|
def get_data():
return {
"fieldname": "job_applicant",
"transactions": [
{"items": ["Employee", "Employee Onboarding"]},
{"items": ["Job Offer", "Appointment Letter"]},
{"items": ["Interview"]},
],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant/job_applicant_dashboard.py
|
Python
|
agpl-3.0
| 217
|
// Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
// MIT License. See license.txt
frappe.listview_settings["Job Applicant"] = {
add_fields: ["status"],
get_indicator: function (doc) {
if (doc.status == "Accepted") {
return [__(doc.status), "green", "status,=," + doc.status];
} else if (["Open", "Replied"].includes(doc.status)) {
return [__(doc.status), "orange", "status,=," + doc.status];
} else if (["Hold", "Rejected"].includes(doc.status)) {
return [__(doc.status), "red", "status,=," + doc.status];
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant/job_applicant_list.js
|
JavaScript
|
agpl-3.0
| 555
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Job Applicant Source", {
refresh: function () {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant_source/job_applicant_source.js
|
JavaScript
|
agpl-3.0
| 196
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class JobApplicantSource(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/job_applicant_source/job_applicant_source.py
|
Python
|
agpl-3.0
| 208
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.provide("erpnext.job_offer");
frappe.ui.form.on("Job Offer", {
onload: function (frm) {
frm.set_query("select_terms", function () {
return { filters: { hr: 1 } };
});
},
setup: function (frm) {
frm.email_field = "applicant_email";
},
select_terms: function (frm) {
erpnext.utils.get_terms(frm.doc.select_terms, frm.doc, function (r) {
if (!r.exc) {
frm.set_value("terms", r.message);
}
});
},
job_offer_term_template: function (frm) {
if (!frm.doc.job_offer_term_template) return;
frappe.db
.get_doc("Job Offer Term Template", frm.doc.job_offer_term_template)
.then((doc) => {
frm.clear_table("offer_terms");
doc.offer_terms.forEach((term) => {
frm.add_child("offer_terms", term);
});
refresh_field("offer_terms");
});
},
refresh: function (frm) {
if (
!frm.doc.__islocal &&
frm.doc.status == "Accepted" &&
frm.doc.docstatus === 1 &&
(!frm.doc.__onload || !frm.doc.__onload.employee)
) {
frm.add_custom_button(__("Create Employee"), function () {
erpnext.job_offer.make_employee(frm);
});
}
if (frm.doc.__onload && frm.doc.__onload.employee) {
frm.add_custom_button(__("Show Employee"), function () {
frappe.set_route("Form", "Employee", frm.doc.__onload.employee);
});
}
},
});
erpnext.job_offer.make_employee = function (frm) {
frappe.model.open_mapped_doc({
method: "hrms.hr.doctype.job_offer.job_offer.make_employee",
frm: frm,
});
};
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer/job_offer.js
|
JavaScript
|
agpl-3.0
| 1,598
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.model.mapper import get_mapped_doc
from frappe.utils import cint, flt, get_link_to_form
class JobOffer(Document):
def onload(self):
employee = frappe.db.get_value("Employee", {"job_applicant": self.job_applicant}, "name") or ""
self.set_onload("employee", employee)
def validate(self):
self.validate_vacancies()
job_offer = frappe.db.exists(
"Job Offer", {"job_applicant": self.job_applicant, "docstatus": ["!=", 2]}
)
if job_offer and job_offer != self.name:
frappe.throw(
_("Job Offer: {0} is already for Job Applicant: {1}").format(
frappe.bold(job_offer), frappe.bold(self.job_applicant)
)
)
def validate_vacancies(self):
staffing_plan = get_staffing_plan_detail(self.designation, self.company, self.offer_date)
check_vacancies = frappe.get_single("HR Settings").check_vacancies
if staffing_plan and check_vacancies:
job_offers = self.get_job_offer(staffing_plan.from_date, staffing_plan.to_date)
if not staffing_plan.get("vacancies") or cint(staffing_plan.vacancies) - len(job_offers) <= 0:
error_variable = "for " + frappe.bold(self.designation)
if staffing_plan.get("parent"):
error_variable = frappe.bold(get_link_to_form("Staffing Plan", staffing_plan.parent))
frappe.throw(_("There are no vacancies under staffing plan {0}").format(error_variable))
def on_change(self):
update_job_applicant(self.status, self.job_applicant)
def get_job_offer(self, from_date, to_date):
"""Returns job offer created during a time period"""
return frappe.get_all(
"Job Offer",
filters={
"offer_date": ["between", (from_date, to_date)],
"designation": self.designation,
"company": self.company,
"docstatus": 1,
},
fields=["name"],
)
def update_job_applicant(status, job_applicant):
if status in ("Accepted", "Rejected"):
frappe.set_value("Job Applicant", job_applicant, "status", status)
def get_staffing_plan_detail(designation, company, offer_date):
detail = frappe.db.sql(
"""
SELECT DISTINCT spd.parent,
sp.from_date as from_date,
sp.to_date as to_date,
sp.name,
sum(spd.vacancies) as vacancies,
spd.designation
FROM `tabStaffing Plan Detail` spd, `tabStaffing Plan` sp
WHERE
sp.docstatus=1
AND spd.designation=%s
AND sp.company=%s
AND spd.parent = sp.name
AND %s between sp.from_date and sp.to_date
""",
(designation, company, offer_date),
as_dict=1,
)
return frappe._dict(detail[0]) if (detail and detail[0].parent) else None
@frappe.whitelist()
def make_employee(source_name, target_doc=None):
def set_missing_values(source, target):
target.personal_email, target.first_name = frappe.db.get_value(
"Job Applicant", source.job_applicant, ["email_id", "applicant_name"]
)
doc = get_mapped_doc(
"Job Offer",
source_name,
{
"Job Offer": {
"doctype": "Employee",
"field_map": {"applicant_name": "employee_name", "offer_date": "scheduled_confirmation_date"},
}
},
target_doc,
set_missing_values,
)
return doc
@frappe.whitelist()
def get_offer_acceptance_rate(company=None, department=None):
filters = {"docstatus": 1}
if company:
filters["company"] = company
if department:
filters["department"] = department
total_offers = frappe.db.count("Job Offer", filters=filters)
filters["status"] = "Accepted"
total_accepted = frappe.db.count("Job Offer", filters=filters)
return {
"value": flt(total_accepted) / flt(total_offers) * 100 if total_offers else 0,
"fieldtype": "Percent",
}
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer/job_offer.py
|
Python
|
agpl-3.0
| 3,723
|
// Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
// MIT License. See license.txt
frappe.listview_settings["Job Offer"] = {
add_fields: ["company", "designation", "job_applicant", "status"],
get_indicator: function (doc) {
if (doc.status == "Accepted") {
return [__(doc.status), "green", "status,=," + doc.status];
} else if (doc.status == "Awaiting Response") {
return [__(doc.status), "orange", "status,=," + doc.status];
} else if (doc.status == "Rejected") {
return [__(doc.status), "red", "status,=," + doc.status];
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer/job_offer_list.js
|
JavaScript
|
agpl-3.0
| 570
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class JobOfferTerm(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer_term/job_offer_term.py
|
Python
|
agpl-3.0
| 219
|
// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
// frappe.ui.form.on("Job Offer Term Template", {
// refresh(frm) {
// },
// });
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer_term_template/job_offer_term_template.js
|
JavaScript
|
agpl-3.0
| 206
|
# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class JobOfferTermTemplate(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/job_offer_term_template/job_offer_term_template.py
|
Python
|
agpl-3.0
| 225
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Job Opening", {
onload: function (frm) {
frm.set_query("department", function () {
return {
filters: {
company: frm.doc.company,
},
};
});
},
designation: function (frm) {
if (frm.doc.designation && frm.doc.company) {
frappe.call({
method: "hrms.hr.doctype.staffing_plan.staffing_plan.get_active_staffing_plan_details",
args: {
company: frm.doc.company,
designation: frm.doc.designation,
date: frappe.datetime.now_date(), // ToDo - Date in Job Opening?
},
callback: function (data) {
if (data.message) {
frm.set_value("staffing_plan", data.message[0].name);
frm.set_value("planned_vacancies", data.message[0].vacancies);
} else {
frm.set_value("staffing_plan", "");
frm.set_value("planned_vacancies", 0);
frappe.show_alert({
indicator: "orange",
message: __("No Staffing Plans found for this Designation"),
});
}
},
});
} else {
frm.set_value("staffing_plan", "");
frm.set_value("planned_vacancies", 0);
}
},
company: function (frm) {
frm.set_value("designation", "");
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/job_opening/job_opening.js
|
JavaScript
|
agpl-3.0
| 1,266
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.naming import set_name_from_naming_options
from frappe.utils import get_link_to_form, getdate, pretty_date
from frappe.website.website_generator import WebsiteGenerator
from hrms.hr.doctype.staffing_plan.staffing_plan import (
get_active_staffing_plan_details,
get_designation_counts,
)
class JobOpening(WebsiteGenerator):
website = frappe._dict(
template="templates/generators/job_opening.html",
condition_field="publish",
page_title_field="job_title",
)
def autoname(self):
self.name = set_name_from_naming_options(frappe.get_meta(self.doctype).autoname, self)
def validate(self):
if not self.route:
self.route = f"jobs/{frappe.scrub(self.company)}/{frappe.scrub(self.job_title).replace('_', '-')}"
self.update_closing_date()
self.validate_dates()
self.validate_current_vacancies()
def on_update(self):
self.update_job_requisition_status()
def update_closing_date(self):
old_doc = self.get_doc_before_save()
if not old_doc:
return
if old_doc.status == "Open" and self.status == "Closed":
self.closes_on = None
if not self.closed_on:
self.closed_on = getdate()
elif old_doc.status == "Closed" and self.status == "Open":
self.closed_on = None
def validate_dates(self):
if self.status == "Open":
self.validate_from_to_dates("posted_on", "closes_on")
if self.status == "Closed":
self.validate_from_to_dates("posted_on", "closed_on")
def validate_current_vacancies(self):
if not self.staffing_plan:
staffing_plan = get_active_staffing_plan_details(self.company, self.designation)
if staffing_plan:
self.staffing_plan = staffing_plan[0].name
self.planned_vacancies = staffing_plan[0].vacancies
elif not self.planned_vacancies:
self.planned_vacancies = frappe.db.get_value(
"Staffing Plan Detail",
{"parent": self.staffing_plan, "designation": self.designation},
"vacancies",
)
if self.staffing_plan and self.planned_vacancies:
designation_counts = get_designation_counts(self.designation, self.company, self.name)
current_count = designation_counts["employee_count"] + designation_counts["job_openings"]
number_of_positions = frappe.db.get_value(
"Staffing Plan Detail",
{"parent": self.staffing_plan, "designation": self.designation},
"number_of_positions",
)
if number_of_positions <= current_count:
frappe.throw(
_(
"Job Openings for the designation {0} are already open or the hiring is complete as per the Staffing Plan {1}"
).format(
frappe.bold(self.designation), get_link_to_form("Staffing Plan", self.staffing_plan)
),
title=_("Vacancies fulfilled"),
)
def update_job_requisition_status(self):
if self.status == "Closed" and self.job_requisition:
job_requisition = frappe.get_doc("Job Requisition", self.job_requisition)
job_requisition.status = "Filled"
job_requisition.completed_on = getdate()
job_requisition.flags.ignore_permissions = True
job_requisition.flags.ignore_mandatory = True
job_requisition.save()
def get_context(self, context):
context.no_of_applications = frappe.db.count("Job Applicant", {"job_title": self.name})
context.parents = [{"route": "jobs", "title": _("All Jobs")}]
context.posted_on = pretty_date(self.posted_on)
def close_expired_job_openings():
today = getdate()
Opening = frappe.qb.DocType("Job Opening")
openings = (
frappe.qb.from_(Opening)
.select(Opening.name)
.where((Opening.status == "Open") & (Opening.closes_on.isnotnull()) & (Opening.closes_on < today))
).run(pluck=True)
for d in openings:
doc = frappe.get_doc("Job Opening", d)
doc.status = "Closed"
doc.flags.ignore_permissions = True
doc.flags.ignore_mandatory = True
doc.save()
|
2302_79757062/hrms
|
hrms/hr/doctype/job_opening/job_opening.py
|
Python
|
agpl-3.0
| 3,953
|
def get_data():
return {
"fieldname": "job_title",
"transactions": [{"items": ["Job Applicant"]}],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/job_opening/job_opening_dashboard.py
|
Python
|
agpl-3.0
| 107
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Job Requisition", {
refresh: function (frm) {
if (!frm.doc.__islocal && !["Filled", "On Hold", "Cancelled"].includes(frm.doc.status)) {
frappe.db
.get_list("Employee Referral", {
filters: { for_designation: frm.doc.designation, status: "Pending" },
})
.then((data) => {
if (data && data.length) {
const link =
data.length > 1
? `<a id="referral_links" style="text-decoration: underline;">${__(
"Employee Referrals",
)}</a>`
: `<a id="referral_links" style="text-decoration: underline;">${__(
"Employee Referral",
)}</a>`;
const headline = __("{} {} open for this position.", [data.length, link]);
frm.dashboard.clear_headline();
frm.dashboard.set_headline(headline, "yellow");
$("#referral_links").on("click", (e) => {
e.preventDefault();
frappe.set_route("List", "Employee Referral", {
for_designation: frm.doc.designation,
status: "Pending",
});
});
}
});
}
if (frm.doc.status === "Open & Approved") {
frm.add_custom_button(
__("Create Job Opening"),
() => {
frappe.model.open_mapped_doc({
method: "hrms.hr.doctype.job_requisition.job_requisition.make_job_opening",
frm: frm,
});
},
__("Actions"),
);
frm.add_custom_button(
__("Associate Job Opening"),
() => {
frappe.prompt(
{
label: __("Job Opening"),
fieldname: "job_opening",
fieldtype: "Link",
options: "Job Opening",
reqd: 1,
get_query: () => {
const filters = {
company: frm.doc.company,
status: "Open",
designation: frm.doc.designation,
};
if (frm.doc.department) filters.department = frm.doc.department;
return { filters: filters };
},
},
(values) => {
frm.call("associate_job_opening", { job_opening: values.job_opening });
},
__("Associate Job Opening"),
__("Submit"),
);
},
__("Actions"),
);
frm.page.set_inner_btn_group_as_primary(__("Actions"));
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/job_requisition/job_requisition.js
|
JavaScript
|
agpl-3.0
| 2,279
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.model.mapper import get_mapped_doc
from frappe.utils import format_duration, get_link_to_form, time_diff_in_seconds
class JobRequisition(Document):
def validate(self):
self.validate_duplicates()
self.set_time_to_fill()
def validate_duplicates(self):
duplicate = frappe.db.exists(
"Job Requisition",
{
"designation": self.designation,
"department": self.department,
"requested_by": self.requested_by,
"status": ("not in", ["Cancelled", "Filled"]),
"name": ("!=", self.name),
},
)
if duplicate:
frappe.throw(
_("A Job Requisition for {0} requested by {1} already exists: {2}").format(
frappe.bold(self.designation),
frappe.bold(self.requested_by),
get_link_to_form("Job Requisition", duplicate),
),
title=_("Duplicate Job Requisition"),
)
def set_time_to_fill(self):
if self.status == "Filled" and self.completed_on:
self.time_to_fill = time_diff_in_seconds(self.completed_on, self.posting_date)
@frappe.whitelist()
def associate_job_opening(self, job_opening):
frappe.db.set_value(
"Job Opening", job_opening, {"job_requisition": self.name, "vacancies": self.no_of_positions}
)
frappe.msgprint(
_("Job Requisition {0} has been associated with Job Opening {1}").format(
frappe.bold(self.name), get_link_to_form("Job Opening", job_opening)
),
title=_("Job Opening Associated"),
)
@frappe.whitelist()
def make_job_opening(source_name, target_doc=None):
def set_missing_values(source, target):
target.job_title = source.designation
target.status = "Open"
target.currency = frappe.db.get_value("Company", source.company, "default_currency")
target.lower_range = source.expected_compensation
target.description = source.description
return get_mapped_doc(
"Job Requisition",
source_name,
{
"Job Requisition": {
"doctype": "Job Opening",
},
"field_map": {
"designation": "designation",
"name": "job_requisition",
"department": "department",
"no_of_positions": "vacancies",
},
},
target_doc,
set_missing_values,
)
@frappe.whitelist()
def get_avg_time_to_fill(company=None, department=None, designation=None):
filters = {"status": "Filled"}
if company:
filters["company"] = company
if department:
filters["department"] = department
if designation:
filters["designation"] = designation
avg_time_to_fill = frappe.db.get_all(
"Job Requisition",
filters=filters,
fields=["avg(time_to_fill) as average_time"],
)[0].average_time
return format_duration(avg_time_to_fill) if avg_time_to_fill else 0
|
2302_79757062/hrms
|
hrms/hr/doctype/job_requisition/job_requisition.py
|
Python
|
agpl-3.0
| 2,785
|
frappe.listview_settings["Job Requisition"] = {
get_indicator: function (doc) {
const status_color = {
Pending: "yellow",
"Open & Approved": "blue",
Rejected: "red",
Filled: "green",
Cancelled: "gray",
"On Hold": "gray",
};
return [__(doc.status), status_color[doc.status], "status,=," + doc.status];
},
formatters: {
expected_by(value, df, doc) {
if (!value || ["Filled", "Cancelled", "On Hold"].includes(doc.status)) return "";
const now = moment();
const expected_by = moment(value);
const color = now > expected_by ? "red" : "green";
return `
<div
class="pill"
style="background-color: var(--bg-${color}); color: var(--text-on-${color}); font-weight:500">
${expected_by.fromNow()}
</div>
`;
},
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/job_requisition/job_requisition_list.js
|
JavaScript
|
agpl-3.0
| 780
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("KRA", {
// refresh: function(frm) {
// }
});
|
2302_79757062/hrms
|
hrms/hr/doctype/kra/kra.js
|
JavaScript
|
agpl-3.0
| 188
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class KRA(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/kra/kra.py
|
Python
|
agpl-3.0
| 208
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
// nosemgrep: frappe-semgrep-rules.rules.frappe-cur-frm-usage
cur_frm.add_fetch("employee", "employee_name", "employee_name");
frappe.ui.form.on("Leave Allocation", {
onload: function (frm) {
// Ignore cancellation of doctype on cancel all.
frm.ignore_doctypes_on_cancel_all = ["Leave Ledger Entry"];
if (!frm.doc.from_date) frm.set_value("from_date", frappe.datetime.get_today());
frm.set_query("employee", function () {
return {
query: "erpnext.controllers.queries.employee_query",
};
});
frm.set_query("leave_type", function () {
return {
filters: {
is_lwp: 0,
},
};
});
},
refresh: function (frm) {
hrms.leave_utils.add_view_ledger_button(frm);
if (frm.doc.docstatus === 1 && !frm.doc.expired) {
var valid_expiry = moment(frappe.datetime.get_today()).isBetween(
frm.doc.from_date,
frm.doc.to_date,
);
if (valid_expiry) {
// expire current allocation
frm.add_custom_button(__("Expire Allocation"), function () {
frm.trigger("expire_allocation");
});
}
}
if (!frm.doc.__islocal && frm.doc.leave_policy_assignment) {
frappe.db.get_value("Leave Type", frm.doc.leave_type, "is_earned_leave", (r) => {
if (cint(r?.is_earned_leave))
frm.set_df_property("new_leaves_allocated", "read_only", 1);
});
}
},
expire_allocation: function (frm) {
frappe.call({
method: "hrms.hr.doctype.leave_ledger_entry.leave_ledger_entry.expire_allocation",
args: {
allocation: frm.doc,
expiry_date: frappe.datetime.get_today(),
},
freeze: true,
callback: function (r) {
if (!r.exc) {
frappe.msgprint(__("Allocation Expired!"));
}
frm.refresh();
},
});
},
employee: function (frm) {
frm.trigger("calculate_total_leaves_allocated");
},
leave_type: function (frm) {
frm.trigger("leave_policy");
frm.trigger("calculate_total_leaves_allocated");
},
carry_forward: function (frm) {
frm.trigger("calculate_total_leaves_allocated");
},
unused_leaves: function (frm) {
frm.set_value(
"total_leaves_allocated",
flt(frm.doc.unused_leaves) + flt(frm.doc.new_leaves_allocated),
);
},
new_leaves_allocated: function (frm) {
frm.set_value(
"total_leaves_allocated",
flt(frm.doc.unused_leaves) + flt(frm.doc.new_leaves_allocated),
);
},
leave_policy: function (frm) {
if (frm.doc.leave_policy && frm.doc.leave_type) {
frappe.db.get_value(
"Leave Policy Detail",
{
parent: frm.doc.leave_policy,
leave_type: frm.doc.leave_type,
},
"annual_allocation",
(r) => {
if (r && !r.exc)
frm.set_value("new_leaves_allocated", flt(r.annual_allocation));
},
"Leave Policy",
);
}
},
calculate_total_leaves_allocated: function (frm) {
if (cint(frm.doc.carry_forward) == 1 && frm.doc.leave_type && frm.doc.employee) {
return frappe.call({
method: "set_total_leaves_allocated",
doc: frm.doc,
callback: function () {
frm.refresh_fields();
},
});
} else if (cint(frm.doc.carry_forward) == 0) {
frm.set_value("unused_leaves", 0);
frm.set_value("total_leaves_allocated", flt(frm.doc.new_leaves_allocated));
}
},
});
frappe.tour["Leave Allocation"] = [
{
fieldname: "employee",
title: "Employee",
description: __("Select the Employee for which you want to allocate leaves."),
},
{
fieldname: "leave_type",
title: "Leave Type",
description: __(
"Select the Leave Type like Sick leave, Privilege Leave, Casual Leave, etc.",
),
},
{
fieldname: "from_date",
title: "From Date",
description: __("Select the date from which this Leave Allocation will be valid."),
},
{
fieldname: "to_date",
title: "To Date",
description: __("Select the date after which this Leave Allocation will expire."),
},
{
fieldname: "new_leaves_allocated",
title: "New Leaves Allocated",
description: __("Enter the number of leaves you want to allocate for the period."),
},
];
|
2302_79757062/hrms
|
hrms/hr/doctype/leave_allocation/leave_allocation.js
|
JavaScript
|
agpl-3.0
| 4,071
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import add_days, date_diff, flt, formatdate, get_link_to_form, getdate
from hrms.hr.doctype.leave_application.leave_application import get_approved_leaves_for_period
from hrms.hr.doctype.leave_ledger_entry.leave_ledger_entry import (
create_leave_ledger_entry,
expire_allocation,
)
from hrms.hr.utils import get_leave_period, set_employee_name
class OverlapError(frappe.ValidationError):
pass
class BackDatedAllocationError(frappe.ValidationError):
pass
class OverAllocationError(frappe.ValidationError):
pass
class LessAllocationError(frappe.ValidationError):
pass
class ValueMultiplierError(frappe.ValidationError):
pass
class LeaveAllocation(Document):
def validate(self):
self.validate_period()
self.validate_allocation_overlap()
self.validate_lwp()
set_employee_name(self)
self.set_total_leaves_allocated()
self.validate_leave_days_and_dates()
def validate_leave_days_and_dates(self):
# all validations that should run on save as well as on update after submit
self.validate_back_dated_allocation()
self.validate_total_leaves_allocated()
self.validate_leave_allocation_days()
def validate_leave_allocation_days(self):
company = frappe.db.get_value("Employee", self.employee, "company")
leave_period = get_leave_period(self.from_date, self.to_date, company)
max_leaves_allowed = frappe.db.get_value("Leave Type", self.leave_type, "max_leaves_allowed")
if max_leaves_allowed > 0:
leave_allocated = 0
if leave_period:
leave_allocated = get_leave_allocation_for_period(
self.employee,
self.leave_type,
leave_period[0].from_date,
leave_period[0].to_date,
exclude_allocation=self.name,
)
leave_allocated += flt(self.new_leaves_allocated)
if leave_allocated > max_leaves_allowed:
frappe.throw(
_(
"Total allocated leaves are more than maximum allocation allowed for {0} leave type for employee {1} in the period"
).format(self.leave_type, self.employee),
OverAllocationError,
)
def on_submit(self):
self.create_leave_ledger_entry()
# expire all unused leaves in the ledger on creation of carry forward allocation
allocation = get_previous_allocation(self.from_date, self.leave_type, self.employee)
if self.carry_forward and allocation:
expire_allocation(allocation)
def on_cancel(self):
self.create_leave_ledger_entry(submit=False)
if self.leave_policy_assignment:
self.update_leave_policy_assignments_when_no_allocations_left()
if self.carry_forward:
self.set_carry_forwarded_leaves_in_previous_allocation(on_cancel=True)
# nosemgrep: frappe-semgrep-rules.rules.frappe-modifying-but-not-comitting
def on_update_after_submit(self):
if self.has_value_changed("new_leaves_allocated"):
self.validate_earned_leave_update()
self.validate_against_leave_applications()
# recalculate total leaves allocated
self.total_leaves_allocated = flt(self.unused_leaves) + flt(self.new_leaves_allocated)
# run required validations again since total leaves are being updated
self.validate_leave_days_and_dates()
leaves_to_be_added = flt(
(self.new_leaves_allocated - self.get_existing_leave_count()),
self.precision("new_leaves_allocated"),
)
args = {
"leaves": leaves_to_be_added,
"from_date": self.from_date,
"to_date": self.to_date,
"is_carry_forward": 0,
}
create_leave_ledger_entry(self, args, True)
self.db_update()
def get_existing_leave_count(self):
ledger_entries = frappe.get_all(
"Leave Ledger Entry",
filters={
"transaction_type": "Leave Allocation",
"transaction_name": self.name,
"employee": self.employee,
"company": self.company,
"leave_type": self.leave_type,
"is_carry_forward": 0,
"docstatus": 1,
},
fields=["SUM(leaves) as total_leaves"],
)
return ledger_entries[0].total_leaves if ledger_entries else 0
def validate_earned_leave_update(self):
if self.leave_policy_assignment and frappe.db.get_value(
"Leave Type", self.leave_type, "is_earned_leave"
):
msg = _("Cannot update allocation for {0} after submission").format(
frappe.bold(_("Earned Leaves"))
)
msg += "<br><br>"
msg += _(
"Earned Leaves are auto-allocated via scheduler based on the annual allocation set in the Leave Policy: {0}"
).format(get_link_to_form("Leave Policy", self.leave_policy))
frappe.throw(msg, title=_("Not Allowed"))
def validate_against_leave_applications(self):
leaves_taken = get_approved_leaves_for_period(
self.employee, self.leave_type, self.from_date, self.to_date
)
if flt(leaves_taken) > flt(self.total_leaves_allocated):
if frappe.db.get_value("Leave Type", self.leave_type, "allow_negative"):
frappe.msgprint(
_(
"Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period"
).format(self.total_leaves_allocated, leaves_taken)
)
else:
frappe.throw(
_(
"Total allocated leaves {0} cannot be less than already approved leaves {1} for the period"
).format(self.total_leaves_allocated, leaves_taken),
LessAllocationError,
)
def update_leave_policy_assignments_when_no_allocations_left(self):
allocations = frappe.db.get_list(
"Leave Allocation",
filters={"docstatus": 1, "leave_policy_assignment": self.leave_policy_assignment},
)
if len(allocations) == 0:
frappe.db.set_value(
"Leave Policy Assignment", self.leave_policy_assignment, "leaves_allocated", 0
)
def validate_period(self):
if date_diff(self.to_date, self.from_date) <= 0:
frappe.throw(_("To date cannot be before from date"))
def validate_lwp(self):
if frappe.db.get_value("Leave Type", self.leave_type, "is_lwp"):
frappe.throw(
_("Leave Type {0} cannot be allocated since it is leave without pay").format(self.leave_type)
)
def validate_allocation_overlap(self):
leave_allocation = frappe.db.sql(
"""
SELECT
name
FROM `tabLeave Allocation`
WHERE
employee=%s AND leave_type=%s
AND name <> %s AND docstatus=1
AND to_date >= %s AND from_date <= %s""",
(self.employee, self.leave_type, self.name, self.from_date, self.to_date),
)
if leave_allocation:
frappe.msgprint(
_("{0} already allocated for Employee {1} for period {2} to {3}").format(
self.leave_type, self.employee, formatdate(self.from_date), formatdate(self.to_date)
)
)
frappe.throw(
_("Reference")
+ f': <a href="/app/Form/Leave Allocation/{leave_allocation[0][0]}">{leave_allocation[0][0]}</a>',
OverlapError,
)
def validate_back_dated_allocation(self):
future_allocation = frappe.db.sql(
"""select name, from_date from `tabLeave Allocation`
where employee=%s and leave_type=%s and docstatus=1 and from_date > %s
and carry_forward=1""",
(self.employee, self.leave_type, self.to_date),
as_dict=1,
)
if future_allocation:
frappe.throw(
_(
"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}"
).format(formatdate(future_allocation[0].from_date), future_allocation[0].name),
BackDatedAllocationError,
)
@frappe.whitelist()
def set_total_leaves_allocated(self):
self.unused_leaves = flt(
get_carry_forwarded_leaves(self.employee, self.leave_type, self.from_date, self.carry_forward),
self.precision("unused_leaves"),
)
self.total_leaves_allocated = flt(
flt(self.unused_leaves) + flt(self.new_leaves_allocated),
self.precision("total_leaves_allocated"),
)
self.limit_carry_forward_based_on_max_allowed_leaves()
if self.carry_forward:
self.set_carry_forwarded_leaves_in_previous_allocation()
if (
not self.total_leaves_allocated
and not frappe.db.get_value("Leave Type", self.leave_type, "is_earned_leave")
and not frappe.db.get_value("Leave Type", self.leave_type, "is_compensatory")
):
frappe.throw(_("Total leaves allocated is mandatory for Leave Type {0}").format(self.leave_type))
def limit_carry_forward_based_on_max_allowed_leaves(self):
max_leaves_allowed = frappe.db.get_value("Leave Type", self.leave_type, "max_leaves_allowed")
if max_leaves_allowed and self.total_leaves_allocated > max_leaves_allowed:
self.total_leaves_allocated = max_leaves_allowed
self.unused_leaves = max_leaves_allowed - flt(self.new_leaves_allocated)
def set_carry_forwarded_leaves_in_previous_allocation(self, on_cancel=False):
"""Set carry forwarded leaves in previous allocation"""
previous_allocation = get_previous_allocation(self.from_date, self.leave_type, self.employee)
if on_cancel:
self.unused_leaves = 0.0
if previous_allocation:
frappe.db.set_value(
"Leave Allocation",
previous_allocation.name,
"carry_forwarded_leaves_count",
self.unused_leaves,
)
def validate_total_leaves_allocated(self):
# Adding a day to include To Date in the difference
date_difference = date_diff(self.to_date, self.from_date) + 1
if date_difference < self.total_leaves_allocated:
if frappe.db.get_value("Leave Type", self.leave_type, "allow_over_allocation"):
frappe.msgprint(
_(
"<b>Total Leaves Allocated</b> are more than the number of days in the allocation period"
),
indicator="orange",
alert=True,
)
else:
frappe.throw(
_(
"<b>Total Leaves Allocated</b> are more than the number of days in the allocation period"
),
exc=OverAllocationError,
title=_("Over Allocation"),
)
def create_leave_ledger_entry(self, submit=True):
if self.unused_leaves:
expiry_days = frappe.db.get_value(
"Leave Type", self.leave_type, "expire_carry_forwarded_leaves_after_days"
)
end_date = add_days(self.from_date, expiry_days - 1) if expiry_days else self.to_date
args = dict(
leaves=self.unused_leaves,
from_date=self.from_date,
to_date=min(getdate(end_date), getdate(self.to_date)),
is_carry_forward=1,
)
create_leave_ledger_entry(self, args, submit)
args = dict(
leaves=self.new_leaves_allocated,
from_date=self.from_date,
to_date=self.to_date,
is_carry_forward=0,
)
create_leave_ledger_entry(self, args, submit)
def get_previous_allocation(from_date, leave_type, employee):
"""Returns document properties of previous allocation"""
Allocation = frappe.qb.DocType("Leave Allocation")
allocations = (
frappe.qb.from_(Allocation)
.select(
Allocation.name,
Allocation.from_date,
Allocation.to_date,
Allocation.employee,
Allocation.leave_type,
)
.where(
(Allocation.employee == employee)
& (Allocation.leave_type == leave_type)
& (Allocation.to_date < from_date)
& (Allocation.docstatus == 1)
)
.orderby(Allocation.to_date, order=frappe.qb.desc)
.limit(1)
).run(as_dict=True)
return allocations[0] if allocations else None
def get_leave_allocation_for_period(employee, leave_type, from_date, to_date, exclude_allocation=None):
from frappe.query_builder.functions import Sum
Allocation = frappe.qb.DocType("Leave Allocation")
return (
frappe.qb.from_(Allocation)
.select(Sum(Allocation.total_leaves_allocated).as_("total_allocated_leaves"))
.where(
(Allocation.employee == employee)
& (Allocation.leave_type == leave_type)
& (Allocation.docstatus == 1)
& (Allocation.name != exclude_allocation)
& (
(Allocation.from_date.between(from_date, to_date))
| (Allocation.to_date.between(from_date, to_date))
| ((Allocation.from_date < from_date) & (Allocation.to_date > to_date))
)
)
).run()[0][0] or 0.0
def get_carry_forwarded_leaves(employee, leave_type, date, carry_forward=None):
"""Returns carry forwarded leaves for the given employee"""
unused_leaves = 0.0
previous_allocation = get_previous_allocation(date, leave_type, employee)
if carry_forward and previous_allocation:
validate_carry_forward(leave_type)
unused_leaves = get_unused_leaves(
employee, leave_type, previous_allocation.from_date, previous_allocation.to_date
)
if unused_leaves:
max_carry_forwarded_leaves = frappe.db.get_value(
"Leave Type", leave_type, "maximum_carry_forwarded_leaves"
)
if max_carry_forwarded_leaves and unused_leaves > flt(max_carry_forwarded_leaves):
unused_leaves = flt(max_carry_forwarded_leaves)
return unused_leaves
def get_unused_leaves(employee, leave_type, from_date, to_date):
"""Returns unused leaves between the given period while skipping leave allocation expiry"""
leaves = frappe.get_all(
"Leave Ledger Entry",
filters={
"employee": employee,
"leave_type": leave_type,
"from_date": (">=", from_date),
"to_date": ("<=", to_date),
},
or_filters={"is_expired": 0, "is_carry_forward": 1},
fields=["sum(leaves) as leaves"],
)
return flt(leaves[0]["leaves"])
def validate_carry_forward(leave_type):
if not frappe.db.get_value("Leave Type", leave_type, "is_carry_forward"):
frappe.throw(_("Leave Type {0} cannot be carry-forwarded").format(leave_type))
|
2302_79757062/hrms
|
hrms/hr/doctype/leave_allocation/leave_allocation.py
|
Python
|
agpl-3.0
| 13,201
|
def get_data():
return {
"fieldname": "leave_allocation",
"transactions": [{"items": ["Compensatory Leave Request"]}, {"items": ["Leave Encashment"]}],
"reports": [{"items": ["Employee Leave Balance"]}],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/leave_allocation/leave_allocation_dashboard.py
|
Python
|
agpl-3.0
| 214
|
// Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
// render
frappe.listview_settings["Leave Allocation"] = {
get_indicator: function (doc) {
if (doc.status === "Expired") {
return [__("Expired"), "gray", "expired, =, 1"];
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/leave_allocation/leave_allocation_list.js
|
JavaScript
|
agpl-3.0
| 319
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.ui.form.on("Leave Application", {
setup: function (frm) {
frm.set_query("leave_approver", function () {
return {
query: "hrms.hr.doctype.department_approver.department_approver.get_approvers",
filters: {
employee: frm.doc.employee,
doctype: frm.doc.doctype,
},
};
});
frm.set_query("employee", erpnext.queries.employee);
},
onload: function (frm) {
// Ignore cancellation of doctype on cancel all.
frm.ignore_doctypes_on_cancel_all = ["Leave Ledger Entry"];
if (!frm.doc.posting_date) {
frm.set_value("posting_date", frappe.datetime.get_today());
}
if (frm.doc.docstatus == 0) {
return frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_mandatory_approval",
args: {
doctype: frm.doc.doctype,
},
callback: function (r) {
if (!r.exc && r.message) {
frm.toggle_reqd("leave_approver", true);
}
},
});
}
},
validate: function (frm) {
if (frm.doc.from_date === frm.doc.to_date && cint(frm.doc.half_day)) {
frm.doc.half_day_date = frm.doc.from_date;
} else if (frm.doc.half_day === 0) {
frm.doc.half_day_date = "";
}
frm.toggle_reqd("half_day_date", cint(frm.doc.half_day));
},
make_dashboard: function (frm) {
let leave_details;
let lwps;
if (frm.doc.employee) {
frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_leave_details",
async: false,
args: {
employee: frm.doc.employee,
date: frm.doc.from_date || frm.doc.posting_date,
},
callback: function (r) {
if (!r.exc && r.message["leave_allocation"]) {
leave_details = r.message["leave_allocation"];
}
lwps = r.message["lwps"];
},
});
$("div").remove(".form-dashboard-section.custom");
frm.dashboard.add_section(
frappe.render_template("leave_application_dashboard", {
data: leave_details,
}),
__("Allocated Leaves"),
);
frm.dashboard.show();
let allowed_leave_types = Object.keys(leave_details);
// lwps should be allowed for selection as they don't have any allocation
allowed_leave_types = allowed_leave_types.concat(lwps);
frm.set_query("leave_type", function () {
return {
filters: [["leave_type_name", "in", allowed_leave_types]],
};
});
}
},
refresh: function (frm) {
hrms.leave_utils.add_view_ledger_button(frm);
if (frm.is_new()) {
frm.trigger("calculate_total_days");
}
frm.set_intro("");
if (frm.doc.__islocal && !in_list(frappe.user_roles, "Employee")) {
frm.set_intro(__("Fill the form and save it"));
} else if (
frm.perm[0] &&
frm.perm[0].submit &&
!frm.is_dirty() &&
!frm.is_new() &&
!frappe.model.has_workflow(frm.doctype) &&
frm.doc.docstatus === 0
) {
frm.set_intro(__("Submit this Leave Application to confirm."));
}
frm.trigger("set_employee");
if (frm.doc.docstatus === 0) {
frm.trigger("make_dashboard");
}
},
async set_employee(frm) {
if (frm.doc.employee) return;
const employee = await hrms.get_current_employee(frm);
if (employee) {
frm.set_value("employee", employee);
}
},
employee: function (frm) {
frm.trigger("make_dashboard");
frm.trigger("get_leave_balance");
frm.trigger("set_leave_approver");
},
leave_approver: function (frm) {
if (frm.doc.leave_approver) {
frm.set_value("leave_approver_name", frappe.user.full_name(frm.doc.leave_approver));
}
},
leave_type: function (frm) {
frm.trigger("get_leave_balance");
},
half_day: function (frm) {
if (frm.doc.half_day) {
if (frm.doc.from_date == frm.doc.to_date) {
frm.set_value("half_day_date", frm.doc.from_date);
} else {
frm.trigger("half_day_datepicker");
}
} else {
frm.set_value("half_day_date", "");
}
frm.trigger("calculate_total_days");
},
from_date: function (frm) {
frm.events.validate_from_to_date(frm, "to_date");
frm.trigger("make_dashboard");
frm.trigger("half_day_datepicker");
frm.trigger("calculate_total_days");
},
to_date: function (frm) {
frm.events.validate_from_to_date(frm, "from_date");
frm.trigger("make_dashboard");
frm.trigger("half_day_datepicker");
frm.trigger("calculate_total_days");
},
half_day_date(frm) {
frm.trigger("calculate_total_days");
},
validate_from_to_date: function (frm, null_date) {
const from_date = Date.parse(frm.doc.from_date);
const to_date = Date.parse(frm.doc.to_date);
if (to_date < from_date) frm.set_value(null_date, "");
},
half_day_datepicker: function (frm) {
frm.set_value("half_day_date", "");
if (!(frm.doc.half_day && frm.doc.from_date && frm.doc.to_date)) return;
const half_day_datepicker = frm.fields_dict.half_day_date.datepicker;
half_day_datepicker.update({
minDate: frappe.datetime.str_to_obj(frm.doc.from_date),
maxDate: frappe.datetime.str_to_obj(frm.doc.to_date),
});
},
get_leave_balance: function (frm) {
if (
frm.doc.docstatus === 0 &&
frm.doc.employee &&
frm.doc.leave_type &&
frm.doc.from_date &&
frm.doc.to_date
) {
return frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_leave_balance_on",
args: {
employee: frm.doc.employee,
date: frm.doc.from_date,
to_date: frm.doc.to_date,
leave_type: frm.doc.leave_type,
consider_all_leaves_in_the_allocation_period: 1,
},
callback: function (r) {
if (!r.exc && r.message) {
frm.set_value("leave_balance", r.message);
} else {
frm.set_value("leave_balance", "0");
}
},
});
}
},
calculate_total_days: function (frm) {
if (frm.doc.from_date && frm.doc.to_date && frm.doc.employee && frm.doc.leave_type) {
// server call is done to include holidays in leave days calculations
return frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_number_of_leave_days",
args: {
employee: frm.doc.employee,
leave_type: frm.doc.leave_type,
from_date: frm.doc.from_date,
to_date: frm.doc.to_date,
half_day: frm.doc.half_day,
half_day_date: frm.doc.half_day_date,
},
callback: function (r) {
if (r && r.message) {
frm.set_value("total_leave_days", r.message);
frm.trigger("get_leave_balance");
}
},
});
}
},
set_leave_approver: function (frm) {
if (frm.doc.employee) {
return frappe.call({
method: "hrms.hr.doctype.leave_application.leave_application.get_leave_approver",
args: {
employee: frm.doc.employee,
},
callback: function (r) {
if (r && r.message) {
frm.set_value("leave_approver", r.message);
}
},
});
}
},
});
frappe.tour["Leave Application"] = [
{
fieldname: "employee",
title: "Employee",
description: __("Select the Employee."),
},
{
fieldname: "leave_type",
title: "Leave Type",
description: __(
"Select type of leave the employee wants to apply for, like Sick Leave, Privilege Leave, Casual Leave, etc.",
),
},
{
fieldname: "from_date",
title: "From Date",
description: __("Select the start date for your Leave Application."),
},
{
fieldname: "to_date",
title: "To Date",
description: __("Select the end date for your Leave Application."),
},
{
fieldname: "half_day",
title: "Half Day",
description: __("To apply for a Half Day check 'Half Day' and select the Half Day Date"),
},
{
fieldname: "leave_approver",
title: "Leave Approver",
description: __(
"Select your Leave Approver i.e. the person who approves or rejects your leaves.",
),
},
];
|
2302_79757062/hrms
|
hrms/hr/doctype/leave_application/leave_application.js
|
JavaScript
|
agpl-3.0
| 7,679
|