def scrap_asset(asset_name): asset = dataent.get_doc("Asset", asset_name) if asset.docstatus != 1: dataent.throw(_("Asset {0} must be submitted").format(asset.name)) elif asset.status in ("Cancelled", "Sold", "Scrapped"): dataent.throw(_("Asset {0} cannot be scrapped, as it is already {1}").format(asset.name, asset.status)) depreciation_series = dataent.get_cached_value('Company', asset.company, "series_for_depreciation_entry") je = dataent.new_doc("Journal Entry") je.voucher_type = "Journal Entry" je.naming_series = depreciation_series je.posting_date = today() je.company = asset.company je.remark = "Scrap Entry for asset {0}".format(asset_name) for entry in get_gl_entries_on_asset_disposal(asset): entry.update({ "reference_type": "Asset", "reference_name": asset_name }) je.append("accounts", entry) je.flags.ignore_permissions = True je.submit() dataent.db.set_value("Asset", asset_name, "disposal_date", today()) dataent.db.set_value("Asset", asset_name, "journal_entry_for_scrap", je.name) asset.set_status("Scrapped") dataent.msgprint(_("Asset scrapped via Journal Entry {0}").format(je.name))
def test_leave_grant(self): leave_type = "_Test Leave Type" # create the leave policy leave_policy = dataent.get_doc({ "doctype": "Leave Policy", "leave_policy_details": [{ "leave_type": leave_type, "annual_allocation": 20 }] }).insert() leave_policy.submit() # create employee and assign the leave period employee = "*****@*****.**" employee_doc_name = make_employee(employee) dataent.db.set_value("Employee", employee_doc_name, "leave_policy", leave_policy.name) # clear the already allocated leave dataent.db.sql( '''delete from `tabLeave Allocation` where employee=%s''', "*****@*****.**") # create the leave period leave_period = create_leave_period(add_months(today(), -3), add_months(today(), 3)) # test leave_allocation leave_period.grant_leave_allocation(employee=employee_doc_name) self.assertEqual( get_leave_balance_on(employee_doc_name, leave_type, today()), 20)
def monthly_auto_repeat(self, doctype, docname, start_date, end_date): def get_months(start, end): diff = (12 * end.year + end.month) - (12 * start.year + start.month) return diff + 1 doc = make_auto_repeat(reference_doctype=doctype, frequency='Monthly', reference_document=docname, start_date=start_date, end_date=end_date) disable_auto_repeat(doc) for data in get_auto_repeat_entries(today()): create_repeated_entries(data) docnames = dataent.get_all(doc.reference_doctype, {'auto_repeat': doc.name}) self.assertEqual(len(docnames), 1) doc = dataent.get_doc('Auto Repeat', doc.name) doc.db_set('disabled', 0) months = get_months(getdate(start_date), getdate(today())) for data in get_auto_repeat_entries(today()): create_repeated_entries(data) docnames = dataent.get_all(doc.reference_doctype, {'auto_repeat': doc.name}) self.assertEqual(len(docnames), months)
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 sync_transactions(bank, bank_account): last_sync_date = dataent.db.get_value("Bank Account", bank_account, "last_integration_date") if last_sync_date: start_date = formatdate(last_sync_date, "YYYY-MM-dd") else: start_date = formatdate(add_months(today(), -12), "YYYY-MM-dd") end_date = formatdate(today(), "YYYY-MM-dd") try: transactions = get_transactions(bank=bank, bank_account=bank_account, start_date=start_date, end_date=end_date) result = [] if transactions: for transaction in transactions: result.append(new_bank_transaction(transaction)) dataent.db.set_value("Bank Account", bank_account, "last_integration_date", getdate(end_date)) return result except Exception: dataent.log_error(dataent.get_traceback(), _("Plaid transactions sync error"))
def get_loyalty_programs(doc): ''' returns applicable loyalty programs for a customer ''' from dataent.desk.treeview import get_children lp_details = [] loyalty_programs = dataent.get_all( "Loyalty Program", fields=["name", "customer_group", "customer_territory"], filters={ "auto_opt_in": 1, "from_date": ["<=", today()], "ifnull(to_date, '2500-01-01')": [">=", today()] }) for loyalty_program in loyalty_programs: customer_groups = [ d.value for d in get_children("Customer Group", loyalty_program.customer_group) ] + [loyalty_program.customer_group] customer_territories = [ d.value for d in get_children("Territory", loyalty_program.customer_territory) ] + [loyalty_program.customer_territory] if (not loyalty_program.customer_group or doc.customer_group in customer_groups)\ and (not loyalty_program.customer_territory or doc.territory in customer_territories): lp_details.append(loyalty_program.name) return lp_details
def test_closing_entry(self): year_start_date = get_fiscal_year(today(), company="_Test Company")[1] make_journal_entry("_Test Bank - _TC", "Sales - _TC", 400, "_Test Cost Center - _TC", posting_date=now(), submit=True) make_journal_entry("_Test Account Cost for Goods Sold - _TC", "_Test Bank - _TC", 600, "_Test Cost Center - _TC", posting_date=now(), submit=True) random_expense_account = dataent.db.sql(""" select t1.account, sum(t1.debit) - sum(t1.credit) as balance, sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) \ as balance_in_account_currency from `tabGL Entry` t1, `tabAccount` t2 where t1.account = t2.name and t2.root_type = 'Expense' and t2.docstatus < 2 and t2.company = '_Test Company' and t1.posting_date between %s and %s group by t1.account having sum(t1.debit) > sum(t1.credit) limit 1""", (year_start_date, today()), as_dict=True) profit_or_loss = dataent.db.sql("""select sum(t1.debit) - sum(t1.credit) as balance from `tabGL Entry` t1, `tabAccount` t2 where t1.account = t2.name and t2.report_type = 'Profit and Loss' and t2.docstatus < 2 and t2.company = '_Test Company' and t1.posting_date between %s and %s""", (year_start_date, today())) profit_or_loss = flt(profit_or_loss[0][0]) if profit_or_loss else 0 pcv = self.make_period_closing_voucher() # Check value for closing account gle_amount_for_closing_account = dataent.db.sql("""select debit - credit from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s and account = '_Test Account Reserves and Surplus - _TC'""", pcv.name) gle_amount_for_closing_account = flt(gle_amount_for_closing_account[0][0]) \ if gle_amount_for_closing_account else 0 self.assertEqual(gle_amount_for_closing_account, profit_or_loss) if random_expense_account: # Check posted value for teh above random_expense_account gle_for_random_expense_account = dataent.db.sql(""" select sum(debit - credit) as amount, sum(debit_in_account_currency - credit_in_account_currency) as amount_in_account_currency from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s and account =%s""", (pcv.name, random_expense_account[0].account), as_dict=True) self.assertEqual(gle_for_random_expense_account[0].amount, -1*random_expense_account[0].balance) self.assertEqual(gle_for_random_expense_account[0].amount_in_account_currency, -1*random_expense_account[0].balance_in_account_currency)
def make_period_closing_voucher(self): pcv = dataent.get_doc({ "doctype": "Period Closing Voucher", "closing_account_head": "_Test Account Reserves and Surplus - _TC", "company": "_Test Company", "fiscal_year": get_fiscal_year(today(), company="_Test Company")[0], "posting_date": today(), "cost_center": "_Test Cost Center - _TC", "remarks": "test" }) pcv.insert() pcv.submit() return pcv
def set_tax_withholding_category(company): accounts = [] abbr = dataent.get_value("Company", company, "abbr") tds_account = dataent.get_value("Account", 'TDS Payable - {0}'.format(abbr), 'name') if company and tds_account: accounts = [dict(company=company, account=tds_account)] fiscal_year = get_fiscal_year(today(), company=company)[0] docs = get_tds_details(accounts, fiscal_year) for d in docs: try: doc = dataent.get_doc(d) doc.flags.ignore_permissions = True doc.flags.ignore_mandatory = True doc.insert() except dataent.DuplicateEntryError: doc = dataent.get_doc("Tax Withholding Category", d.get("name")) doc.append("accounts", accounts[0]) # if fiscal year don't match with any of the already entered data, append rate row fy_exist = [k for k in doc.get('rates') if k.get('fiscal_year')==fiscal_year] if not fy_exist: doc.append("rates", d.get('rates')[0]) doc.save()
def get_data(doctype, date_field): return dataent.db.sql(""" select name, from_date, end_date, recurring_type, recurring_id, next_date, notify_by_email, notification_email_address, recurring_print_format, repeat_on_day_of_month, submit_on_creation, docstatus, {0} from `tab{1}` where is_recurring = 1 and next_date >= %s and docstatus < 2 order by next_date desc """.format(date_field, doctype), today(), as_dict=1)
def send_project_update_email_to_users(project): doc = dataent.get_doc('Project', project) if is_holiday_today(doc.holiday_list) or not doc.users: return project_update = dataent.get_doc({ "doctype": "Project Update", "project": project, "sent": 0, "date": today(), "time": nowtime(), "naming_series": "UPDATE-.project.-.YY.MM.DD.-", }).insert() subject = "For project %s, update your status" % (project) incoming_email_account = dataent.db.get_value( 'Email Account', dict(enable_incoming=1, default_incoming=1), 'email_id') dataent.sendmail(recipients=get_users_email(doc), message=doc.message, subject=_(subject), reference_doctype=project_update.doctype, reference_name=project_update.name, reply_to=incoming_email_account)
def test_get_monthly_results(self): '''Test monthly aggregation values of a field''' result_dict = get_monthly_results('Event', 'subject', 'creation', 'event_type="Private"', 'count') from dataent.utils import today, formatdate self.assertEqual(result_dict[formatdate(today(), "MM-yyyy")], 2)
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 make_course_schedule_test_record(**args): args = dataent._dict(args) course_schedule = dataent.new_doc("Course Schedule") course_schedule.student_group = args.student_group or "Course-TC101-2014-2015 (_Test Academic Term)" course_schedule.course = args.course or "TC101" course_schedule.instructor = args.instructor or "_Test Instructor" course_schedule.room = args.room or dataent.get_all("Room")[0].name course_schedule.schedule_date = args.schedule_date or today() course_schedule.from_time = args.from_time or to_timedelta("01:00:00") course_schedule.to_time = args.to_time or course_schedule.from_time + datetime.timedelta( hours=1) if not args.do_not_save: if args.simulate: while True: try: course_schedule.save() break except OverlapError: course_schedule.from_time = course_schedule.from_time + datetime.timedelta( minutes=10) course_schedule.to_time = course_schedule.from_time + datetime.timedelta( hours=1) else: course_schedule.save() return course_schedule
def make_opportunity(**args): args = dataent._dict(args) opp_doc = dataent.get_doc({ "doctype": "Opportunity", "company": args.company or "_Test Company", "opportunity_from": args.opportunity_from or "Customer", "opportunity_type": "Sales", "with_items": args.with_items or 0, "transaction_date": today() }) if opp_doc.opportunity_from == 'Customer': opp_doc.party_name = args.customer or "_Test Customer" if opp_doc.opportunity_from == 'Lead': opp_doc.party_name = args.lead or "_T-Lead-00001" if args.with_items: opp_doc.append('items', { "item_code": args.item_code or "_Test Item", "qty": args.qty or 1 }) opp_doc.insert() return opp_doc
def test_notification_is_attached(self): todo = dataent.get_doc( dict(doctype='ToDo', description='Test recurring notification attachment', assigned_by='Administrator')).insert() doc = make_auto_repeat( reference_document=todo.name, notify=1, recipients="*****@*****.**", subject="New ToDo", message="A new ToDo has just been created for you") for data in get_auto_repeat_entries(today()): create_repeated_entries(data) dataent.db.commit() new_todo = dataent.db.get_value('ToDo', { 'auto_repeat': doc.name, 'name': ('!=', todo.name) }, 'name') linked_comm = dataent.db.exists( "Communication", dict(reference_doctype="ToDo", reference_name=new_todo)) self.assertTrue(linked_comm)
def convert_deferred_revenue_to_income(start_date=None, end_date=None): # book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM if not start_date: start_date = add_months(today(), -1) if not end_date: end_date = add_days(today(), -1) # check for the sales invoice for which GL entries has to be done invoices = dataent.db.sql_list(''' select distinct parent from `tabSales Invoice Item` where service_start_date<=%s and service_end_date>=%s and enable_deferred_revenue = 1 and docstatus = 1 and ifnull(amount, 0) > 0 ''', (end_date, start_date)) for invoice in invoices: doc = dataent.get_doc("Sales Invoice", invoice) book_deferred_income_or_expense(doc, end_date)
def make_auto_repeat_entry(date=None): enqueued_method = 'dataent.desk.doctype.auto_repeat.auto_repeat.create_repeated_entries' jobs = get_jobs() if not jobs or enqueued_method not in jobs[dataent.local.site]: date = date or today() for data in get_auto_repeat_entries(date): dataent.enqueue(enqueued_method, data=data)
def test_monthly_auto_repeat(self): start_date = today() end_date = add_months(start_date, 12) todo = dataent.get_doc( dict(doctype='ToDo', description='test recurring todo', assigned_by='Administrator')).insert() self.monthly_auto_repeat('ToDo', todo.name, start_date, end_date)
def post_depreciation_entries(date=None): # Return if automatic booking of asset depreciation is disabled if not cint(dataent.db.get_value("Accounts Settings", None, "book_asset_depreciation_entry_automatically")): return if not date: date = today() for asset in get_depreciable_assets(date): make_depreciation_entry(asset, date) dataent.db.commit()
def before_submit(self): start_date_copy = self.start_date today_copy = add_days(today(), -1) if start_date_copy <= today_copy: start_date_copy = today_copy if not self.next_schedule_date: self.next_schedule_date = get_next_schedule_date( start_date_copy, self.frequency, self.repeat_on_day)
def test_create_training_event(self): if not dataent.db.get_value("Training Event", "Basic Training Event"): dataent.get_doc({ "doctype": "Training Event", "event_name": "Basic Training Event", "training_program": "Basic Training", "location": "Union Square", "start_time": add_days(today(), 5), "end_time": add_days(today(), 6), "introduction": "Welcome to the Basic Training Event", "employees": get_attendees(self.employee, self.employee2) }).insert()
def allow_to_make_project_update(project, time, frequency): data = dataent.db.sql( """ SELECT name from `tabProject Update` WHERE project = %s and date = %s """, (project, today())) # len(data) > 1 condition is checked for twicely frequency if data and (frequency in ['Daily', 'Weekly'] or len(data) > 1): return False if get_time(nowtime()) >= get_time(time): return True
def make_sales_invoice(): dataent.set_user("Administrator") si = create_sales_invoice(company="_Test Company 2", customer = '_Test Customer 2', currency = 'EUR', warehouse = 'Finished Goods - _TC2', debit_to = 'Debtors - _TC2', income_account = 'Sales - _TC2', expense_account = 'Cost of Goods Sold - _TC2', cost_center = '_Test Company 2 - _TC2', do_not_save=1) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30)) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50)) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20)) si.submit() return si.name
def stop_resume_auto_repeat(auto_repeat, status): doc = dataent.get_doc('Auto Repeat', auto_repeat) dataent.msgprint(_("Auto Repeat has been {0}").format(status)) if status == 'Resumed': doc.next_schedule_date = get_next_schedule_date( today(), doc.frequency, doc.repeat_on_day) doc.update_status(status) doc.save() return doc.status
def create_sales_invoice_record(qty=1): # return sales invoice doc object return dataent.get_doc({ "doctype": "Sales Invoice", "customer": dataent.get_doc('Customer', { "customer_name": "Prestiga-Biz" }).name, "company": '_Test Company', "due_date": today(), "posting_date": today(), "currency": "INR", "taxes_and_charges": "", "debit_to": "Debtors - _TC", "taxes": [], "items": [{ 'doctype': 'Sales Invoice Item', 'item_code': dataent.get_doc('Item', { 'item_name': 'Consulting' }).name, 'qty': qty, "rate": 10000, 'income_account': 'Sales - _TC', 'cost_center': 'Main - _TC', 'expense_account': 'Cost of Goods Sold - _TC' }] })
def make_depreciation_entry(asset_name, date=None): dataent.has_permission('Journal Entry', throw=True) if not date: date = today() asset = dataent.get_doc("Asset", asset_name) fixed_asset_account, accumulated_depreciation_account, depreciation_expense_account = \ get_depreciation_accounts(asset) depreciation_cost_center, depreciation_series = dataent.get_cached_value('Company', asset.company, ["depreciation_cost_center", "series_for_depreciation_entry"]) depreciation_cost_center = asset.cost_center or depreciation_cost_center for d in asset.get("schedules"): if not d.journal_entry and getdate(d.schedule_date) <= getdate(date): je = dataent.new_doc("Journal Entry") je.voucher_type = "Depreciation Entry" je.naming_series = depreciation_series je.posting_date = d.schedule_date je.company = asset.company je.finance_book = d.finance_book je.remark = "Depreciation Entry against {0} worth {1}".format(asset_name, d.depreciation_amount) je.append("accounts", { "account": accumulated_depreciation_account, "credit_in_account_currency": d.depreciation_amount, "reference_type": "Asset", "reference_name": asset.name }) je.append("accounts", { "account": depreciation_expense_account, "debit_in_account_currency": d.depreciation_amount, "reference_type": "Asset", "reference_name": asset.name, "cost_center": depreciation_cost_center }) je.flags.ignore_permissions = True je.submit() d.db_set("journal_entry", je.name) idx = cint(d.finance_book_id) finance_books = asset.get('finance_books')[idx - 1] finance_books.value_after_depreciation -= d.depreciation_amount finance_books.db_update() asset.set_status() return asset
def test_pr_billing_status(self): # PO -> PR1 -> PI and PO -> PI and PO -> PR2 from epaas.buying.doctype.purchase_order.test_purchase_order import create_purchase_order from epaas.buying.doctype.purchase_order.purchase_order \ import make_purchase_receipt, make_purchase_invoice as make_purchase_invoice_from_po po = create_purchase_order() pr1 = make_purchase_receipt(po.name) pr1.posting_date = today() pr1.posting_time = "10:00" pr1.get("items")[0].received_qty = 2 pr1.get("items")[0].qty = 2 pr1.submit() pi1 = make_purchase_invoice(pr1.name) pi1.submit() pr1.load_from_db() self.assertEqual(pr1.per_billed, 100) pi2 = make_purchase_invoice_from_po(po.name) pi2.get("items")[0].qty = 4 pi2.submit() pr2 = make_purchase_receipt(po.name) pr2.posting_date = today() pr2.posting_time = "08:00" pr2.get("items")[0].received_qty = 5 pr2.get("items")[0].qty = 5 pr2.submit() pr1.load_from_db() self.assertEqual(pr1.get("items")[0].billed_amt, 1000) self.assertEqual(pr1.per_billed, 100) self.assertEqual(pr1.status, "Completed") self.assertEqual(pr2.get("items")[0].billed_amt, 2000) self.assertEqual(pr2.per_billed, 80) self.assertEqual(pr2.status, "To Bill")
def test_restrict_scheduler_events(self): dataent.set_user("Administrator") dormant_date = add_days(today(), -5) dataent.db.sql('update tabUser set last_active=%s', dormant_date) restrict_scheduler_events_if_dormant() dataent.local.conf = _dict(dataent.get_site_config()) self.assertFalse("all" in get_enabled_scheduler_events()) self.assertTrue(dataent.conf.get('dormant', False)) clear_limit("expiry") dataent.local.conf = _dict(dataent.get_site_config())
def is_holiday(employee, date=None): '''Returns True if given Employee has an holiday on the given date :param employee: Employee `name` :param date: Date to check. Will check for today if None''' holiday_list = get_holiday_list_for_employee(employee) if not date: date = today() if holiday_list: return dataent.get_all('Holiday List', dict(name=holiday_list, holiday_date=date)) and True or False