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'))
