def test_timesheet_time_overlap(self): settings = dataent.get_single('Projects Settings') initial_setting = settings.ignore_employee_time_overlap settings.ignore_employee_time_overlap = 0 settings.save() update_activity_type("_Test Activity Type") timesheet = dataent.new_doc("Timesheet") timesheet.employee = "_T-Employee-00001" timesheet.append( 'time_logs', { "billable": 1, "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(hours=3), "company": "_Test Company" }) timesheet.append( 'time_logs', { "billable": 1, "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(hours=3), "company": "_Test Company" }) self.assertRaises(dataent.ValidationError, timesheet.save) settings.ignore_employee_time_overlap = 1 settings.save() timesheet.save() # should not throw an error settings.ignore_employee_time_overlap = initial_setting settings.save()
def test_enabled_events(self): dataent.flags.enabled_events = [ "hourly", "hourly_long", "daily", "daily_long", "weekly", "weekly_long", "monthly", "monthly_long" ] # maintain last_event and next_event on the same day last_event = now_datetime().replace(hour=0, minute=0, second=0, microsecond=0) next_event = last_event + relativedelta(minutes=30) enqueue_applicable_events(dataent.local.site, next_event, last_event) self.assertFalse("cron" in dataent.flags.ran_schedulers) # maintain last_event and next_event on the same day last_event = now_datetime().replace(hour=0, minute=0, second=0, microsecond=0) next_event = last_event + relativedelta(hours=2) dataent.flags.ran_schedulers = [] enqueue_applicable_events(dataent.local.site, next_event, last_event) self.assertTrue("all" in dataent.flags.ran_schedulers) self.assertTrue("hourly" in dataent.flags.ran_schedulers) dataent.flags.enabled_events = None
def get_leave_period(): leave_period_name = dataent.db.exists({ "doctype": "Leave Period", "company": "_Test Company" }) if leave_period_name: return dataent.get_doc("Leave Period", leave_period_name[0][0]) else: return dataent.get_doc(dict( name = 'Test Leave Period', doctype = 'Leave Period', from_date = "{0}-12-01".format(now_datetime().year - 1), to_date = "{0}-12-31".format(now_datetime().year), company = "_Test Company", is_active = 1 )).insert()
def validate(self): if session['user'] != 'Guest' and not self.customer: dataent.throw(_("Customer is required")) if self.status=="Closed" and not self.resolution_date and \ dataent.db.get_value("Warranty Claim", self.name, "status")!="Closed": self.resolution_date = now_datetime()
def send_daily(): '''Check reports to be sent daily''' current_day = calendar.day_name[now_datetime().weekday()] enabled_reports = dataent.get_all('Auto Email Report', filters={ 'enabled': 1, 'frequency': ('in', ('Daily', 'Weekdays', 'Weekly')) }) for report in enabled_reports: auto_email_report = dataent.get_doc('Auto Email Report', report.name) # if not correct weekday, skip if auto_email_report.frequency == "Weekdays": if current_day in ("Saturday", "Sunday"): continue elif auto_email_report.frequency == 'Weekly': if auto_email_report.day_of_week != current_day: continue auto_email_report.send()
def add_items(self, items): self.set('po_items', []) for data in items: item_details = get_item_details(data.item_code) pi = self.append( 'po_items', { 'include_exploded_items': 1, 'warehouse': data.warehouse, 'item_code': data.item_code, 'description': item_details and item_details.description or '', 'stock_uom': item_details and item_details.stock_uom or '', 'bom_no': item_details and item_details.bom_no or '', 'planned_qty': data.pending_qty, 'pending_qty': data.pending_qty, 'planned_start_date': now_datetime(), 'product_bundle_item': data.parent_item }) if self.get_items_from == "Sales Order": pi.sales_order = data.parent pi.sales_order_item = data.name elif self.get_items_from == "Material Request": pi.material_request = data.parent pi.material_request_item = data.name
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 get_expiry_message(): if "System Manager" not in dataent.get_roles(): return "" limits = get_limits() if not limits.expiry: return "" expires_on = getdate(get_limits().get("expiry")) today = now_datetime().date() message = "" if today > expires_on: message = _("Your subscription has expired.") else: days_to_expiry = (expires_on - today).days if days_to_expiry == 0: message = _("Your subscription will expire today.") elif days_to_expiry == 1: message = _("Your subscription will expire tomorrow.") elif days_to_expiry <= EXPIRY_WARNING_DAYS: message = _("Your subscription will expire on {0}.").format( formatdate(expires_on)) if message and limits.upgrade_url: upgrade_link = get_upgrade_link(limits.upgrade_url) message += ' ' + _('To renew, {0}.').format(upgrade_link) return message
def parse_naming_series(parts, doctype='', doc=''): n = '' if isinstance(parts, string_types): parts = parts.split('.') series_set = False today = now_datetime() for e in parts: part = '' if e.startswith('#'): if not series_set: digits = len(e) part = getseries(n, digits, doctype) series_set = True elif e == 'YY': part = today.strftime('%y') elif e == 'MM': part = today.strftime('%m') elif e == 'DD': part = today.strftime("%d") elif e == 'YYYY': part = today.strftime('%Y') elif e == 'FY': part = dataent.defaults.get_user_default("fiscal_year") elif e.startswith('{') and doc: e = e.replace('{', '').replace('}', '') part = doc.get(e) elif doc and doc.get(e): part = doc.get(e) else: part = e if isinstance(part, string_types): n += part return n
def get_creation_count(self, doctype, minutes): """Get count of records created in the last x minutes""" from dataent.utils import now_datetime from dateutil.relativedelta import relativedelta return dataent.db.sql( """select count(name) from `tab{doctype}` where creation >= %s""".format(doctype=doctype), now_datetime() - relativedelta(minutes=minutes))[0][0]
def send(): now_date = now_datetime().date() for ed in dataent.db.sql("""select name from `tabEmail Digest` where enabled=1 and docstatus<2""", as_list=1): ed_obj = dataent.get_doc('Email Digest', ed[0]) if (now_date == ed_obj.get_next_sending()): ed_obj.send()
def check_out_inpatient(inpatient_record): if inpatient_record.inpatient_occupancies: for inpatient_occupancy in inpatient_record.inpatient_occupancies: if inpatient_occupancy.left != 1: inpatient_occupancy.left = True inpatient_occupancy.check_out = now_datetime() dataent.db.set_value("Healthcare Service Unit", inpatient_occupancy.service_unit, "occupancy_status", "Vacant")
def get_queue(): return dataent.db.sql('''select name, sender from `tabEmail Queue` where (status='Not Sent' or status='Partially Sent') and (send_after is null or send_after < %(now)s) order by priority desc, creation asc limit 500''', { 'now': now_datetime() }, as_dict=True)
def has_expired(): if dataent.session.user == "Administrator": return False expires_on = get_limits().expiry if not expires_on: return False if now_datetime().date() <= getdate(expires_on): return False return True
def test_timesheet_std_working_hours(self): company = dataent.get_doc('Company', "_Test Company") company.standard_working_hours = 8 company.save() timesheet = dataent.new_doc("Timesheet") timesheet.employee = "_T-Employee-00001" timesheet.company = '_Test Company' timesheet.append( 'time_logs', { "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(days=4) }) timesheet.save() ts = dataent.get_doc('Timesheet', timesheet.name) self.assertEqual(ts.total_hours, 32) ts.submit() ts.cancel() company = dataent.get_doc('Company', "_Test Company") company.standard_working_hours = 0 company.save() timesheet = dataent.new_doc("Timesheet") timesheet.employee = "_T-Employee-00001" timesheet.company = '_Test Company' timesheet.append( 'time_logs', { "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(days=4) }) timesheet.save() ts = dataent.get_doc('Timesheet', timesheet.name) self.assertEqual(ts.total_hours, 96) ts.submit() ts.cancel()
def validate_posting_time(self): # set Edit Posting Date and Time to 1 while data import if dataent.flags.in_import and self.posting_date: self.set_posting_time = 1 if not getattr(self, 'set_posting_time', None): now = now_datetime() self.posting_date = now.strftime('%Y-%m-%d') self.posting_time = now.strftime('%H:%M:%S.%f') elif self.posting_time: try: get_time(self.posting_time) except ValueError: dataent.throw(_('Invalid Posting Time'))
def test_validate_overlap_admission(self): dataent.db.sql("""delete from `tabInpatient Record`""") patient = get_patient() ip_record = create_inpatient(patient) ip_record.save(ignore_permissions=True) ip_record_new = create_inpatient(patient) self.assertRaises(dataent.ValidationError, ip_record_new.save) service_unit = get_healthcare_service_unit() admit_patient(ip_record, service_unit, now_datetime()) ip_record_new = create_inpatient(patient) self.assertRaises(dataent.ValidationError, ip_record_new.save) dataent.db.sql("""delete from `tabInpatient Record`""")
def setup_employee(): dataent.db.set_value("HR Settings", None, "emp_created_by", "Naming Series") dataent.db.commit() for d in dataent.get_all('Salary Component'): salary_component = dataent.get_doc('Salary Component', d.name) salary_component.append('accounts', dict( company=epaas.get_default_company(), default_account=dataent.get_value('Account', dict(account_name=('like', 'Salary%'))) )) salary_component.save() import_json('Employee') holiday_list = dataent.db.get_value("Holiday List", {"holiday_list_name": str(now_datetime().year)}, 'name') dataent.db.sql('''update tabEmployee set holiday_list={0}'''.format(holiday_list))
def setup_fiscal_year(): fiscal_year = None for year in range(2010, now_datetime().year + 1, 1): try: fiscal_year = dataent.get_doc({ "doctype": "Fiscal Year", "year": cstr(year), "year_start_date": "{0}-01-01".format(year), "year_end_date": "{0}-12-31".format(year) }).insert() except dataent.DuplicateEntryError: pass # set the last fiscal year (current year) as default if fiscal_year: fiscal_year.set_as_default()
def validate_end_of_life(item_code, end_of_life=None, disabled=None, verbose=1): if (not end_of_life) or (disabled is None): end_of_life, disabled = dataent.db.get_value( "Item", item_code, ["end_of_life", "disabled"]) if end_of_life and end_of_life != "0000-00-00" and getdate( end_of_life) <= now_datetime().date(): msg = _("Item {0} has reached its end of life on {1}").format( item_code, formatdate(end_of_life)) _msgprint(msg, verbose) if disabled: _msgprint(_("Item {0} is disabled").format(item_code), verbose)
def before_insert(self): index = get_current_index() self.row_index = index self.timestamp = now_datetime() if index != 1: prev_hash = dataent.db.sql( "SELECT chaining_hash FROM `tabTransaction Log` WHERE row_index = {0}" .format(index - 1)) if prev_hash: self.previous_hash = prev_hash[0][0] else: self.previous_hash = "Indexing broken" else: self.previous_hash = self.hash_line() self.transaction_hash = self.hash_line() self.chaining_hash = self.hash_chain() self.checksum_version = "v1.0.1"
def setup_holiday_list(): """Setup Holiday List for the current year""" year = now_datetime().year holiday_list = dataent.get_doc({ "doctype": "Holiday List", "holiday_list_name": str(year), "from_date": "{0}-01-01".format(year), "to_date": "{0}-12-31".format(year), }) holiday_list.insert() holiday_list.weekly_off = "Saturday" holiday_list.get_weekly_off_dates() holiday_list.weekly_off = "Sunday" holiday_list.get_weekly_off_dates() holiday_list.save() dataent.set_value("Company", epaas.get_default_company(), "default_holiday_list", holiday_list.name)
def setup_leave_allocation(): year = now_datetime().year for employee in dataent.get_all('Employee', fields=['name']): leave_types = dataent.get_all("Leave Type", fields=['name', 'max_continuous_days_allowed']) for leave_type in leave_types: if not leave_type.max_continuous_days_allowed: leave_type.max_continuous_days_allowed = 10 leave_allocation = dataent.get_doc({ "doctype": "Leave Allocation", "employee": employee.name, "from_date": "{0}-01-01".format(year), "to_date": "{0}-12-31".format(year), "leave_type": leave_type.name, "new_leaves_allocated": random.randint(1, int(leave_type.max_continuous_days_allowed)) }) leave_allocation.insert() leave_allocation.submit() dataent.db.commit()
def notify_admin_access_to_system_manager(login_manager=None): if (login_manager and login_manager.user == "Administrator" and dataent.local.conf.notify_admin_access_to_system_manager): site = '<a href="{0}" target="_blank">{0}</a>'.format( dataent.local.request.host_url) date_and_time = '<b>{0}</b>'.format( format_datetime(now_datetime(), format_string="medium")) ip_address = dataent.local.request_ip access_message = _( 'Administrator accessed {0} on {1} via IP Address {2}.').format( site, date_and_time, ip_address) dataent.sendmail(recipients=get_system_managers(), subject=_("Administrator Logged In"), template="administrator_logged_in", args={'access_message': access_message}, header=['Access Notification', 'orange'])
def set_backup_file_name(self): todays_date = now_datetime().strftime('%Y%m%d_%H%M%S') site = dataent.local.site or dataent.generate_hash(length=8) site = site.replace('.', '_') #Generate a random name using today's date and a 8 digit random number for_db = todays_date + "-" + site + "-database.sql" for_public_files = todays_date + "-" + site + "-files.tar" for_private_files = todays_date + "-" + site + "-private-files.tar" backup_path = get_backup_path() if not self.backup_path_db: self.backup_path_db = os.path.join(backup_path, for_db) if not self.backup_path_files: self.backup_path_files = os.path.join(backup_path, for_public_files) if not self.backup_path_private_files: self.backup_path_private_files = os.path.join( backup_path, for_private_files)
def test_admit_and_discharge(self): dataent.db.sql("""delete from `tabInpatient Record`""") patient = get_patient() # Schedule Admission ip_record = create_inpatient(patient) ip_record.save(ignore_permissions=True) self.assertEqual( ip_record.name, dataent.db.get_value("Patient", patient, "inpatient_record")) self.assertEqual( ip_record.status, dataent.db.get_value("Patient", patient, "inpatient_status")) # Admit service_unit = get_healthcare_service_unit() admit_patient(ip_record, service_unit, now_datetime()) self.assertEqual( "Admitted", dataent.db.get_value("Patient", patient, "inpatient_status")) self.assertEqual( "Occupied", dataent.db.get_value("Healthcare Service Unit", service_unit, "occupancy_status")) # Discharge schedule_discharge(patient=patient) self.assertEqual( "Vacant", dataent.db.get_value("Healthcare Service Unit", service_unit, "occupancy_status")) ip_record1 = dataent.get_doc("Inpatient Record", ip_record.name) # Validate Pending Invoices self.assertRaises(dataent.ValidationError, ip_record.discharge) mark_invoiced_inpatient_occupancy(ip_record1) discharge_patient(ip_record1) self.assertEqual( None, dataent.db.get_value("Patient", patient, "inpatient_record")) self.assertEqual( None, dataent.db.get_value("Patient", patient, "inpatient_status"))
def get_from_to_date(self): today = now_datetime().date() # decide from date based on email digest frequency if self.frequency == "Daily": # from date, to_date is yesterday from_date = to_date = today - timedelta(days=1) elif self.frequency == "Weekly": # from date is the previous week's monday from_date = today - timedelta(days=today.weekday(), weeks=1) # to date is sunday i.e. the previous day to_date = from_date + timedelta(days=6) else: # from date is the 1st day of the previous month from_date = today - relativedelta(days=today.day - 1, months=1) # to date is the last day of the previous month to_date = today - relativedelta(days=today.day) return from_date, to_date
def create_production_plan(**args): args = dataent._dict(args) pln = dataent.get_doc({ 'doctype': 'Production Plan', 'company': args.company or '_Test Company', 'posting_date': nowdate(), 'include_non_stock_items': args.include_non_stock_items or 1, 'include_subcontracted_items': args.include_subcontracted_items or 1, 'ignore_existing_ordered_qty': args.ignore_existing_ordered_qty or 1, 'po_items': [{ 'use_multi_level_bom': args.use_multi_level_bom or 1, 'item_code': args.item_code, 'bom_no': dataent.db.get_value('Item', args.item_code, 'default_bom'), 'planned_qty': args.planned_qty or 1, 'planned_start_date': args.planned_start_date or now_datetime() }] }) mr_items = get_items_for_material_requests(pln.as_dict()) for d in mr_items: pln.append('mr_items', d) if not args.do_not_save: pln.insert() if not args.do_not_submit: pln.submit() return pln
def validate_hour(self): """check if user is logging in during restricted hours""" login_before = int( dataent.db.get_value( 'User', self.user, 'login_before', ignore=True) or 0) login_after = int( dataent.db.get_value('User', self.user, 'login_after', ignore=True) or 0) if not (login_before or login_after): return from dataent.utils import now_datetime current_hour = int(now_datetime().strftime('%H')) if login_before and current_hour > login_before: dataent.throw(_("Login not allowed at this time"), dataent.AuthenticationError) if login_after and current_hour < login_after: dataent.throw(_("Login not allowed at this time"), dataent.AuthenticationError)
def get_report_content(self): '''Returns file in for the report in given format''' report = dataent.get_doc('Report', self.report) if self.report_type == 'Report Builder' and self.data_modified_till: self.filters = json.loads(self.filters) if self.filters else {} self.filters['modified'] = ( '>', now_datetime() - timedelta(hours=self.data_modified_till)) columns, data = report.get_data(limit=self.no_of_rows or 100, user=self.user, filters=self.filters, as_dict=True) # add serial numbers columns.insert(0, dataent._dict(fieldname='idx', label='', width='30px')) for i in range(len(data)): data[i]['idx'] = i + 1 if len(data) == 0 and self.send_if_data: return None if self.format == 'HTML': return self.get_html_table(columns, data) elif self.format == 'XLSX': spreadsheet_data = self.get_spreadsheet_data(columns, data) xlsx_file = make_xlsx(spreadsheet_data, "Auto Email Report") return xlsx_file.getvalue() elif self.format == 'CSV': spreadsheet_data = self.get_spreadsheet_data(columns, data) return to_csv(spreadsheet_data) else: dataent.throw(_('Invalid Output Format'))