def sync_for_current_user():
if frappe.get_list("Email Account Config", filters={"enabled": 1,"user":frappe.session.user}):
for email_account in frappe.get_list("Email Account Config", filters={"enabled": 1,"user":frappe.session.user}):
email_config = frappe.get_doc('Email Account Config',email_account)
email_config.receive()
return {"msg":"Email Synced, Please Refresh page."}
else:
return {"msg":"Email Configration Not Done or Configuration Is Not Enabled"}
def before_tests():
frappe.clear_cache()
# complete setup if missing
from frappe.desk.page.setup_wizard.setup_wizard import setup_complete
if not frappe.get_list("Company"):
setup_complete({
"currency" :"USD",
"first_name" :"Test",
"last_name" :"User",
"company_name" :"Wind Power LLC",
"timezone" :"America/New_York",
"company_abbr" :"WP",
"industry" :"Manufacturing",
"country" :"United States",
"fy_start_date" :"2014-01-01",
"fy_end_date" :"2014-12-31",
"language" :"english",
"company_tagline" :"Testing",
"email" :"*****@*****.**",
"password" :"test",
"chart_of_accounts" : "Standard"
})
frappe.db.sql("delete from `tabLeave Allocation`")
frappe.db.sql("delete from `tabLeave Application`")
frappe.db.sql("delete from `tabSalary Slip`")
frappe.db.sql("delete from `tabItem Price`")
frappe.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 0)
frappe.db.commit()
def get_student_attendance_records(based_on, date=None, student_batch=None, course_schedule=None):
student_list = []
student_attendance_list = []
if based_on=="Course Schedule":
student_group = frappe.db.get_value("Course Schedule", course_schedule, "student_group")
if student_group:
student_list = frappe.get_list("Student Group Student", fields=["student", "student_name", "idx"] , \
filters={"parent": student_group}, order_by= "idx")
else:
student_batch = frappe.db.get_value("Course Schedule", course_schedule, "student_batch")
if not student_list:
student_list = frappe.get_list("Student Batch Student", fields=["student", "student_name", "idx"] , filters={"parent": student_batch}, order_by= "idx")
if course_schedule:
student_attendance_list= frappe.db.sql("""select student, status from `tabStudent Attendance` where \
course_schedule= %s and docstatus=1""", (course_schedule), as_dict=1)
else:
student_attendance_list= frappe.db.sql("""select student, status from `tabStudent Attendance` where \
student_batch= %s and date= %s and docstatus=1 and \
(course_schedule is Null or course_schedule='')""",
(student_batch, date), as_dict=1)
for attendance in student_attendance_list:
for student in student_list:
if student.student == attendance.student:
student.status = attendance.status
return student_list
def validate(self):
total_qty = 0
if self.total_qty == 0:
frappe.throw(_("Total Quantity cannot be 0"))
# else:
# for i in self.measurement_table:
# total_qty += round(i.number * i.qty, 4)
# if self.total_qty != total_qty:
# frappe.throw(_("Total Quantity mismatch Error"))
delivery_note = frappe.get_list("Delivery Note",
fields=["name", "docstatus"],
filters = {
"name": self.delivery_note
})
if delivery_note[0].docstatus != 0:
frappe.throw(_("Only Draft Delivery Note Allowed"))
delivery_note_items = frappe.get_list("Delivery Note Item",
fields=["parent", "item_code"],
filters = {
"parent": self.delivery_note
})
cl = []
for itm in delivery_note_items:
if self.item == itm.item_code:
cl.append(1)
else:
cl.append(0)
if sum(cl) == 0:
frappe.throw(_("Only Items from Delivery Note Allowed"))
def get_filter_dashboard_data(stats, doctype, filters=[]):
"""get tags info"""
import json
tags = json.loads(stats)
if filters:
filters = json.loads(filters)
stats = {}
columns = frappe.db.get_table_columns(doctype)
for tag in tags:
if not tag["name"] in columns: continue
tagcount = []
if tag["type"] not in ['Date', 'Datetime']:
tagcount = frappe.get_list(doctype,
fields=[tag["name"], "count(*)"],
filters = filters + ["ifnull(`%s`,'')!=''" % tag["name"]],
group_by = tag["name"],
as_list = True)
if tag["type"] not in ['Check','Select','Date','Datetime','Int',
'Float','Currency','Percent'] and tag['name'] not in ['docstatus']:
stats[tag["name"]] = list(tagcount)
if stats[tag["name"]]:
data =["No Data", frappe.get_list(doctype,
fields=[tag["name"], "count(*)"],
filters=filters + ["({0} = '' or {0} is null)".format(tag["name"])],
as_list=True)[0][1]]
if data and data[1]!=0:
stats[tag["name"]].append(data)
else:
stats[tag["name"]] = tagcount
return stats
def get_employees(date, department=None, branch=None, company=None):
attendance_not_marked = []
attendance_marked = []
conditions = {}
conditions["status"] = "Active"
if department:
conditions["department"] = department;
if branch:
conditions["branch"] = branch;
if company:
conditions["company"] = company;
employee_list = frappe.get_list("Employee", fields=["employee", "employee_name"], filters=conditions, order_by="employee_name")
marked_employee = {}
for emp in frappe.get_list("Attendance", fields=["employee", "status"],
filters={"att_date": date}):
marked_employee[emp['employee']] = emp['status']
for employee in employee_list:
employee['status'] = marked_employee.get(employee['employee'])
if employee['employee'] not in marked_employee:
attendance_not_marked.append(employee)
else:
attendance_marked.append(employee)
return {
"marked": attendance_marked,
"unmarked": attendance_not_marked
}
def test_strict_user_permissions(self):
"""If `Strict User Permissions` is checked in System Settings,
show records even if User Permissions are missing for a linked
doctype"""
frappe.set_user("Administrator")
frappe.db.sql('delete from tabContact')
make_test_records_for_doctype('Contact', force=True)
set_user_permission_doctypes("Contact", role="Sales User",
apply_user_permissions=1, user_permission_doctypes=['Salutation'])
set_user_permission_doctypes("Salutation", role="All",
apply_user_permissions=1, user_permission_doctypes=['Salutation'])
add_user_permission("Salutation", "Mr", "*****@*****.**")
self.set_strict_user_permissions(0)
frappe.set_user("*****@*****.**")
self.assertEquals(len(frappe.get_list("Contact")), 2)
frappe.set_user("Administrator")
self.set_strict_user_permissions(1)
frappe.set_user("*****@*****.**")
self.assertTrue(len(frappe.get_list("Contact")), 1)
frappe.set_user("Administrator")
self.set_strict_user_permissions(0)
def set_taxes(row, filters):
taxes = frappe.get_list("Sales Taxes and Charges",
filters={
'parent': row.dn_id
},
fields=('item_wise_tax_detail', 'account_head'))
account_list = ["cgst_account", "sgst_account", "igst_account", "cess_account"]
taxes_list = frappe.get_list("GST Account",
filters={
"parent": "GST Settings",
"company": filters.company
},
fields=account_list)
item_tax_rate = {}
for tax in taxes:
item_wise_tax = json.loads(tax.item_wise_tax_detail)
item_tax_rate[tax.account_head] = item_wise_tax.get(row.item_code)
tax_rate = []
tax = taxes_list[0]
for key in account_list:
if tax[key] not in item_tax_rate.keys():
item_tax_rate[tax[key]] = [0.0, 0.0]
tax_rate.append(str(item_tax_rate[tax[key]][0]))
row.update({key[:5] + "amount": round(item_tax_rate.get(tax[key], 0.0)[1], 2)})
item_tax_rate.pop(tax[key])
row.amount = float(row.amount) + sum(i[1] for i in item_tax_rate.values())
row.update({'tax_rate': '+'.join(tax_rate)})
def get_linked_docs(doctype, name, metadata_loaded=None):
if not metadata_loaded: metadata_loaded = []
meta = frappe.widgets.form.meta.get_meta(doctype)
linkinfo = meta.get("__linked_with")
results = {}
for dt, link in linkinfo.items():
link["doctype"] = dt
link_meta_bundle = frappe.widgets.form.load.get_meta_bundle(dt)
linkmeta = link_meta_bundle[0]
if not linkmeta.get("issingle"):
fields = [d.fieldname for d in linkmeta.get("fields", {"in_list_view":1,
"fieldtype": ["not in", ["Image", "HTML", "Button", "Table"]]})] \
+ ["name", "modified", "docstatus"]
fields = ["`tab{dt}`.`{fn}`".format(dt=dt, fn=sf.strip()) for sf in fields if sf]
if link.get("child_doctype"):
ret = frappe.get_list(doctype=dt, fields=fields,
filters=[[link.get('child_doctype'), link.get("fieldname"), '=', name]])
else:
ret = frappe.get_list(doctype=dt, fields=fields,
filters=[[dt, link.get("fieldname"), '=', name]])
if ret:
results[dt] = ret
if not dt in metadata_loaded:
frappe.local.response.docs.extend(link_meta_bundle)
return results
def get_student_attendance_records(based_on, date=None, student_group=None, course_schedule=None):
student_list = []
student_attendance_list = []
if based_on=="Course Schedule":
student_group = frappe.db.get_value("Course Schedule", course_schedule, "student_group")
if student_group:
student_list = frappe.get_list("Student Group Student", fields=["student", "student_name", "group_roll_number"] , \
filters={"parent": student_group, "active": 1}, order_by= "group_roll_number")
if not student_list:
student_list = frappe.get_list("Student Group Student", fields=["student", "student_name", "group_roll_number"] ,
filters={"parent": student_group, "active": 1}, order_by= "group_roll_number")
if course_schedule:
student_attendance_list= frappe.db.sql('''select student, status from `tabStudent Attendance` where \
course_schedule= %s''', (course_schedule), as_dict=1)
else:
student_attendance_list= frappe.db.sql('''select student, status from `tabStudent Attendance` where \
student_group= %s and date= %s and \
(course_schedule is Null or course_schedule='')''',
(student_group, date), as_dict=1)
for attendance in student_attendance_list:
for student in student_list:
if student.student == attendance.student:
student.status = attendance.status
return student_list
def enable_all_roles_and_domains():
""" enable all roles and domain for testing """
roles = frappe.get_list("Role", filters={"disabled": 1})
for role in roles:
_role = frappe.get_doc("Role", role.get("name"))
_role.disabled = 0
_role.flags.ignore_mandatory = True
_role.flags.ignore_permissions = True
_role.save()
# add all roles to users
user = frappe.get_doc("User", "*****@*****.**")
user.add_roles(*[role.get("name") for role in roles])
domains = frappe.get_list("Domain")
if not domains:
return
domain_settings = frappe.get_doc("Domain Settings", "Domain Settings")
domain_settings.set("active_domains", [])
for domain in domains:
row = domain_settings.append("active_domains", {})
row.domain=domain.get("name")
domain_settings.save()
def get_items(warehouse, posting_date, posting_time):
items = frappe.get_list("Bin", fields=["item_code"], filters={"warehouse": warehouse}, as_list=1)
items += frappe.get_list("Item", fields=["name"], filters= {"is_stock_item": 1, "has_serial_no": 0,
"has_batch_no": 0, "has_variants": 0, "disabled": 0, "default_warehouse": warehouse},
as_list=1)
res = []
for item in set(items):
stock_bal = get_stock_balance(item[0], warehouse, posting_date, posting_time,
with_valuation_rate=True)
if frappe.db.get_value("Item",item[0],"disabled") == 0:
res.append({
"item_code": item[0],
"warehouse": warehouse,
"qty": stock_bal[0],
"item_name": frappe.db.get_value('Item', item[0], 'item_name'),
"valuation_rate": stock_bal[1],
"current_qty": stock_bal[0],
"current_valuation_rate": stock_bal[1]
})
return res
def get_employees(date, department = None, branch = None, company = None):
attendance_not_marked = []
attendance_marked = []
filters = {"status": "Active", "date_of_joining": ["<=", date]}
if department != "All":
filters["department"] = department
if branch != "All":
filters["branch"] = branch
if company != "All":
filters["company"] = company
employee_list = frappe.get_list("Employee", fields=["employee", "employee_name"], filters=filters, order_by="employee_name")
marked_employee = {}
for emp in frappe.get_list("Attendance", fields=["employee", "status"],
filters={"attendance_date": date}):
marked_employee[emp['employee']] = emp['status']
for employee in employee_list:
employee['status'] = marked_employee.get(employee['employee'])
if employee['employee'] not in marked_employee:
attendance_not_marked.append(employee)
else:
attendance_marked.append(employee)
return {
"marked": attendance_marked,
"unmarked": attendance_not_marked
}
def get_comments_reviews(response):
response["download_count"] = frappe.get_list("IP Download Log", fields=["count(*)"], filters={ "file_name":response.get("file_name") }, as_list=True)[0][0]
response["avg_ratings"] = frappe.get_list("IP Review", fields=["ifnull(avg(ratings),0.0)"], filters={ "file_name":response.get("file_name") }, as_list=True)[0][0]
response["comments"] = frappe.db.sql(""" select ipr.user_id, ipr.comments, ipr.ratings, concat(usr.first_name , ' ',usr.last_name) as full_name
from `tabIP Review` ipr left join `tabUser` usr
on usr.name = ipr.user_id
where file_name = %s""",(response.get("file_name")),as_dict=1)
response["download_flag"] = frappe.db.get_value("IP Download Log", {"file_name":response.get("file_name"), "user_id":frappe.session.user}, "name")
response["panel_class"] = "panel panel-primary ip-file-panel" if response.get("published_flag") else "panel panel-archive ip-file-panel"
def remove_app(app_name, dry_run=False, yes=False):
"""Delete app and all linked to the app's module with the app."""
if not dry_run and not yes:
confirm = raw_input("All doctypes (including custom), modules related to this app will be deleted. Are you sure you want to continue (y/n) ? ")
if confirm!="y":
return
from frappe.utils.backups import scheduled_backup
print "Backing up..."
scheduled_backup(ignore_files=True)
drop_doctypes = []
# remove modules, doctypes, roles
for module_name in frappe.get_module_list(app_name):
for doctype in frappe.get_list("DocType", filters={"module": module_name},
fields=["name", "issingle"]):
print "removing DocType {0}...".format(doctype.name)
# drop table
if not dry_run:
frappe.delete_doc("DocType", doctype.name)
if not doctype.issingle:
drop_doctypes.append(doctype.name)
# remove reports
for report in frappe.get_list("Report", filters={"module": module_name}):
print "removing {0}...".format(report.name)
if not dry_run:
frappe.delete_doc("Report", report.name)
for page in frappe.get_list("Page", filters={"module": module_name}):
print "removing Page {0}...".format(page.name)
# drop table
if not dry_run:
frappe.delete_doc("Page", page.name)
print "removing Module {0}...".format(module_name)
if not dry_run:
frappe.delete_doc("Module Def", module_name)
# delete desktop icons
frappe.db.sql('delete from `tabDesktop Icon` where app=%s', app_name)
remove_from_installed_apps(app_name)
if not dry_run:
# drop tables after a commit
frappe.db.commit()
for doctype in set(drop_doctypes):
frappe.db.sql("drop table `tab{0}`".format(doctype))
def check_attendance_records_exist(course_schedule=None, student_batch=None, date=None):
"""Check if Attendance Records are made against the specified Course Schedule or Student Batch for given date.
:param course_schedule: Course Schedule.
:param student_batch: Student Batch.
:param date: Date.
"""
if course_schedule:
return frappe.get_list("Student Attendance", filters={"course_schedule": course_schedule})
else:
return frappe.get_list("Student Attendance", filters={"student_batch": student_batch, "date": date})
def get_linked_docs(doctype, name, metadata_loaded=None, no_metadata=False):
if not metadata_loaded:
metadata_loaded = []
meta = frappe.desk.form.meta.get_meta(doctype)
linkinfo = meta.get("__linked_with")
results = {}
if not linkinfo:
return results
me = frappe.db.get_value(doctype, name, ["parenttype", "parent"], as_dict=True)
for dt, link in linkinfo.items():
link["doctype"] = dt
link_meta_bundle = frappe.desk.form.load.get_meta_bundle(dt)
linkmeta = link_meta_bundle[0]
if not linkmeta.get("issingle"):
fields = [
d.fieldname
for d in linkmeta.get(
"fields", {"in_list_view": 1, "fieldtype": ["not in", ["Image", "HTML", "Button", "Table"]]}
)
] + ["name", "modified", "docstatus"]
fields = ["`tab{dt}`.`{fn}`".format(dt=dt, fn=sf.strip()) for sf in fields if sf]
try:
if link.get("get_parent"):
if me and me.parent and me.parenttype == dt:
ret = frappe.get_list(doctype=dt, fields=fields, filters=[[dt, "name", "=", me.parent]])
else:
ret = None
elif link.get("child_doctype"):
ret = frappe.get_list(
doctype=dt,
fields=fields,
filters=[[link.get("child_doctype"), link.get("fieldname"), "=", name]],
)
else:
ret = frappe.get_list(doctype=dt, fields=fields, filters=[[dt, link.get("fieldname"), "=", name]])
except frappe.PermissionError:
frappe.local.message_log.pop()
continue
if ret:
results[dt] = ret
if not no_metadata and not dt in metadata_loaded:
frappe.local.response.docs.extend(link_meta_bundle)
return results
def get_student_group_students(student_group, include_inactive=0):
"""Returns List of student, student_name in Student Group.
:param student_group: Student Group.
"""
if include_inactive:
students = frappe.get_list("Student Group Student", fields=["student", "student_name"] ,
filters={"parent": student_group}, order_by= "group_roll_number")
else:
students = frappe.get_list("Student Group Student", fields=["student", "student_name"] ,
filters={"parent": student_group, "active": 1}, order_by= "group_roll_number")
return students
def assign_student_group(student, student_name, program, courses, batch):
course_list = [d["course"] for d in courses]
for d in frappe.get_list("Student Group", fields=("name"), filters={"program": program, "course":("in", course_list)}):
student_group = frappe.get_doc("Student Group", d.name)
student_group.append("students", {"student": student, "student_name": student_name,
"group_roll_number":len(student_group.students)+1, "active":1})
student_group.save()
student_batch = frappe.get_list("Student Group", fields=("name"), filters={"program": program, "group_based_on":"Batch", "batch":batch})[0]
student_batch_doc = frappe.get_doc("Student Group", student_batch.name)
student_batch_doc.append("students", {"student": student, "student_name": student_name,
"group_roll_number":len(student_batch_doc.students)+1, "active":1})
student_batch_doc.save()
frappe.db.commit()
def get_list(doctype, txt, filters, limit_start, limit_page_length=20, ignore_permissions=False,
fields=None, order_by=None):
meta = frappe.get_meta(doctype)
if not filters:
filters = []
if not fields:
fields = "distinct *"
or_filters = []
if txt:
if meta.search_fields:
for f in meta.get_search_fields():
if f == 'name' or meta.get_field(f).fieldtype in ('Data', 'Text', 'Small Text', 'Text Editor'):
or_filters.append([doctype, f, "like", "%" + txt + "%"])
else:
if isinstance(filters, dict):
filters["name"] = ("like", "%" + txt + "%")
else:
filters.append([doctype, "name", "like", "%" + txt + "%"])
return frappe.get_list(doctype, fields = fields,
filters=filters, or_filters=or_filters, limit_start=limit_start,
limit_page_length = limit_page_length, ignore_permissions=ignore_permissions,
order_by=order_by)
def get_notifications_for_doctypes(config, notification_count):
"""Notifications for DocTypes"""
can_read = frappe.get_user().get_can_read()
open_count_doctype = {}
for d in config.for_doctype:
if d in can_read:
condition = config.for_doctype[d]
if d in notification_count:
open_count_doctype[d] = notification_count[d]
else:
try:
if isinstance(condition, dict):
result = len(frappe.get_list(d, fields=["name"],
filters=condition, limit_page_length = 21, as_list=True, ignore_ifnull=True))
else:
result = frappe.get_attr(condition)()
except frappe.PermissionError:
frappe.msgprint("Permission Error in notifications for {0}".format(d))
except Exception, e:
# OperationalError: (1412, 'Table definition has changed, please retry transaction')
if e.args[0]!=1412:
raise
else:
open_count_doctype[d] = result
frappe.cache().hset("notification_count:" + d, frappe.session.user, result)
def arrival_end_trip():
trip = json.loads(frappe.local.request.values["inputData"])
t = frappe.get_list("DRS", fields=["*"],
filters={"trip_name":trip["tripName"]})[0]
tx = frappe.get_doc("DRS", t["name"])
tx.status = "End Trip"
tx.save()
def get_students(doctype, txt, searchfield, start, page_len, filters):
if not filters.get("academic_term"):
filters["academic_term"] = frappe.defaults.get_defaults().academic_term
if not filters.get("academic_year"):
filters["academic_year"] = frappe.defaults.get_defaults().academic_year
enrolled_students = frappe.get_list("Program Enrollment", filters={
"academic_term": filters.get('academic_term'),
"academic_year": filters.get('academic_year')
}, fields=["student"])
students = [d.student for d in enrolled_students] if enrolled_students else [""]
return frappe.db.sql("""select
name, title from tabStudent
where
name not in (%s)
and
`%s` LIKE %s
order by
idx desc, name
limit %s, %s"""%(
", ".join(['%s']*len(students)), searchfield, "%s", "%s", "%s"),
tuple(students + ["%%%s%%" % txt, start, page_len]
)
)
def test_get_monthly_goal_graph_data(self):
'''Test for accurate values in graph data (based on test_get_monthly_results)'''
docname = frappe.get_list('Event', filters = {"subject": ["=", "_Test Event 1"]})[0]["name"]
frappe.db.set_value('Event', docname, 'description', 1)
data = get_monthly_goal_graph_data('Test', 'Event', docname, 'description', 'description', 'description',
'Event', '', 'description', 'creation', 'starts_on = "2014-01-01"', 'count')
self.assertEqual(float(data['data']['datasets'][0]['values'][-1]), 1)
def get_events(doctype, start, end, field_map, filters=None, fields=None):
field_map = frappe._dict(json.loads(field_map))
doc_meta = frappe.get_meta(doctype)
for d in doc_meta.fields:
if d.fieldtype == "Color":
field_map.update({
"color": d.fieldname
})
if filters:
filters = json.loads(filters or '')
if not fields:
fields = [field_map.start, field_map.end, field_map.title, 'name']
if field_map.color:
fields.append(field_map.color)
start_date = "ifnull(%s, '0000-00-00 00:00:00')" % field_map.start
end_date = "ifnull(%s, '2199-12-31 00:00:00')" % field_map.end
filters += [
[doctype, start_date, '<=', end],
[doctype, end_date, '>=', start],
]
return frappe.get_list(doctype, fields=fields, filters=filters)
def get_items_from_file(doc_name, warehouse, posting_date, posting_time):
res_items = []
try:
rows = read_csv_content_from_attached_file(frappe.get_doc("Stock Reconciliation", doc_name))
except:
frappe.throw(_("Please select a valid csv file with data"))
# detect item_code, quantity, description
is_header_detected = False
item_code_idx = 0
quantity_idx = 0
cost_idx = 0
description_idx = 0
for row in rows:
if not is_header_detected:
try:
robust_row = ['' if field is None else field.lower().strip() for field in row]
item_code_idx = map(lambda a: a.startswith('item no') or a.startswith('item code'), robust_row).index(True)
quantity_idx = map(lambda a: a.startswith('quantity'), robust_row).index(True)
cost_idx = map(lambda a: a.startswith('cost'), robust_row).index(True)
description_idx = map(lambda a: a.startswith('description'), robust_row).index(True)
except ValueError:
continue
else:
is_header_detected = True
continue
item_code = row[item_code_idx]
# quantity
quantity = row[quantity_idx]
if isinstance(quantity, basestring):
quantity = quantity.strip().replace(',', '')
quantity = float(quantity) if quantity else None
# cost
cost = row[cost_idx]
if isinstance(cost, basestring):
cost = cost.strip().replace(',', '')
cost = float(cost) if cost else None
description = row[description_idx]
if item_code is None or quantity is None or description is None or cost is None:
continue
item_code = item_code.upper().strip()
list_item = frappe.get_list('Item', fields=['name', 'item_name'], filters={'is_stock_item': 'Yes', 'name': item_code})
if not list_item:
continue
item = list_item[0]
item.item_code = item.name
item.oc_item_name = item.item_name
item.warehouse = warehouse
item.qty = quantity
item.valuation_rate = cost
item.current_qty = quantity
item.current_valuation_rate = cost
del item["name"]
res_items.append(item)
return res_items
def get_student_group_students(student_group):
"""Returns List of student, student_name in Student Group.
:param student_group: Student Group.
"""
students = frappe.get_list("Student Group Student", fields=["student", "student_name"] , filters={"parent": student_group}, order_by= "idx")
return students
def remove_app(app_name, dry_run=False):
"""Delete app and all linked to the app's module with the app."""
if not dry_run:
confirm = raw_input("All doctypes (including custom), modules related to this app will be deleted. Are you sure you want to continue (y/n) ? ")
if confirm!="y":
return
from frappe.utils.backups import scheduled_backup
print "Backing up..."
scheduled_backup(ignore_files=True)
# remove modules, doctypes, roles
for module_name in frappe.get_module_list(app_name):
for doctype in frappe.get_list("DocType", filters={"module": module_name},
fields=["name", "issingle"]):
print "removing {0}...".format(doctype.name)
# drop table
if not dry_run:
if not doctype.issingle:
frappe.db.sql("drop table `tab{0}`".format(doctype.name))
frappe.delete_doc("DocType", doctype.name)
print "removing Module {0}...".format(module_name)
if not dry_run:
frappe.delete_doc("Module Def", module_name)
remove_from_installed_apps(app_name)
def update_dependencies_on_duplicated_project(self):
if self.flags.dont_sync_tasks: return
if not self.copied_from:
self.copied_from = self.name
if self.name != self.copied_from and self.get('__unsaved'):
# duplicated project
dependency_map = {}
for task in self.tasks:
_task = frappe.db.get_value(
'Task',
{"subject": task.title, "project": self.copied_from},
['name', 'depends_on_tasks'],
as_dict=True
)
if _task is None:
continue
name = _task.name
dependency_map[task.title] = [ x['subject'] for x in frappe.get_list(
'Task Depends On', {"parent": name}, ['subject'])]
for key, value in dependency_map.iteritems():
task_name = frappe.db.get_value('Task', {"subject": key, "project": self.name })
task_doc = frappe.get_doc('Task', task_name)
for dt in value:
dt_name = frappe.db.get_value('Task', {"subject": dt, "project": self.name })
task_doc.append('depends_on', {"task": dt_name})
task_doc.db_update()
def get_notifications():
if frappe.flags.in_install_app:
return
config = get_notification_config()
can_read = frappe.user.get_can_read()
open_count_doctype = {}
open_count_module = {}
notification_count = dict(frappe.db.sql("""select for_doctype, open_count
from `tabNotification Count` where owner=%s""", (frappe.session.user,)))
for d in config.for_doctype:
if d in can_read:
condition = config.for_doctype[d]
key = condition.keys()[0]
if d in notification_count:
open_count_doctype[d] = notification_count[d]
else:
result = frappe.get_list(d, fields=["count(*)"],
filters=[[d, key, "=", condition[key]]], as_list=True)[0][0]
open_count_doctype[d] = result
try:
frappe.get_doc({"doctype":"Notification Count", "for_doctype":d,
"open_count":result}).insert(ignore_permissions=True)
except MySQLdb.OperationalError, e:
if e.args[0] not in (1213, 1205):
raise
logger.error("Deadlock")
def clc_calculator():
# days = ["2018-07-01", "2018-07-02", "2018-07-03", "2018-07-04", "2018-07-06",
# "2018-07-07", "2018-07-08", "2018-07-09", "2018-07-10", "2018-07-11", "2018-07-12", "2018-07-13",
# "2018-07-14", "2018-07-15", "2018-07-16", "2018-07-17", "2018-07-18", "2018-07-19", "2018-07-20",
# "2018-07-20", "2018-07-21", "2018-07-22", "2018-07-23", "2018-07-24", "2018-07-25"]
days = ['2018-07-21']
for day in days:
attendance_list = frappe.get_list(
"Attendance",
fields=[
'name', 'employee', 'employee_name', 'employment_type',
'in_time', 'out_time', 'total_working_hours', 'department',
'contractor', 'attendance_date'
],
filters={
"attendance_date": day,
"status": "Present",
"employment_type": "Contract"
})
for attendance in attendance_list:
ctc_per_day = 0
ot_earnings = 0
actual_hours = 0
ot_hours = 0
ot_cost = 0
total = 0
earned_ctc = 0
att = frappe.get_doc("Attendance", attendance['name'])
if att.department == "Boiler":
ctc_per_day = frappe.get_value("Contractor",
attendance["contractor"],
"boiler")
elif att.department == "MOULD":
ctc_per_day = frappe.get_value("Contractor",
attendance["contractor"],
"mould_operator")
else:
ctc_per_day = frappe.get_value("Contractor",
attendance["contractor"],
"ctc_per_day")
working_hours = frappe.db.get_value("Employee",
attendance['employee'],
'working_hours')
actual_working_hours = (working_hours.seconds / 3600.00)
if ctc_per_day:
total_working_hours = att.total_working_hours
if total_working_hours > 0:
earned_ctc = flt(total_working_hours *
(ctc_per_day / actual_working_hours))
if total_working_hours > actual_working_hours:
ot_hours = total_working_hours - actual_working_hours
earned_ctc = flt((total_working_hours - ot_hours) *
(ctc_per_day / actual_working_hours))
ot_cost = (ctc_per_day / actual_working_hours)
ot_earnings = flt(ot_hours * ot_cost)
total = earned_ctc + ot_earnings
clc = frappe.new_doc("Contract Labour Costing")
clc.update({
"attendance_id": att.name,
"employee": att.employee,
"employee_name": att.employee_name,
"employment_type": att.employment_type,
"attendance_date": att.attendance_date,
"department": att.department,
"in_time": att.in_time,
"out_time": att.out_time,
"total_working_hours": att.total_working_hours,
"actual_working_hours": actual_working_hours,
"contractor": att.contractor,
"ctc_per_day": ctc_per_day,
"earned_ctc": earned_ctc,
"ot_hours": ot_hours,
"ot_cost": ot_cost,
"ot_earnings": ot_earnings,
"total": total
})
clc.save(ignore_permissions=True)
def get_list(self, *args, **kwargs): return frappe.get_list(*args, **kwargs)
def get_list(doctype, fields=None, filters=None, order_by=None, limit_start=None, limit_page_length=20): return frappe.get_list(doctype, fields=fields, filters=filters, order_by=order_by, limit_start=limit_start, limit_page_length=limit_page_length, ignore_permissions=False)
def search_widget(doctype,
txt,
query=None,
searchfield=None,
start=0,
page_length=20,
filters=None,
filter_fields=None,
as_dict=False,
reference_doctype=None,
ignore_user_permissions=False):
start = cint(start)
if isinstance(filters, string_types):
filters = json.loads(filters)
if searchfield:
sanitize_searchfield(searchfield)
if not searchfield:
searchfield = "name"
standard_queries = frappe.get_hooks().standard_queries or {}
if query and query.split()[0].lower() != "select":
# by method
frappe.response["values"] = frappe.call(query,
doctype,
txt,
searchfield,
start,
page_length,
filters,
as_dict=as_dict)
elif not query and doctype in standard_queries:
# from standard queries
search_widget(doctype, txt, standard_queries[doctype][0], searchfield,
start, page_length, filters)
else:
meta = frappe.get_meta(doctype)
if query:
frappe.throw(_("This query style is discontinued"))
# custom query
# frappe.response["values"] = frappe.db.sql(scrub_custom_query(query, searchfield, txt))
else:
if isinstance(filters, dict):
filters_items = filters.items()
filters = []
for f in filters_items:
if isinstance(f[1], (list, tuple)):
filters.append([doctype, f[0], f[1][0], f[1][1]])
else:
filters.append([doctype, f[0], "=", f[1]])
if filters == None:
filters = []
or_filters = []
# build from doctype
if txt:
search_fields = ["name"]
if meta.title_field:
search_fields.append(meta.title_field)
if meta.search_fields:
search_fields.extend(meta.get_search_fields())
for f in search_fields:
fmeta = meta.get_field(f.strip())
if (doctype not in UNTRANSLATED_DOCTYPES) and (
f == "name" or (fmeta and fmeta.fieldtype in [
"Data", "Text", "Small Text", "Long Text",
"Link", "Select", "Read Only", "Text Editor"
])):
or_filters.append(
[doctype,
f.strip(), "like", "%{0}%".format(txt)])
if meta.get("fields", {
"fieldname": "enabled",
"fieldtype": "Check"
}):
filters.append([doctype, "enabled", "=", 1])
if meta.get("fields", {
"fieldname": "disabled",
"fieldtype": "Check"
}):
filters.append([doctype, "disabled", "!=", 1])
# format a list of fields combining search fields and filter fields
fields = get_std_fields_list(meta, searchfield or "name")
if filter_fields:
fields = list(set(fields + json.loads(filter_fields)))
formatted_fields = [
'`tab%s`.`%s`' % (meta.name, f.strip()) for f in fields
]
# find relevance as location of search term from the beginning of string `name`. used for sorting results.
formatted_fields.append(
"""locate({_txt}, `tab{doctype}`.`name`) as `_relevance`""".
format(_txt=frappe.db.escape((txt or "").replace("%", "")),
doctype=doctype))
# In order_by, `idx` gets second priority, because it stores link count
from frappe.model.db_query import get_order_by
order_by_based_on_meta = get_order_by(doctype, meta)
# 2 is the index of _relevance column
order_by = "_relevance, {0}, `tab{1}`.idx desc".format(
order_by_based_on_meta, doctype)
ignore_permissions = True if doctype == "DocType" else (
cint(ignore_user_permissions) and has_permission(doctype))
if doctype in UNTRANSLATED_DOCTYPES:
page_length = None
values = frappe.get_list(doctype,
filters=filters,
fields=formatted_fields,
or_filters=or_filters,
limit_start=start,
limit_page_length=page_length,
order_by=order_by,
ignore_permissions=ignore_permissions,
reference_doctype=reference_doctype,
as_list=not as_dict,
strict=False)
if doctype in UNTRANSLATED_DOCTYPES:
values = tuple([
v for v in list(values)
if re.search(txt + ".*", (
_(v.name) if as_dict else _(v[0])), re.IGNORECASE)
])
# remove _relevance from results
if as_dict:
for r in values:
r.pop("_relevance")
frappe.response["values"] = values
else:
frappe.response["values"] = [r[:-1] for r in values]
def automatic_meter_reading_demo():
"""
Using Pure fresh Naivasha Ellitrack device. I am going to simulate weekly billing
"""
#Get sensor data from ellitrack
serial = 17112915
#get period dates
first_day_of_the_month = datetime.datetime.today().replace(day=1)
yesterday = datetime.datetime.now().date() - datetime.timedelta(days=1)
#seven_days_earlier = yesterday - datetime.timedelta(days=7)
period_from = yesterday.strftime("%d-%m-%Y")
period_from = period_from + ' +00:00:00'
period_to = yesterday.strftime("%d-%m-%Y")
period_to = period_to + " +23:59:59"
#print(period_from, period_to)
#initialize request session
login_url = "http://www.ellitrack.nl/auth/login/"
#authenticate session
ellitrack_session = requests.Session()
ellitrack_session.post(login_url,
data={
'username': "******",
'password': "******"
})
#get data for pure fresh ellitrack
data_url = "http://www.ellitrack.nl/measurement/downloadexport/serialnumber/%s/type/period/n/0" \
"/periodtype/date/periodfrom/%s/periodto/%s/format/json" % (serial, period_from, period_to)
resp = ellitrack_session.get(data_url)
if resp.status_code == 200:
output = StringIO(resp.text)
ell_df = pandas.read_csv(output, sep="\t")
#unnecessary columns removed
ell_df_stripped = ell_df[ell_df.columns[0:2]]
#get prev and curr readings
prev_reading = ell_df_stripped['1 Energie'].min()
curr_reading = ell_df_stripped['1 Energie'].max()
#Insert data into Meter Reading Sheet Doctype
data = {
"doctype": "Meter Reading Capture",
"reading_date": first_day_of_the_month,
}
#billing month
get_curr_month = first_day_of_the_month.strftime("%B")
automatic_readings_data = {
"doctype": "Meter Reading Sheet",
"automatic_meter_id": "%s" % serial,
"previous_automatic_readings": "%s" % prev_reading,
"current_automatic_readings": "%s" % curr_reading,
"parent": "All Territories %s 2018" % get_curr_month,
"parenttype": "Meter Reading Capture",
"parentfield": "meter_reading_sheet"
}
#check if doc exists
name = "All Territories " + get_curr_month + " 2018"
doc_list = frappe.get_list("Meter Reading Capture",
filters={'name': name})
if doc_list:
mdoc = frappe.get_doc("Meter Reading Capture", name)
try:
mrs_doc = frappe.get_doc(automatic_readings_data)
mrs_doc.insert()
frappe.db.commit()
except Exception as err:
return err
else:
#create new doc
doc = frappe.new_doc("Meter Reading Capture")
doc.reading_date = first_day_of_the_month
doc.billing_period = get_curr_month + " 2018"
doc.route = "All Territories"
doc.route_and_billing_period = name
try:
doc.insert()
frappe.db.commit()
except Exception as err:
return err
try:
#update doc with the meter readings
mrs_doc = frappe.get_doc(automatic_readings_data)
mrs_doc.insert()
frappe.db.commit()
except Exception as err:
return err
def get_kanban_boards(doctype):
'''Get Kanban Boards for doctype to show in List View'''
return frappe.get_list('Kanban Board',
fields=['name', 'filters', 'reference_doctype', 'private'],
filters={ 'reference_doctype': doctype }
)
def cache_companies_monthly_sales_history():
companies = [d['name'] for d in frappe.get_list("Company")]
for company in companies:
update_company_monthly_sales(company)
update_transactions_annual_history(company)
frappe.db.commit()
def make_lease_invoice_schedule(leasedoc):
#frappe.msgprint("This is the parameter passed: " + str(leasedoc))
lease = frappe.get_doc("Lease", str(leasedoc))
try:
# Delete unnecessary records after lease end date
lease_invoice_schedule_list = frappe.get_list("Lease Invoice Schedule",
fields=[
"name", "parent",
"lease_item",
"invoice_number",
"date_to_invoice"
],
filters={
"parent":
lease.name,
"date_to_invoice":
(">", lease.end_date)
})
for lease_invoice_schedule in lease_invoice_schedule_list:
frappe.delete_doc("Lease Invoice Schedule",
lease_invoice_schedule.name)
# Only process lease that items and is current
if len(lease.lease_item) >= 1 and lease.end_date >= getdate(today()):
# Clean up records that are no longer required, i.e. of unnecessary lease items and unnecessary dates
# Records before 1st Jan 2020
lease_invoice_schedule_list = frappe.get_list(
"Lease Invoice Schedule",
fields=["name", "parent", "invoice_number", "date_to_invoice"],
filters={
"parent": lease.name,
"date_to_invoice": ("<", getdate("2020-01-01"))
})
# frappe.msgprint("Records before 1st Jan 2020 " + str(lease_invoice_schedule_list))
for lease_invoice_schedule in lease_invoice_schedule_list:
# frappe.msgprint("Deleting Record before 1st Jan 2020 " + str(lease_invoice_schedule.name))
frappe.delete_doc("Lease Invoice Schedule",
lease_invoice_schedule.name)
# Records of lease_items that no longer existing in lease.lease_item
lease_invoice_schedule_list = frappe.get_list(
"Lease Invoice Schedule",
fields=[
"name", "parent", "lease_item", "invoice_number",
"date_to_invoice"
],
filters={"parent": lease.name})
lease_items_list = frappe.get_list(
"Lease Item",
fields=["name", "parent", "lease_item"],
filters={"parent": lease.name})
# Create list of lease items that are part of lease.lease_item
lease_item_name_list = [
lease_item['lease_item'] for lease_item in lease_items_list
]
#frappe.msgprint(str(lease_item_list))
for lease_invoice_schedule in lease_invoice_schedule_list:
if lease_invoice_schedule.lease_item not in lease_item_name_list:
# frappe.msgprint("This lease item will be removed from invoice schedule " + str(lease_invoice_schedule.lease_item))
frappe.delete_doc("Lease Invoice Schedule",
lease_invoice_schedule.name)
item_invoice_frequency = {
"Monthly": 1.00, # .00 to make it float type
"Bi-Monthly": 2.00,
"Quarterly": 3.00,
"6 months": 6.00,
"Annually": 12.00
}
idx = 1
for item in lease.lease_item:
# frappe.msgprint("Lease item being processed: " + str(item.lease_item))
lease_invoice_schedule_list = frappe.get_all(
"Lease Invoice Schedule",
fields=[
"name", "parent", "lease_item", "qty",
"invoice_number", "date_to_invoice"
],
filters={
"parent": lease.name,
"lease_item": item.lease_item
},
order_by="date_to_invoice")
# frappe.msgprint(str(lease_invoice_schedule_list))
# Get the latest item frequency incase lease was changed.
frequency_factor = item_invoice_frequency.get(
item.frequency, "Invalid frequency")
#frappe.msgprint("Next Invoice date calculated: " + str(invoice_date))
if frequency_factor == "Invalid frequency":
message = "Invalid frequency: " + str(
item.frequency) + " for " + str(
leasedoc) + " not found. Contact the developers!"
frappe.log_error("Frequency incorrect", message)
break
invoice_qty = float(frequency_factor)
end_date = lease.end_date
invoice_date = lease.start_date
# Find out the first invoice date on or after 2020-01-01 to process.
while end_date >= invoice_date and invoice_date < getdate(
'2020-01-01'):
invoice_period_end = add_days(
add_months(invoice_date, frequency_factor), -1)
# Set invoice_Qty as appropriate fraction of frequency_factor
if invoice_period_end > end_date:
invoice_qty = getDateMonthDiff(invoice_date, end_date,
1)
#frappe.msgprint("Invoice quantity corrected as " + str(invoice_qty))
invoice_date = add_days(invoice_period_end, 1)
# If there is no lease_invoice_schedule_list found, i.e. it is fresh new list to be created
if not lease_invoice_schedule_list:
while end_date >= invoice_date:
invoice_period_end = add_days(
add_months(invoice_date, frequency_factor), -1)
# frappe.msgprint("Invoice period end: " + str(invoice_period_end) + "--- Invoice Date: " + str(invoice_date))
#frappe.msgprint("End Date: " + str(end_date))
# set invoice_Qty as appropriate fraction of frequency_factor
if invoice_period_end > end_date:
invoice_qty = getDateMonthDiff(
invoice_date, end_date, 1)
#frappe.msgprint("Invoice quantity corrected as " + str(invoice_qty))
# frappe.msgprint("Making Fresh Invoice Schedule for " + str(invoice_date)
# + ", Quantity calculated: " + str(invoice_qty))
makeInvoiceSchedule(invoice_date, item.lease_item,
item.paid_by, item.lease_item,
lease.name, invoice_qty,
item.amount, idx,
item.currency_code,
item.witholding_tax,
lease.days_to_invoice_in_advance,
item.invoice_item_group)
idx += 1
invoice_date = add_days(invoice_period_end, 1)
for lease_invoice_schedule in lease_invoice_schedule_list:
# frappe.msgprint("Upon entering lease_invoice_schedule_list - Date to invoice: " + str(lease_invoice_schedule.date_to_invoice)
# + " and invoice date to process is " + str(invoice_date))
if not (lease_invoice_schedule.schedule_start_date):
lease_invoice_schedule.schedule_start_date = lease_invoice_schedule.date_to_invoice
while end_date >= invoice_date and lease_invoice_schedule.schedule_start_date > invoice_date:
invoice_period_end = add_days(
add_months(invoice_date, frequency_factor), -1)
# frappe.msgprint("Upon entering Invoice period end: " + str(invoice_period_end) + "--- Invoice Date: " + str(invoice_date))
#frappe.msgprint("End Date: " + str(end_date))
# set invoice_Qty as appropriate fraction of frequency_factor
if invoice_period_end > end_date:
invoice_qty = getDateMonthDiff(
invoice_date, end_date, 1)
#frappe.msgprint("Invoice quantity corrected as " + str(invoice_qty))
# frappe.msgprint("Making Pre Invoice Schedule for " + str(invoice_date) + ", Quantity calculated: " + str(invoice_qty))
makeInvoiceSchedule(invoice_date, item.lease_item,
item.paid_by, item.lease_item,
lease.name, invoice_qty,
item.amount, idx,
item.currency_code,
item.witholding_tax,
lease.days_to_invoice_in_advance,
item.invoice_item_group)
idx += 1
invoice_date = add_days(invoice_period_end, 1)
#frappe.msgprint(str(lease_invoice_schedule))
# If the record already exists and invoice is generated
if (lease_invoice_schedule.invoice_number is not None
and lease_invoice_schedule.invoice_number != ""):
# frappe.msgprint("Lease Invoice Schedule retained: " + lease_invoice_schedule.name
# + " for invoice number: " + str(lease_invoice_schedule.invoice_number)
# + " dated " + str(lease_invoice_schedule.date_to_invoice)
# )
# Set months as rounded up by 1 if the month is a fraction (last invoice for the lease item already created).
# Above needed to escape from infinite loop of rounded down date and therefore never reaching end of the lease.
if lease_invoice_schedule.qty != round(
lease_invoice_schedule.qty, 0):
add_months_value = round(
lease_invoice_schedule.qty, 0) + 1
else:
add_months_value = lease_invoice_schedule.qty
#frappe.msgprint("Add Months Value" + str(add_months_value) + " due to qty = " + str(lease_invoice_schedule.qty))
invoice_date = add_months(
lease_invoice_schedule.schedule_start_date,
add_months_value)
# Set sequence to show it on the top
frappe.db.set_value("Lease Invoice Schedule",
lease_invoice_schedule.name, "idx",
idx)
idx += 1
# If the invoice is not created
else:
# frappe.msgprint("Deleting schedule :" + lease_invoice_schedule.name + " dated: " + str(lease_invoice_schedule.date_to_invoice) + " for " + str(lease_invoice_schedule.lease_item))
frappe.delete_doc("Lease Invoice Schedule",
lease_invoice_schedule.name)
# frappe.msgprint("first invoice_date: " + str(invoice_date), "Lease Invoice Schedule")
while end_date >= invoice_date:
invoice_period_end = add_days(
add_months(invoice_date, frequency_factor), -1)
# frappe.msgprint("Invoice period end: " + str(invoice_period_end) + "--- Invoice Date: " + str(invoice_date))
#frappe.msgprint("End Date: " + str(end_date))
# set invoice_Qty as appropriate fraction of frequency_factor
if invoice_period_end > end_date:
invoice_qty = getDateMonthDiff(invoice_date, end_date,
1)
#frappe.msgprint("Invoice quantity corrected as " + str(invoice_qty))
# frappe.msgprint("Making Post Invoice Schedule for " + str(invoice_date) + ", Quantity calculated: " + str(invoice_qty))
makeInvoiceSchedule(invoice_date, item.lease_item,
item.paid_by, item.lease_item,
lease.name, invoice_qty, item.amount,
idx, item.currency_code,
item.witholding_tax,
lease.days_to_invoice_in_advance,
item.invoice_item_group)
idx += 1
invoice_date = add_days(invoice_period_end, 1)
frappe.msgprint("Completed making of invoice schedule.")
except Exception as e:
frappe.msgprint("Exception error! Check app error log.")
app_error_log(frappe.session.user, str(e))
def search_widget(
doctype,
txt,
query=None,
searchfield=None,
start=0,
page_length=20,
filters=None,
filter_fields=None,
as_dict=False,
reference_doctype=None,
ignore_user_permissions=False,
):
start = cint(start)
if isinstance(filters, string_types):
filters = json.loads(filters)
if searchfield:
sanitize_searchfield(searchfield)
if not searchfield:
searchfield = "name"
standard_queries = frappe.get_hooks().standard_queries or {}
if query and query.split()[0].lower() != "select":
# by method
try:
is_whitelisted(frappe.get_attr(query))
frappe.response["values"] = frappe.call(
query, doctype, txt, searchfield, start, page_length, filters, as_dict=as_dict
)
except frappe.exceptions.PermissionError as e:
if frappe.local.conf.developer_mode:
raise e
else:
frappe.respond_as_web_page(
title="Invalid Method", html="Method not found", indicator_color="red", http_status_code=404
)
return
except Exception as e:
raise e
elif not query and doctype in standard_queries:
# from standard queries
search_widget(
doctype, txt, standard_queries[doctype][0], searchfield, start, page_length, filters
)
else:
meta = frappe.get_meta(doctype)
if query:
frappe.throw(_("This query style is discontinued"))
# custom query
# frappe.response["values"] = frappe.db.sql(scrub_custom_query(query, searchfield, txt))
else:
if isinstance(filters, dict):
filters_items = filters.items()
filters = []
for f in filters_items:
if isinstance(f[1], (list, tuple)):
filters.append([doctype, f[0], f[1][0], f[1][1]])
else:
filters.append([doctype, f[0], "=", f[1]])
if filters == None:
filters = []
or_filters = []
translated_search_doctypes = frappe.get_hooks("translated_search_doctypes")
# build from doctype
if txt:
search_fields = ["name"]
if meta.title_field:
search_fields.append(meta.title_field)
if meta.search_fields:
search_fields.extend(meta.get_search_fields())
for f in search_fields:
fmeta = meta.get_field(f.strip())
if (doctype not in translated_search_doctypes) and (
f == "name"
or (
fmeta
and fmeta.fieldtype
in ["Data", "Text", "Small Text", "Long Text", "Link", "Select", "Read Only", "Text Editor"]
)
):
or_filters.append([doctype, f.strip(), "like", "%{0}%".format(txt)])
if meta.get("fields", {"fieldname": "enabled", "fieldtype": "Check"}):
filters.append([doctype, "enabled", "=", 1])
if meta.get("fields", {"fieldname": "disabled", "fieldtype": "Check"}):
filters.append([doctype, "disabled", "!=", 1])
# format a list of fields combining search fields and filter fields
fields = get_std_fields_list(meta, searchfield or "name")
if filter_fields:
fields = list(set(fields + json.loads(filter_fields)))
formatted_fields = ["`tab%s`.`%s`" % (meta.name, f.strip()) for f in fields]
# find relevance as location of search term from the beginning of string `name`. used for sorting results.
formatted_fields.append(
"""locate({_txt}, `tab{doctype}`.`name`) as `_relevance`""".format(
_txt=frappe.db.escape((txt or "").replace("%", "").replace("@", "")), doctype=doctype
)
)
# In order_by, `idx` gets second priority, because it stores link count
from frappe.model.db_query import get_order_by
order_by_based_on_meta = get_order_by(doctype, meta)
# 2 is the index of _relevance column
order_by = "_relevance, {0}, `tab{1}`.idx desc".format(order_by_based_on_meta, doctype)
ptype = "select" if frappe.only_has_select_perm(doctype) else "read"
ignore_permissions = (
True
if doctype == "DocType"
else (cint(ignore_user_permissions) and has_permission(doctype, ptype=ptype))
)
if doctype in translated_search_doctypes:
page_length = None
values = frappe.get_list(
doctype,
filters=filters,
fields=formatted_fields,
or_filters=or_filters,
limit_start=start,
limit_page_length=page_length,
order_by=order_by,
ignore_permissions=ignore_permissions,
reference_doctype=reference_doctype,
as_list=not as_dict,
strict=False,
)
if doctype in translated_search_doctypes:
# Filtering the values array so that query is included in very element
values = (
v
for v in values
if re.search(f"{re.escape(txt)}.*", _(v.name if as_dict else v[0]), re.IGNORECASE)
)
# Sorting the values array so that relevant results always come first
# This will first bring elements on top in which query is a prefix of element
# Then it will bring the rest of the elements and sort them in lexicographical order
values = sorted(values, key=lambda x: relevance_sorter(x, txt, as_dict))
# remove _relevance from results
if as_dict:
for r in values:
r.pop("_relevance")
frappe.response["values"] = values
else:
frappe.response["values"] = [r[:-1] for r in values]
def get_employees(**args):
return frappe.get_list('Employee',
filters=args['filters'],
fields=['name', 'employee_name'])
def get_data(self, filters=None, limit=None, user=None, as_dict=False):
columns = []
out = []
if self.report_type in ('Query Report', 'Script Report', 'Custom Report'):
# query and script reports
data = frappe.desk.query_report.run(self.name, filters=filters, user=user)
for d in data.get('columns'):
if isinstance(d, dict):
col = frappe._dict(d)
if not col.fieldname:
col.fieldname = col.label
columns.append(col)
else:
fieldtype, options = "Data", None
parts = d.split(':')
if len(parts) > 1:
if parts[1]:
fieldtype, options = parts[1], None
if fieldtype and '/' in fieldtype:
fieldtype, options = fieldtype.split('/')
columns.append(frappe._dict(label=parts[0], fieldtype=fieldtype, fieldname=parts[0], options=options))
out += data.get('result')
else:
# standard report
params = json.loads(self.json)
if params.get('fields'):
columns = params.get('fields')
elif params.get('columns'):
columns = params.get('columns')
elif params.get('fields'):
columns = params.get('fields')
else:
columns = [['name', self.ref_doctype]]
for df in frappe.get_meta(self.ref_doctype).fields:
if df.in_list_view:
columns.append([df.fieldname, self.ref_doctype])
_filters = params.get('filters') or []
if filters:
for key, value in iteritems(filters):
condition, _value = '=', value
if isinstance(value, (list, tuple)):
condition, _value = value
_filters.append([key, condition, _value])
def _format(parts):
# sort by is saved as DocType.fieldname, covert it to sql
return '`tab{0}`.`{1}`'.format(*parts)
if params.get('sort_by'):
order_by = _format(params.get('sort_by').split('.')) + ' ' + params.get('sort_order')
elif params.get('order_by'):
order_by = params.get('order_by')
else:
order_by = _format([self.ref_doctype, 'modified']) + ' desc'
if params.get('sort_by_next'):
order_by += ', ' + _format(params.get('sort_by_next').split('.')) + ' ' + params.get('sort_order_next')
result = frappe.get_list(self.ref_doctype,
fields = [_format([c[1], c[0]]) for c in columns],
filters=_filters,
order_by = order_by,
as_list=True,
limit=limit,
user=user)
_columns = []
for column in columns:
meta = frappe.get_meta(column[1])
field = [meta.get_field(column[0]) or frappe._dict(label=meta.get_label(column[0]), fieldname=column[0])]
_columns.extend(field)
columns = _columns
out = out + [list(d) for d in result]
if as_dict:
data = []
for row in out:
if isinstance(row, (list, tuple)):
_row = frappe._dict()
for i, val in enumerate(row):
_row[columns[i].get('fieldname')] = val
elif isinstance(row, dict):
# no need to convert from dict to dict
_row = frappe._dict(row)
data.append(_row)
else:
data = out
return columns, data
def scheduled_import_fints_payments(manual=None):
"""Create payment entries by FinTS Schedule.
:param manual: Call manualy
:type manual: bool
:return: None
"""
schedule_settings = frappe.get_single('FinTS Schedule')
# Query child table
for child_item in schedule_settings.schedule_items:
# Get the last run / last imported transaction date
try:
if child_item.active and (child_item.import_frequency or manual):
lastruns = frappe.get_list(
'FinTS Import',
filters={
'fints_login': child_item.fints_login,
'docstatus': 1,
'end_date': ('>', '1/1/1900')
},
fields=['name', 'end_date', 'modified'],
order_by='end_date desc, modified desc')[:1] or [None]
# Create new 'FinTS Import' doc
fints_import = frappe.get_doc({
'doctype':
'FinTS Import',
'fints_login':
child_item.fints_login
})
if lastruns[0] is not None:
if child_item.import_frequency == 'Daily':
checkdate = (now_datetime().date() -
relativedelta(days=1))
elif child_item.import_frequency == 'Weekly':
checkdate = (now_datetime().date() -
relativedelta(weeks=1))
elif child_item.import_frequency == 'Monthly':
checkdate = (now_datetime().date() -
relativedelta(months=1))
else:
raise ValueError('Unknown frequency')
new_from_date = (lastruns[0].end_date +
relativedelta(days=1))
if (new_from_date < now_datetime().date()
and (lastruns[0].end_date < checkdate or manual)):
fints_import.from_date = new_from_date
# overlap = child_item.overlap
# if overlap < 0:
# overlap = 0
else:
frappe.db.rollback()
print("skip")
continue
# fints_import.from_date = lastruns[0].end_date - relativedelta(days=overlap) # noqa: E501
# else: load all available transactions of the past
# always import transactions from yesterday
fints_import.to_date = \
now_datetime().date() - relativedelta(days=1)
fints_import.save()
if manual:
import_fints_transactions(fints_import.name,
child_item.fints_login,
schedule_settings.name)
else:
FinTSController(child_item.fints_login) \
.import_fints_transactions(fints_import.name)
# fin_imp.import_transactions(fints_import.name, child_item.fints_login) # noqa: E501
print(frappe.as_json(child_item))
except Exception:
frappe.log_error(frappe.get_traceback())
def find_lead_by_email(self):
lead_list = frappe.get_list(
'Lead', filters={'email_id': self.customer_email}, ignore_permissions=True)
if lead_list:
return lead_list[0].name
return None
def get_order_for_column(board, colname): filters = [[board.reference_doctype, board.field_name, '=', colname]] if board.filters: filters.append(frappe.parse_json(board.filters)[0]) return frappe.as_json(frappe.get_list(board.reference_doctype, filters=filters, pluck='name'))
def get_employees(salary_structure):
employees = frappe.get_list('Salary Structure Assignment',
filters={'salary_structure': salary_structure}, fields=['employee'])
return list(set([d.employee for d in employees]))
def make_stock_entry(**args):
'''Helper function to make a Stock Entry
:item_code: Item to be moved
:qty: Qty to be moved
:company: Company Name (optional)
:from_warehouse: Optional
:to_warehouse: Optional
:rate: Optional
:serial_no: Optional
:batch_no: Optional
:posting_date: Optional
:posting_time: Optional
:purpose: Optional
:do_not_save: Optional flag
:do_not_submit: Optional flag
'''
def process_serial_numbers(serial_nos_list):
serial_nos_list = [
'\n'.join(serial_num['serial_no'] for serial_num in serial_nos_list
if serial_num.serial_no)
]
uniques = list(set(serial_nos_list[0].split('\n')))
return '\n'.join(uniques)
s = frappe.new_doc("Stock Entry")
args = frappe._dict(args)
if args.posting_date or args.posting_time:
s.set_posting_time = 1
if args.posting_date:
s.posting_date = args.posting_date
if args.posting_time:
s.posting_time = args.posting_time
# map names
if args.from_warehouse:
args.source = args.from_warehouse
if args.to_warehouse:
args.target = args.to_warehouse
if args.item_code:
args.item = args.item_code
if isinstance(args.qty, string_types):
if '.' in args.qty:
args.qty = flt(args.qty)
else:
args.qty = cint(args.qty)
# purpose
if not args.purpose:
if args.source and args.target:
s.purpose = "Material Transfer"
elif args.source:
s.purpose = "Material Issue"
else:
s.purpose = "Material Receipt"
else:
s.purpose = args.purpose
# company
if not args.company:
if args.source:
args.company = frappe.db.get_value('Warehouse', args.source,
'company')
elif args.target:
args.company = frappe.db.get_value('Warehouse', args.target,
'company')
# set values from test
if frappe.flags.in_test:
if not args.company:
args.company = '_Test Company'
if not args.item:
args.item = '_Test Item'
s.company = args.company or erpnext.get_default_company()
s.purchase_receipt_no = args.purchase_receipt_no
s.delivery_note_no = args.delivery_note_no
s.sales_invoice_no = args.sales_invoice_no
s.is_opening = args.is_opening or "No"
if not args.cost_center:
args.cost_center = frappe.get_value('Company', s.company,
'cost_center')
if not args.expense_account and s.is_opening == "No":
args.expense_account = frappe.get_value('Company', s.company,
'stock_adjustment_account')
# We can find out the serial number using the batch source document
serial_number = args.serial_no
if not args.serial_no and args.qty and args.batch_no:
serial_number_list = frappe.get_list(doctype='Stock Ledger Entry',
fields=['serial_no'],
filters={
'batch_no': args.batch_no,
'warehouse':
args.from_warehouse
})
serial_number = process_serial_numbers(serial_number_list)
args.serial_no = serial_number
s.append(
"items", {
"item_code": args.item,
"s_warehouse": args.source,
"t_warehouse": args.target,
"qty": args.qty,
"basic_rate": args.rate or args.basic_rate,
"conversion_factor": 1.0,
"serial_no": args.serial_no,
'batch_no': args.batch_no,
'cost_center': args.cost_center,
'expense_account': args.expense_account
})
if not args.do_not_save:
s.insert()
if not args.do_not_submit:
s.submit()
return s
def emp_absent_today():
# days = add_days(today(), -1)
days = ["2018-08-05"]
# "2018-06-23", "2018-06-24", "2018-06-25", "2018-06-26", "2018-06-27", "2018-06-28", "2018-06-29", "2018-06-30"]
for day in days:
query = """SELECT emp.name FROM `tabAttendance` att, `tabEmployee` emp
WHERE att.employee = emp.name AND att.attendance_date = '%s'""" % (day)
present_emp = frappe.db.sql(query, as_dict=True)
for emp in frappe.get_list('Employee', filters={'status': 'Active'}):
joining_date = frappe.db.get_value("Employee", emp,
["date_of_joining"])
holiday = frappe.get_list("Holiday List",
filters={'holiday_date': day})
if datetime.strptime(day, '%Y-%m-%d').date() < joining_date:
pass
elif emp in present_emp:
pass
elif holiday:
pre_day_att = frappe.db.get_value(
"Attendance", {
"employee": emp.name,
"attendance_date": add_days(day, -1)
}, ['status'],
as_dict=True)
if pre_day_att:
if not (pre_day_att['status'] == 'Present'
or pre_day_att['status'] == 'On Duty'
or pre_day_att['status'] == 'Half Day'):
pre_day_att == True
next_day_att = frappe.db.get_value(
"Attendance", {
"employee": emp.name,
"attendance_date": add_days(day, 1)
}, ['status'],
as_dict=True)
if next_day_att:
if not (next_day_att['status'] == 'Present'
or next_day_att['status'] == 'On Duty'
or next_day_att['status'] == 'Half Day'):
next_day_att == True
if pre_day_att and next_day_att:
doc = frappe.get_doc('Employee', emp)
leave = get_leave(doc.name, day)
if leave:
status = 'On Leave'
else:
status = 'Absent'
attendance = frappe.new_doc("Attendance")
attendance.update({
"employee": doc.name,
"employee_name": doc.employee_name,
"attendance_date": day,
"status": status,
"company": doc.company
})
attendance.save(ignore_permissions=True)
attendance.submit()
frappe.db.commit()
else:
doc = frappe.get_doc('Employee', emp)
leave = get_leave(doc.name, day)
if leave:
status = 'On Leave'
else:
status = 'Absent'
attendance = frappe.new_doc("Attendance")
attendance.update({
"employee": doc.name,
"employee_name": doc.employee_name,
"attendance_date": day,
"status": status,
"company": doc.company
})
attendance.save(ignore_permissions=True)
attendance.submit()
frappe.db.commit()
def test_priorities(self):
make_priorities()
priorities = frappe.get_list("Issue Priority")
for priority in priorities:
self.assertIn(priority.name, ["Low", "Medium", "High"])
def has_email_account(email):
return frappe.get_list("Email Account", filters={"email_id": email})
def get_contact_name(email_id):
contact = frappe.get_list("Contact Email",
filters={"email_id": email_id},
fields=["parent"],
limit=1)
return contact[0].parent if contact else None
def get_companies():
"""get a list of companies based on permission"""
return [d.name for d in frappe.get_list("Company", fields=["name"],
order_by="name")]
def get_clinical_procedures_to_invoice(patient, company):
clinical_procedures_to_invoice = []
procedures = frappe.get_list(
"Clinical Procedure",
fields="*",
filters={
"patient": patient.name,
"company": company,
"invoiced": False
},
)
for procedure in procedures:
if not procedure.appointment:
item, is_billable = frappe.get_cached_value(
"Clinical Procedure Template", procedure.procedure_template,
["item", "is_billable"])
if procedure.procedure_template and is_billable:
clinical_procedures_to_invoice.append({
"reference_type":
"Clinical Procedure",
"reference_name":
procedure.name,
"service":
item
})
# consumables
if (procedure.invoice_separately_as_consumables
and procedure.consume_stock and procedure.status == "Completed"
and not procedure.consumption_invoiced):
service_item = frappe.db.get_single_value(
"Healthcare Settings", "clinical_procedure_consumable_item")
if not service_item:
frappe.throw(
_("Please configure Clinical Procedure Consumable Item in {0}"
).format(
frappe.utils.get_link_to_form(
"Healthcare Settings", "Healthcare Settings")),
title=_("Missing Configuration"),
)
clinical_procedures_to_invoice.append({
"reference_type":
"Clinical Procedure",
"reference_name":
procedure.name,
"service":
service_item,
"rate":
procedure.consumable_total_amount,
"description":
procedure.consumption_details,
})
procedure_prescriptions = frappe.db.sql(
"""
SELECT
pp.name, pp.procedure
FROM
`tabPatient Encounter` et, `tabProcedure Prescription` pp
WHERE
et.patient=%s
and pp.parent=et.name
and pp.procedure_created=0
and pp.invoiced=0
and pp.appointment_booked=0
""",
(patient.name),
as_dict=1,
)
for prescription in procedure_prescriptions:
item, is_billable = frappe.get_cached_value(
"Clinical Procedure Template", prescription.procedure,
["item", "is_billable"])
if is_billable:
clinical_procedures_to_invoice.append({
"reference_type":
"Procedure Prescription",
"reference_name":
prescription.name,
"service":
item,
})
return clinical_procedures_to_invoice
def get_linked_docs(doctype, name, linkinfo=None, for_doctype=None):
if isinstance(linkinfo, string_types):
# additional fields are added in linkinfo
linkinfo = json.loads(linkinfo)
results = {}
if not linkinfo:
return results
if for_doctype:
links = frappe.get_doc(doctype, name).get_link_filters(for_doctype)
if links:
linkinfo = links
if for_doctype in linkinfo:
# only get linked with for this particular doctype
linkinfo = {for_doctype: linkinfo.get(for_doctype)}
else:
return results
me = frappe.db.get_value(doctype,
name, ["parenttype", "parent"],
as_dict=True)
for dt, link in linkinfo.items():
filters = []
link["doctype"] = dt
link_meta_bundle = frappe.desk.form.load.get_meta_bundle(dt)
linkmeta = link_meta_bundle[0]
if not linkmeta.get("issingle"):
fields = [
d.fieldname for d in linkmeta.get(
"fields", {
"in_list_view":
1,
"fieldtype": [
"not in", ("Image", "HTML", "Button") +
frappe.model.table_fields
]
})
] + ["name", "modified", "docstatus"]
if link.get("add_fields"):
fields += link["add_fields"]
fields = [
"`tab{dt}`.`{fn}`".format(dt=dt, fn=sf.strip())
for sf in fields if sf and "`tab" not in sf
]
try:
if link.get("filters"):
ret = frappe.get_list(doctype=dt,
fields=fields,
filters=link.get("filters"))
elif link.get("get_parent"):
if me and me.parent and me.parenttype == dt:
ret = frappe.get_list(
doctype=dt,
fields=fields,
filters=[[dt, "name", '=', me.parent]])
else:
ret = None
elif link.get("child_doctype"):
or_filters = [[
link.get('child_doctype'), link_fieldnames, '=', name
] for link_fieldnames in link.get("fieldname")]
# dynamic link
if link.get("doctype_fieldname"):
filters.append([
link.get('child_doctype'),
link.get("doctype_fieldname"), "=", doctype
])
ret = frappe.get_list(doctype=dt,
fields=fields,
filters=filters,
or_filters=or_filters,
distinct=True)
else:
link_fieldnames = link.get("fieldname")
if link_fieldnames:
if isinstance(link_fieldnames, string_types):
link_fieldnames = [link_fieldnames]
or_filters = [[dt, fieldname, '=', name]
for fieldname in link_fieldnames]
# dynamic link
if link.get("doctype_fieldname"):
filters.append([
dt,
link.get("doctype_fieldname"), "=", doctype
])
ret = frappe.get_list(doctype=dt,
fields=fields,
filters=filters,
or_filters=or_filters)
else:
ret = None
except frappe.PermissionError:
if frappe.local.message_log:
frappe.local.message_log.pop()
continue
if ret:
results[dt] = ret
return results
def get_from_db():
doctypes = frappe.get_list("Global Search DocType", fields=["document_type"], order_by="idx ASC")
return [d.document_type for d in doctypes] or []
def test_create_test_data():
frappe.set_user("Administrator")
# create test item
if not frappe.db.exists("Item", "_Test Tesla Car"):
item = frappe.get_doc({
"description":
"_Test Tesla Car",
"doctype":
"Item",
"has_batch_no":
0,
"has_serial_no":
0,
"inspection_required":
0,
"is_stock_item":
1,
"opening_stock":
100,
"is_sub_contracted_item":
0,
"item_code":
"_Test Tesla Car",
"item_group":
"_Test Item Group",
"item_name":
"_Test Tesla Car",
"apply_warehouse_wise_reorder_level":
0,
"warehouse":
"Stores - _TC",
"gst_hsn_code":
"999800",
"valuation_rate":
5000,
"standard_rate":
5000,
"item_defaults": [{
"company": "_Test Company",
"default_warehouse": "Stores - _TC",
"default_price_list": "_Test Price List",
"expense_account": "Cost of Goods Sold - _TC",
"buying_cost_center": "Main - _TC",
"selling_cost_center": "Main - _TC",
"income_account": "Sales - _TC"
}],
})
item.insert()
# create test item price
item_price = frappe.get_list('Item Price',
filters={
'item_code': '_Test Tesla Car',
'price_list': '_Test Price List'
},
fields=['name'])
if len(item_price) == 0:
item_price = frappe.get_doc({
"doctype": "Item Price",
"item_code": "_Test Tesla Car",
"price_list": "_Test Price List",
"price_list_rate": 5000
})
item_price.insert()
# create test item pricing rule
if not frappe.db.exists("Pricing Rule",
{"title": "_Test Pricing Rule for _Test Item"}):
item_pricing_rule = frappe.get_doc({
"doctype":
"Pricing Rule",
"title":
"_Test Pricing Rule for _Test Item",
"apply_on":
"Item Code",
"items": [{
"item_code": "_Test Tesla Car"
}],
"warehouse":
"Stores - _TC",
"coupon_code_based":
1,
"selling":
1,
"rate_or_discount":
"Discount Percentage",
"discount_percentage":
30,
"company":
"_Test Company",
"currency":
"INR",
"for_price_list":
"_Test Price List"
})
item_pricing_rule.insert()
# create test item sales partner
if not frappe.db.exists("Sales Partner", "_Test Coupon Partner"):
sales_partner = frappe.get_doc({
"doctype": "Sales Partner",
"partner_name": "_Test Coupon Partner",
"commission_rate": 2,
"referral_code": "COPART"
})
sales_partner.insert()
# create test item coupon code
if not frappe.db.exists("Coupon Code", "SAVE30"):
pricing_rule = frappe.db.get_value(
"Pricing Rule", {"title": "_Test Pricing Rule for _Test Item"},
['name'])
coupon_code = frappe.get_doc({
"doctype": "Coupon Code",
"coupon_name": "SAVE30",
"coupon_code": "SAVE30",
"pricing_rule": pricing_rule,
"valid_from": "2014-01-01",
"maximum_use": 1,
"used": 0
})
coupon_code.insert()
def validate(self):
hr_users = []
hr_managers = []
system_man = []
hr_users_remove = []
hr_managers_remove = []
system_man_remove = []
for r in self.get('roles'):
wf = frappe.get_list("Workflow", ["name", "document_type"],
filters={"document_type": r.application})
if not wf:
self.create_wf(r.application)
wf = frappe.get_list("Workflow", ["name", "document_type"],
filters={"document_type": r.application})
if wf:
hr_users.append(r.suggestion)
hr_managers.append(r.recommendation)
system_man.append(r.approval)
for m in self.get("approvls2"):
hr_users_remove.append(m.suggestion)
hr_managers_remove.append(m.recommendation)
system_man_remove.append(m.approval)
hr_managers = self.remove_dublicate(hr_managers)
hr_managers_remove = self.remove_dublicate(hr_managers_remove)
hr_users = self.remove_dublicate(hr_users)
hr_users_remove = self.remove_dublicate(hr_users_remove)
hr_managers = self.remove_dublicate(hr_managers)
hr_managers_remove = self.remove_dublicate(hr_managers_remove)
for rem in hr_users:
if rem in hr_users_remove:
hr_users_remove.remove(rem)
else:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.add_roles("HR User")
else:
frappe.throw(
"There is no user for employee '{0}'".format(rem))
for rem in hr_managers:
if rem in hr_managers_remove:
hr_managers_remove.remove(rem)
else:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.add_roles("HR Manager")
else:
frappe.msgprint(
"There is no user for employee '{0}'".format(rem))
for rem in system_man:
if rem in system_man_remove:
system_man_remove.remove(rem)
else:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.add_roles("System Manager")
else:
frappe.msgprint(
"There is no user for employee '{0}'".format(rem))
for rem in hr_users_remove:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.remove_roles("HR User")
else:
frappe.msgprint(
"There is no user for employee '{0}'".format(rem))
for rem in hr_managers_remove:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.remove_roles("HR Manager")
else:
frappe.msgprint(
"There is no user for employee '{0}'".format(rem))
for rem in system_man_remove:
ems = frappe.get_doc("Employee", rem)
if ems:
if ems.user_id:
users = frappe.get_doc("User", ems.user_id)
if users:
users.remove_roles("System Manager")
else:
frappe.msgprint(
"There is no user for employee '{0}'".format(rem))
self.approvls2 = self.get("roles")
def onload(Document):
self = Document
teams = frappe.get_list("TeamPlaner Team",
fields=("title"),
filters={"team_von_verein": self.name})
self.set_onload('team_uebersicht', teams)
def get_goal():
goal = frappe.get_list("Quality Goal",
filters={"goal": "_Test Quality Goal"},
fields=["name"])
return goal[0]
def get_user_groups():
return frappe.get_list(
"User Group", fields=["name as id", "name as value"], update={"is_group": True}
)
def delete_event(self):
for current in frappe.get_list("Event", {"ref_name": self.name}):
event = frappe.get_doc("Event", current.name)
event.delete()
