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)
