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