def get_booking_dates(doc, item, posting_date=None): if not posting_date: posting_date = add_days(today(), -1) last_gl_entry = False deferred_account = "deferred_revenue_account" if doc.doctype=="Sales Invoice" else "deferred_expense_account" prev_gl_entry = dataent.db.sql(''' select name, posting_date from `tabGL Entry` where company=%s and account=%s and voucher_type=%s and voucher_no=%s and voucher_detail_no=%s order by posting_date desc limit 1 ''', (doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name), as_dict=True) if prev_gl_entry: start_date = getdate(add_days(prev_gl_entry[0].posting_date, 1)) else: start_date = item.service_start_date end_date = get_last_day(start_date) if end_date >= item.service_end_date: end_date = item.service_end_date last_gl_entry = True elif item.service_stop_date and end_date >= item.service_stop_date: end_date = item.service_stop_date last_gl_entry = True if end_date > getdate(posting_date): end_date = posting_date if getdate(start_date) <= getdate(end_date): return start_date, end_date, last_gl_entry else: return None, None, None
def get_start_end_dates(payroll_frequency, start_date=None, company=None): '''Returns dict of start and end dates for given payroll frequency based on start_date''' if payroll_frequency == "Monthly" or payroll_frequency == "Bimonthly" or payroll_frequency == "": fiscal_year = get_fiscal_year(start_date, company=company)[0] month = "%02d" % getdate(start_date).month m = get_month_details(fiscal_year, month) if payroll_frequency == "Bimonthly": if getdate(start_date).day <= 15: start_date = m['month_start_date'] end_date = m['month_mid_end_date'] else: start_date = m['month_mid_start_date'] end_date = m['month_end_date'] else: start_date = m['month_start_date'] end_date = m['month_end_date'] if payroll_frequency == "Weekly": end_date = add_days(start_date, 6) if payroll_frequency == "Fortnightly": end_date = add_days(start_date, 13) if payroll_frequency == "Daily": end_date = start_date return dataent._dict({'start_date': start_date, 'end_date': end_date})
def calculate_next_due_date(periodicity, start_date=None, end_date=None, last_completion_date=None, next_due_date=None): if not start_date and not last_completion_date: start_date = dataent.utils.now() if last_completion_date and (last_completion_date > start_date or not start_date): start_date = last_completion_date if periodicity == 'Daily': next_due_date = add_days(start_date, 1) if periodicity == 'Weekly': next_due_date = add_days(start_date, 7) if periodicity == 'Monthly': next_due_date = add_months(start_date, 1) if periodicity == 'Yearly': next_due_date = add_years(start_date, 1) if periodicity == '2 Yearly': next_due_date = add_years(start_date, 2) if periodicity == 'Quarterly': next_due_date = add_months(start_date, 3) if end_date and (start_date >= end_date or last_completion_date >= end_date or next_due_date): next_due_date = "" return next_due_date
def test_staffing_plan_parent_company(self): _set_up() if dataent.db.exists("Staffing Plan", "Test"): return staffing_plan = dataent.new_doc("Staffing Plan") staffing_plan.company = "_Test Company" staffing_plan.name = "Test" staffing_plan.from_date = nowdate() staffing_plan.to_date = add_days(nowdate(), 10) staffing_plan.append( "staffing_details", { "designation": "Designer", "number_of_positions": 7, "estimated_cost_per_position": 50000 }) staffing_plan.insert() staffing_plan.submit() self.assertEqual(staffing_plan.total_estimated_budget, 350000.00) if dataent.db.exists("Staffing Plan", "Test 1"): return staffing_plan = dataent.new_doc("Staffing Plan") staffing_plan.company = "_Test Company 10" staffing_plan.name = "Test 1" staffing_plan.from_date = nowdate() staffing_plan.to_date = add_days(nowdate(), 10) staffing_plan.append( "staffing_details", { "designation": "Designer", "number_of_positions": 7, "estimated_cost_per_position": 60000 }) staffing_plan.insert() self.assertRaises(ParentCompanyError, staffing_plan.submit)
def test_future_inactive_signed_contract_status(self): self.contract_doc.is_signed = True self.contract_doc.start_date = add_days(nowdate(), 1) self.contract_doc.end_date = add_days(nowdate(), 2) self.contract_doc.insert() self.assertEqual(self.contract_doc.status, "Inactive")
def test_max_continuous_leaves(self): employee = get_employee() leave_period = get_leave_period() dataent.delete_doc_if_exists("Leave Type", "Test Leave Type", force=1) leave_type = dataent.get_doc(dict( leave_type_name = 'Test Leave Type', doctype = 'Leave Type', max_leaves_allowed = 15, max_continuous_days_allowed = 3 )).insert() date = add_days(nowdate(), -7) allocate_leaves(employee, leave_period, leave_type.name, 10) leave_application = dataent.get_doc(dict( doctype = 'Leave Application', employee = employee.name, leave_type = leave_type.name, from_date = date, to_date = add_days(date, 4), company = "_Test Company", docstatus = 1, status = "Approved" )) self.assertRaises(dataent.ValidationError, leave_application.insert)
def make_auto_repeat(**args): args = dataent._dict(args) doc = dataent.get_doc({ 'doctype': 'Auto Repeat', 'reference_doctype': args.reference_doctype or 'ToDo', 'reference_document': args.reference_document or dataent.db.get_value('ToDo', {'docstatus': 1}, 'name'), 'frequency': args.frequency or 'Daily', 'start_date': args.start_date or add_days(today(), -1), 'end_date': args.end_date or add_days(today(), 2), 'submit_on_creation': args.submit_on_creation or 0, 'notify_by_email': args.notify or 0, 'recipients': args.recipients or "", 'subject': args.subject or "", 'message': args.message or "" }).insert(ignore_permissions=True) if not args.do_not_submit: doc.submit() return doc
def test_make_purchase_invoice_with_terms(self): po = create_purchase_order(do_not_save=True) self.assertRaises(dataent.ValidationError, make_pi_from_po, po.name) po.update({"payment_terms_template": "_Test Payment Term Template"}) po.save() po.submit() self.assertEqual(po.payment_schedule[0].payment_amount, 2500.0) self.assertEqual(getdate(po.payment_schedule[0].due_date), getdate(po.transaction_date)) self.assertEqual(po.payment_schedule[1].payment_amount, 2500.0) self.assertEqual(getdate(po.payment_schedule[1].due_date), add_days(getdate(po.transaction_date), 30)) pi = make_pi_from_po(po.name) pi.save() self.assertEqual(pi.doctype, "Purchase Invoice") self.assertEqual(len(pi.get("items", [])), 1) self.assertEqual(pi.payment_schedule[0].payment_amount, 2500.0) self.assertEqual(getdate(pi.payment_schedule[0].due_date), getdate(po.transaction_date)) self.assertEqual(pi.payment_schedule[1].payment_amount, 2500.0) self.assertEqual(getdate(pi.payment_schedule[1].due_date), add_days(getdate(po.transaction_date), 30))
def get_period_date_ranges(self): from dateutil.relativedelta import relativedelta, MO from_date, to_date = getdate(self.filters.from_date), getdate(self.filters.to_date) increment = { "Monthly": 1, "Quarterly": 3, "Half-Yearly": 6, "Yearly": 12 }.get(self.filters.range, 1) if self.filters.range in ['Monthly', 'Quarterly']: from_date = from_date.replace(day = 1) elif self.filters.range == "Yearly": from_date = get_fiscal_year(from_date)[1] else: from_date = from_date + relativedelta(from_date, weekday=MO(-1)) self.periodic_daterange = [] for dummy in range(1, 53): if self.filters.range == "Weekly": period_end_date = add_days(from_date, 6) else: period_end_date = add_to_date(from_date, months=increment, days=-1) if period_end_date > to_date: period_end_date = to_date self.periodic_daterange.append(period_end_date) from_date = add_days(period_end_date, 1) if period_end_date == to_date: break
def test_reschedule_dependent_task(self): task1 = create_task("_Test Task 1", nowdate(), add_days(nowdate(), 10)) task2 = create_task("_Test Task 2", add_days(nowdate(), 11), add_days(nowdate(), 15), task1.name) task2.get("depends_on")[0].project = "_Test Project" task2.save() task3 = create_task("_Test Task 3", add_days(nowdate(), 11), add_days(nowdate(), 15), task2.name) task3.get("depends_on")[0].project = "_Test Project" task3.save() task1.update({"exp_end_date": add_days(nowdate(), 20)}) task1.save() self.assertEqual( dataent.db.get_value("Task", task2.name, "exp_start_date"), getdate(add_days(nowdate(), 21))) self.assertEqual( dataent.db.get_value("Task", task2.name, "exp_end_date"), getdate(add_days(nowdate(), 25))) self.assertEqual( dataent.db.get_value("Task", task3.name, "exp_start_date"), getdate(add_days(nowdate(), 26))) self.assertEqual( dataent.db.get_value("Task", task3.name, "exp_end_date"), getdate(add_days(nowdate(), 30)))
def test_payroll_frequency(self): fiscal_year = get_fiscal_year(nowdate(), company=epaas.get_default_company())[0] month = "%02d" % getdate(nowdate()).month m = get_month_details(fiscal_year, month) for payroll_frequency in [ "Monthly", "Bimonthly", "Fortnightly", "Weekly", "Daily" ]: make_employee(payroll_frequency + "*****@*****.**") ss = make_employee_salary_slip( payroll_frequency + "*****@*****.**", payroll_frequency) if payroll_frequency == "Monthly": self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Bimonthly": if getdate(ss.start_date).day <= 15: self.assertEqual(ss.end_date, m['month_mid_end_date']) else: self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Fortnightly": self.assertEqual(ss.end_date, add_days(nowdate(), 13)) elif payroll_frequency == "Weekly": self.assertEqual(ss.end_date, add_days(nowdate(), 6)) elif payroll_frequency == "Daily": self.assertEqual(ss.end_date, nowdate())
def create_purchase_order(**args): po = dataent.new_doc("Purchase Order") args = dataent._dict(args) if args.transaction_date: po.transaction_date = args.transaction_date po.schedule_date = add_days(nowdate(), 1) po.company = args.company or "_Test Company" po.supplier = args.customer or "_Test Supplier" po.is_subcontracted = args.is_subcontracted or "No" po.currency = args.currency or dataent.get_cached_value( 'Company', po.company, "default_currency") po.conversion_factor = args.conversion_factor or 1 po.supplier_warehouse = args.supplier_warehouse or None po.append( "items", { "item_code": args.item or args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty or 10, "rate": args.rate or 500, "schedule_date": add_days(nowdate(), 1), "include_exploded_items": args.get('include_exploded_items', 1) }) if not args.do_not_save: po.insert() if not args.do_not_submit: if po.is_subcontracted == "Yes": supp_items = po.get("supplied_items") for d in supp_items: d.reserve_warehouse = args.warehouse or "_Test Warehouse - _TC" po.submit() return po
def test_overdue(self): task = create_task("Testing Overdue", add_days(nowdate(), -10), add_days(nowdate(), -5)) from epaas.projects.doctype.task.task import set_tasks_as_overdue set_tasks_as_overdue() self.assertEqual(dataent.db.get_value("Task", task.name, "status"), "Overdue")
def test_lapsed_contract_status(self): self.contract_doc.contract_term = "_Test Customer Contract with Requirements" self.contract_doc.start_date = add_days(nowdate(), -2) self.contract_doc.end_date = add_days(nowdate(), 1) self.contract_doc.requires_fulfilment = 1 self.contract_doc.fulfilment_deadline = add_days(nowdate(), -1) self.contract_doc.save() self.assertEqual(self.contract_doc.fulfilment_status, "Lapsed")
def test_fee_validity(self): dataent.db.sql("""delete from `tabPatient Appointment`""") dataent.db.sql("""delete from `tabFee Validity`""") patient = get_random("Patient") practitioner = get_random("Healthcare Practitioner") department = get_random("Medical Department") if not patient: patient = dataent.new_doc("Patient") patient.patient_name = "_Test Patient" patient.sex = "Male" patient.save(ignore_permissions=True) patient = patient.name if not department: medical_department = dataent.new_doc("Medical Department") medical_department.department = "_Test Medical Department" medical_department.save(ignore_permissions=True) department = medical_department.name if not practitioner: practitioner = dataent.new_doc("Healthcare Practitioner") practitioner.first_name = "_Test Healthcare Practitioner" practitioner.department = department practitioner.save(ignore_permissions=True) practitioner = practitioner.name dataent.db.set_value("Healthcare Settings", None, "max_visit", 2) dataent.db.set_value("Healthcare Settings", None, "valid_days", 7) appointment = create_appointment(patient, practitioner, nowdate(), department) invoiced = dataent.db.get_value("Patient Appointment", appointment.name, "invoiced") self.assertEqual(invoiced, 0) invoice_appointment(appointment) appointment = create_appointment(patient, practitioner, add_days(nowdate(), 4), department) invoiced = dataent.db.get_value("Patient Appointment", appointment.name, "invoiced") self.assertTrue(invoiced) appointment = create_appointment(patient, practitioner, add_days(nowdate(), 5), department) invoiced = dataent.db.get_value("Patient Appointment", appointment.name, "invoiced") self.assertEqual(invoiced, 0) appointment = create_appointment(patient, practitioner, add_days(nowdate(), 10), department) invoiced = dataent.db.get_value("Patient Appointment", appointment.name, "invoiced") self.assertEqual(invoiced, 0)
def create_task(self, crop_tasks, project_name, start_date): for crop_task in crop_tasks: task = dataent.new_doc("Task") task.update({ "subject": crop_task.get("task_name"), "priority": crop_task.get("priority"), "project": project_name, "exp_start_date": add_days(start_date, crop_task.get("start_day") - 1), "exp_end_date": add_days(start_date, crop_task.get("end_day") - 1) }) task.insert()
def test_valid_till(self): from epaas.selling.doctype.quotation.quotation import make_sales_order quotation = dataent.copy_doc(test_records[0]) quotation.valid_till = add_days(quotation.transaction_date, -1) self.assertRaises(dataent.ValidationError, quotation.validate) quotation.valid_till = add_days(nowdate(), -1) quotation.insert() quotation.submit() self.assertRaises(dataent.ValidationError, make_sales_order, quotation.name)
def setup_asset(): assets = json.loads(open(dataent.get_app_path('epaas', 'demo', 'data', 'asset.json')).read()) for d in assets: asset = dataent.new_doc('Asset') asset.update(d) asset.purchase_date = add_days(nowdate(), -random.randint(20, 1500)) asset.next_depreciation_date = add_days(asset.purchase_date, 30) asset.warehouse = "Stores - WPL" asset.set_missing_values() asset.make_depreciation_schedule() asset.flags.ignore_validate = True asset.flags.ignore_mandatory = True asset.save() asset.submit()
def get_same_items(): return [{ "item_code": "_Test FG Item", "warehouse": "_Test Warehouse - _TC", "qty": 1, "rate": 500, "schedule_date": add_days(nowdate(), 1) }, { "item_code": "_Test FG Item", "warehouse": "_Test Warehouse - _TC", "qty": 4, "rate": 500, "schedule_date": add_days(nowdate(), 1) }]
def get_auto_repeat_schedule(self): schedule_details = [] start_date_copy = getdate(self.start_date) end_date_copy = getdate(self.end_date) today_copy = dataent.utils.datetime.date.today() if start_date_copy < today_copy: start_date_copy = today_copy if not self.end_date: days = 60 if self.frequency in ['Daily', 'Weekly'] else 365 end_date_copy = add_days(today_copy, days) start_date_copy = get_next_schedule_date(start_date_copy, self.frequency, self.repeat_on_day) while (getdate(start_date_copy) < getdate(end_date_copy)): row = { "reference_document": self.reference_document, "frequency": self.frequency, "next_scheduled_date": start_date_copy } schedule_details.append(row) start_date_copy = get_next_schedule_date(start_date_copy, self.frequency, self.repeat_on_day) return schedule_details
def execute(filters=None): if not filters: filters = {} from_date = get_first_day(filters["month"] + '-' + filters["year"]) to_date = get_last_day(filters["month"] + '-' + filters["year"]) total_days_in_month = date_diff(to_date, from_date) +1 columns = get_columns(total_days_in_month) students = get_student_group_students(filters.get("student_group"),1) students_list = get_students_list(students) att_map = get_attendance_list(from_date, to_date, filters.get("student_group"), students_list) data = [] for stud in students: row = [stud.student, stud.student_name] student_status = dataent.db.get_value("Student", stud.student, "enabled") date = from_date total_p = total_a = 0.0 for day in range(total_days_in_month): status="None" if att_map.get(stud.student): status = att_map.get(stud.student).get(date, "None") elif not student_status: status = "Inactive" else: status = "None" status_map = {"Present": "P", "Absent": "A", "None": "", "Inactive":"-"} row.append(status_map[status]) if status == "Present": total_p += 1 elif status == "Absent": total_a += 1 date = add_days(date, 1) row += [total_p, total_a] data.append(row) return columns, data
def test_current_asset_value(self): pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=100000.0, location="Test Location") asset_name = dataent.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name') asset_doc = dataent.get_doc('Asset', asset_name) month_end_date = get_last_day(nowdate()) purchase_date = nowdate() if nowdate() != month_end_date else add_days( nowdate(), -15) asset_doc.available_for_use_date = purchase_date asset_doc.purchase_date = purchase_date asset_doc.calculate_depreciation = 1 asset_doc.append( "finance_books", { "expected_value_after_useful_life": 200, "depreciation_method": "Straight Line", "total_number_of_depreciations": 3, "frequency_of_depreciation": 10, "depreciation_start_date": month_end_date }) asset_doc.submit() current_value = get_current_asset_value(asset_doc.name) self.assertEqual(current_value, 100000.0)
def test_make_sales_invoice_with_terms(self): so = make_sales_order(do_not_submit=True) self.assertRaises(dataent.ValidationError, make_sales_invoice, so.name) so.update({"payment_terms_template": "_Test Payment Term Template"}) so.save() so.submit() si = make_sales_invoice(so.name) self.assertEqual(len(si.get("items")), len(so.get("items"))) self.assertEqual(len(si.get("items")), 1) si.insert() self.assertEqual(si.payment_schedule[0].payment_amount, 500.0) self.assertEqual(si.payment_schedule[0].due_date, so.transaction_date) self.assertEqual(si.payment_schedule[1].payment_amount, 500.0) self.assertEqual(si.payment_schedule[1].due_date, add_days(so.transaction_date, 30)) si.submit() si1 = make_sales_invoice(so.name) self.assertEqual(len(si1.get("items")), 0)
def get_error_report(from_date=None, to_date=None, limit=10): from dataent.utils import get_url, now_datetime, add_days if not from_date: from_date = add_days(now_datetime().date(), -1) if not to_date: to_date = add_days(now_datetime().date(), -1) errors = get_errors(from_date, to_date, limit) if errors: return 1, """<h4>Error Logs (max {limit}):</h4> <p>URL: <a href="{url}" target="_blank">{url}</a></p><hr>{errors}""".format( limit=limit, url=get_url(), errors="<hr>".join(errors)) else: return 0, "<p>No error logs</p>"
def make_leave_application(): allocated_leaves = dataent.get_all("Leave Allocation", fields=['employee', 'leave_type']) for allocated_leave in allocated_leaves: leave_balance = get_leave_balance_on( allocated_leave.employee, allocated_leave.leave_type, dataent.flags.current_date, consider_all_leaves_in_the_allocation_period=True) if leave_balance != 0: if leave_balance == 1: to_date = dataent.flags.current_date else: to_date = add_days(dataent.flags.current_date, random.randint(0, leave_balance - 1)) leave_application = dataent.get_doc({ "doctype": "Leave Application", "employee": allocated_leave.employee, "from_date": dataent.flags.current_date, "to_date": to_date, "leave_type": allocated_leave.leave_type, }) try: leave_application.insert() leave_application.submit() dataent.db.commit() except (OverlapError, AttendanceAlreadyMarkedError): dataent.db.rollback()
def validate_schedule_date_for_holiday_list(self, schedule_date, sales_person): validated = False employee = dataent.db.get_value("Sales Person", sales_person, "employee") if employee: holiday_list = get_holiday_list_for_employee(employee) else: holiday_list = dataent.get_cached_value('Company', self.company, "default_holiday_list") holidays = dataent.db.sql_list( '''select holiday_date from `tabHoliday` where parent=%s''', holiday_list) if not validated and holidays: # max iterations = len(holidays) for i in range(len(holidays)): if schedule_date in holidays: schedule_date = add_days(schedule_date, -1) else: validated = True break return schedule_date
def make_material_request(self): '''Create Material Requests grouped by Sales Order and Material Request Type''' material_request_list = [] material_request_map = {} for item in self.mr_items: item_doc = dataent.get_cached_doc('Item', item.item_code) # key for Sales Order:Material Request Type key = '{}:{}'.format(item.sales_order, item_doc.default_material_request_type) schedule_date = add_days(nowdate(), cint(item_doc.lead_time_days)) if not key in material_request_map: # make a new MR for the combination material_request_map[key] = dataent.new_doc("Material Request") material_request = material_request_map[key] material_request.update({ "transaction_date": nowdate(), "status": "Draft", "company": self.company, "requested_by": dataent.session.user, 'material_request_type': item_doc.default_material_request_type }) material_request_list.append(material_request) else: material_request = material_request_map[key] # add item material_request.append("items", { "item_code": item.item_code, "qty": item.quantity, "schedule_date": schedule_date, "warehouse": item.warehouse, "sales_order": item.sales_order, 'production_plan': self.name, 'material_request_plan_item': item.name, "project": dataent.db.get_value("Sales Order", item.sales_order, "project") \ if item.sales_order else None }) for material_request in material_request_list: # submit material_request.flags.ignore_permissions = 1 material_request.run_method("set_missing_values") material_request.submit() dataent.flags.mute_messages = False if material_request_list: material_request_list = ["""<a href="#Form/Material Request/{0}">{1}</a>""".format(m.name, m.name) \ for m in material_request_list] msgprint(_("{0} created").format(comma_and(material_request_list))) else: msgprint(_("No material request created"))
def create_salary_slips_for_payroll_period(employee, salary_structure, payroll_period, deduct_random=True): deducted_dates = [] i = 0 while i < 12: slip = dataent.get_doc({ "doctype": "Salary Slip", "employee": employee, "salary_structure": salary_structure, "frequency": "Monthly" }) if i == 0: posting_date = add_days(payroll_period.start_date, 25) else: posting_date = add_months(posting_date, 1) if i == 11: slip.deduct_tax_for_unsubmitted_tax_exemption_proof = 1 slip.deduct_tax_for_unclaimed_employee_benefits = 1 if deduct_random and not random.randint(0, 2): slip.deduct_tax_for_unsubmitted_tax_exemption_proof = 1 deducted_dates.append(posting_date) slip.posting_date = posting_date slip.start_date = get_first_day(posting_date) slip.end_date = get_last_day(posting_date) doc = make_salary_slip(salary_structure, slip, employee) doc.submit() i += 1 return deducted_dates
def create_delivery_trip(contact=None): if not contact: contact = get_contact_and_address("_Test Customer") delivery_trip = dataent.new_doc("Delivery Trip") delivery_trip.update({ "doctype": "Delivery Trip", "company": epaas.get_default_company(), "departure_time": add_days(now_datetime(), 5), "driver": dataent.db.get_value('Driver', {"full_name": "Newton Scmander"}), "vehicle": "JB 007", "delivery_stops": [{ "customer": "_Test Customer", "address": contact.shipping_address.parent, "contact": contact.contact_person.parent }, { "customer": "_Test Customer", "address": contact.shipping_address.parent, "contact": contact.contact_person.parent }] }) delivery_trip.insert() return delivery_trip
def check_stock_frozen_date(self): stock_frozen_upto = dataent.db.get_value('Stock Settings', None, 'stock_frozen_upto') or '' if stock_frozen_upto: stock_auth_role = dataent.db.get_value('Stock Settings', None, 'stock_auth_role') if getdate(self.posting_date) <= getdate( stock_frozen_upto ) and not stock_auth_role in dataent.get_roles(): dataent.throw( _("Stock transactions before {0} are frozen").format( formatdate(stock_frozen_upto)), StockFreezeError) stock_frozen_upto_days = int( dataent.db.get_value('Stock Settings', None, 'stock_frozen_upto_days') or 0) if stock_frozen_upto_days: stock_auth_role = dataent.db.get_value('Stock Settings', None, 'stock_auth_role') older_than_x_days_ago = (add_days(getdate( self.posting_date), stock_frozen_upto_days) <= date.today()) if older_than_x_days_ago and not stock_auth_role in dataent.get_roles( ): dataent.throw( _("Not allowed to update stock transactions older than {0}" ).format(stock_frozen_upto_days), StockFreezeError)