def get_employees(date, department = None, branch = None, company = None): attendance_not_marked = [] attendance_marked = [] filters = {"status": "Active", "date_of_joining": ["<=", date]} for field, value in {'department': department, 'branch': branch, 'company': company}.items(): if value: filters[field] = value employee_list = dataent.get_list("Employee", fields=["employee", "employee_name"], filters=filters, order_by="employee_name") marked_employee = {} for emp in dataent.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_customers_suppliers(doctype, user): customers = [] suppliers = [] meta = dataent.get_meta(doctype) if has_common(["Supplier", "Customer"], dataent.get_roles(user)): contacts = dataent.db.sql(""" select `tabContact`.email_id, `tabDynamic Link`.link_doctype, `tabDynamic Link`.link_name from `tabContact`, `tabDynamic Link` where `tabContact`.name=`tabDynamic Link`.parent and `tabContact`.email_id =%s """, user, as_dict=1) customers = [c.link_name for c in contacts if c.link_doctype == 'Customer'] \ if meta.get_field("customer") else None suppliers = [c.link_name for c in contacts if c.link_doctype == 'Supplier'] \ if meta.get_field("supplier") else None elif dataent.has_permission(doctype, 'read', user=user): customers = [customer.name for customer in dataent.get_list("Customer")] \ if meta.get_field("customer") else None suppliers = [supplier.name for supplier in dataent.get_list("Customer")] \ if meta.get_field("supplier") else None return customers, suppliers
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 = 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 dataent.utils.backups import scheduled_backup print("Backing up...") scheduled_backup(ignore_files=True) drop_doctypes = [] # remove modules, doctypes, roles for module_name in dataent.get_module_list(app_name): for doctype in dataent.get_list("DocType", filters={"module": module_name}, fields=["name", "issingle"]): print("removing DocType {0}...".format(doctype.name)) if not dry_run: dataent.delete_doc("DocType", doctype.name) if not doctype.issingle: drop_doctypes.append(doctype.name) # remove reports, pages and web forms for doctype in ("Report", "Page", "Web Form"): for record in dataent.get_list(doctype, filters={"module": module_name}): print("removing {0} {1}...".format(doctype, record.name)) if not dry_run: dataent.delete_doc(doctype, record.name) print("removing Module {0}...".format(module_name)) if not dry_run: dataent.delete_doc("Module Def", module_name) # delete desktop icons dataent.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 dataent.db.commit() for doctype in set(drop_doctypes): dataent.db.sql("drop table `tab{0}`".format(doctype))
def get_reply(self): if self.startswith('open', 'show open', 'list open', 'get open'): if self.tables: doctype = self.get_doctype() from dataent.desk.notifications import get_notification_config filters = get_notification_config().get('for_doctype').get( doctype, None) if filters: if isinstance(filters, dict): data = dataent.get_list(doctype, filters=filters) else: data = [{ 'name': d[0], 'title': d[1] } for d in dataent.get_attr(filters)(as_list=True)] return ", ".join( '[{title}](#Form/{doctype}/{name})'.format( doctype=doctype, name=d.get('name'), title=d.get('title') or d.get('name')) for d in data) else: return _("Can't identify open {0}. Try something else." ).format(doctype)
def get_reply(self): if self.query.endswith(' ' + _('list')) and self.startswith(_('list')): self.query = _('list') + ' ' + self.query.replace( ' ' + _('list'), '') if self.startswith(_('list'), _('show')): like = None if ' ' + _('like') + ' ' in self.query: self.query, like = self.query.split(' ' + _('like') + ' ') self.tables = self.reply.identify_tables( self.query.split(None, 1)[1]) if self.tables: doctype = self.get_doctype() meta = dataent.get_meta(doctype) fields = ['name'] if meta.title_field: fields.append('`{0}` as title'.format(meta.title_field)) filters = {} if like: filters = { meta.title_field or 'name': ('like', '%' + like + '%') } return self.format_list( dataent.get_list(self.get_doctype(), fields=fields, filters=filters))
def get_next(doctype, value, prev, filters=None, order_by="modified desc"): prev = not int(prev) sort_field, sort_order = order_by.split(" ") if not filters: filters = [] if isinstance(filters, string_types): filters = json.loads(filters) # condition based on sort order condition = ">" if sort_order.lower() == "desc" else "<" # switch the condition if prev: condition = "<" if condition == ">" else "<" else: sort_order = "asc" if sort_order.lower() == "desc" else "desc" # add condition for next or prev item if not order_by[0] in [f[1] for f in filters]: filters.append([doctype, sort_field, condition, value]) res = dataent.get_list(doctype, fields=["name"], filters=filters, order_by=sort_field + " " + sort_order, limit_start=0, limit_page_length=1, as_list=True) if not res: dataent.msgprint(_("No further records")) return None else: return res[0][0]
def get_children(doctype, parent=None, company=None, is_root=False, is_tree=False): filters = [['company', '=', company]] fields = ['name as value', 'employee_name as title'] if is_root: parent = '' if parent and company and parent != company: filters.append(['reports_to', '=', parent]) else: filters.append(['reports_to', '=', '']) employees = dataent.get_list(doctype, fields=fields, filters=filters, order_by='name') for employee in employees: is_expandable = dataent.get_all( doctype, filters=[['reports_to', '=', employee.get('value')]]) employee.expandable = 1 if is_expandable else 0 return employees
def get_students(doctype, txt, searchfield, start, page_len, filters): if not filters.get("academic_term"): filters["academic_term"] = dataent.defaults.get_defaults().academic_term if not filters.get("academic_year"): filters["academic_year"] = dataent.defaults.get_defaults().academic_year enrolled_students = dataent.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 dataent.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 get_assessment_details(assessment_plan): """Returns Assessment Criteria and Maximum Score from Assessment Plan Master. :param Assessment Plan: Assessment Plan """ return dataent.get_list("Assessment Plan Criteria", \ fields=["assessment_criteria", "maximum_score", "docstatus"], filters={"parent": assessment_plan}, order_by= "idx")
def get_list(doctype, fields=None, filters=None, order_by=None, limit_start=None, limit_page_length=20, parent=None): '''Returns a list of records by filters, fields, ordering and limit :param doctype: DocType of the data to be queried :param fields: fields to be returned. Default is `name` :param filters: filter list by this dict :param order_by: Order by this fieldname :param limit_start: Start at this index :param limit_page_length: Number of records to be returned (default 20)''' if dataent.is_table(doctype): check_parent_permission(parent, doctype) return dataent.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 get_events(start, end, filters=None): """Returns events for Gantt / Calendar view rendering. :param start: Start date-time. :param end: End date-time. :param filters: Filters (JSON). """ if filters: filters = json.loads(filters) else: filters = [] if start: filters.append(['Holiday', 'holiday_date', '>', getdate(start)]) if end: filters.append(['Holiday', 'holiday_date', '<', getdate(end)]) return dataent.get_list('Holiday List', fields=[ 'name', '`tabHoliday`.holiday_date', '`tabHoliday`.description', '`tabHoliday List`.color' ], filters=filters, update={"allDay": 1})
def get_message_details(self): '''Return args for template''' dws_group = dataent.get_doc('Daily Work Summary Group', self.daily_work_summary_group) replies = dataent.get_all('Communication', fields=['content', 'text_content', 'sender'], filters=dict( reference_doctype=self.doctype, reference_name=self.name, communication_type='Communication', sent_or_received='Received'), order_by='creation asc') did_not_reply = self.email_sent_to.split() for d in replies: user = dataent.db.get_values("User", {"email": d.sender}, ["full_name", "user_image"], as_dict=True) d.sender_name = user[0].full_name if user else d.sender d.image = user[0].image if user and user[0].image else None original_image = d.image # make thumbnail image try: if original_image: file_name = dataent.get_list('File', {'file_url': original_image}) if file_name: file_name = file_name[0].name file_doc = dataent.get_doc('File', file_name) thumbnail_image = file_doc.make_thumbnail( set_as_thumbnail=False, width=100, height=100, crop=True) d.image = thumbnail_image except: d.image = original_image if d.sender in did_not_reply: did_not_reply.remove(d.sender) if d.text_content: d.content = dataent.utils.md_to_html( EmailReplyParser.parse_reply(d.text_content)) did_not_reply = [ (dataent.db.get_value("User", {"email": email}, "full_name") or email) for email in did_not_reply ] return dict(replies=replies, original_message=dws_group.message, title=_('Work Summary for {0}'.format( global_date_format(self.creation))), did_not_reply=', '.join(did_not_reply) or '', did_not_reply_title=_('No replies from'))
def test_template_works(self): if not dataent.db.exists('Address Template', 'India'): dataent.get_doc({ "doctype": "Address Template", "country": 'India', "is_default": 1 }).insert() if not dataent.db.exists('Address', '_Test Address-Office'): dataent.get_doc({ "address_line1": "_Test Address Line 1", "address_title": "_Test Address", "address_type": "Office", "city": "_Test City", "state": "Test State", "country": "India", "doctype": "Address", "is_primary_address": 1, "phone": "+91 0000000000" }).insert() address = dataent.get_list("Address")[0].name display = get_address_display( dataent.get_doc("Address", address).as_dict()) self.assertTrue(display)
def before_tests(): dataent.clear_cache() # complete setup if missing from dataent.desk.page.setup_wizard.setup_wizard import setup_complete if not dataent.get_list("Company"): setup_complete({ "currency": "USD", "full_name": "Test User", "company_name": "Wind Power LLC", "timezone": "America/New_York", "company_abbr": "WP", "industry": "Manufacturing", "country": "United States", "fy_start_date": "2011-01-01", "fy_end_date": "2011-12-31", "language": "english", "company_tagline": "Testing", "email": "*****@*****.**", "password": "******", "chart_of_accounts": "Standard", "domains": ["Manufacturing"], }) dataent.db.sql("delete from `tabLeave Allocation`") dataent.db.sql("delete from `tabLeave Application`") dataent.db.sql("delete from `tabSalary Slip`") dataent.db.sql("delete from `tabItem Price`") dataent.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 0) enable_all_roles_and_domains() dataent.db.commit()
def get_events(doctype, start, end, field_map, filters=None, fields=None): field_map = dataent._dict(json.loads(field_map)) doc_meta = dataent.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 dataent.get_list(doctype, fields=fields, filters=filters)
def on_update_after_submit(self): student = dataent.get_list("Student", filters={"student_applicant": self.name}) if student: dataent.throw( _("Cannot change status as student {0} is linked with student application {1}" ).format(student[0].name, self.name))
def get_assessment_criteria(course): """Returns Assessmemt Criteria and their Weightage from Course Master. :param Course: Course """ return dataent.get_list("Course Assessment Criteria", \ fields=["assessment_criteria", "weightage"], filters={"parent": course}, order_by= "idx")
def execute(): if not dataent.db.table_exists('Daily Work Summary Group'): dataent.reload_doc("hr", "doctype", "daily_work_summary_group") dataent.reload_doc("hr", "doctype", "daily_work_summary_group_user") # check if Daily Work Summary Settings Company table exists try: dataent.db.sql('DESC `tabDaily Work Summary Settings Company`') except Exception: return # get the previously saved settings previous_setting = get_previous_setting() if previous_setting["companies"]: for d in previous_setting["companies"]: users = dataent.get_list( "Employee", dict(company=d.company, user_id=("!=", " ")), "user_id as user") if (len(users)): # create new group entry for each company entry new_group = dataent.get_doc( dict(doctype="Daily Work Summary Group", name="Daily Work Summary for " + d.company, users=users, send_emails_at=d.send_emails_at, subject=previous_setting["subject"], message=previous_setting["message"])) new_group.flags.ignore_permissions = True new_group.flags.ignore_validate = True new_group.insert(ignore_if_duplicate=True) dataent.delete_doc("DocType", "Daily Work Summary Settings") dataent.delete_doc("DocType", "Daily Work Summary Settings Company")
def get_children(doctype, parent=None, is_root=False, **filters): if not parent or parent=="BOM": dataent.msgprint(_('Please select a BOM')) return if dataent.form_dict.parent: bom_doc = dataent.get_doc("BOM", dataent.form_dict.parent) dataent.has_permission("BOM", doc=bom_doc, throw=True) bom_items = dataent.get_all('BOM Item', fields=['item_code', 'bom_no as value', 'stock_qty'], filters=[['parent', '=', dataent.form_dict.parent]], order_by='idx') item_names = tuple(d.get('item_code') for d in bom_items) items = dataent.get_list('Item', fields=['image', 'description', 'name'], filters=[['name', 'in', item_names]]) # to get only required item dicts for bom_item in bom_items: # extend bom_item dict with respective item dict bom_item.update( # returns an item dict from items list which matches with item_code next(item for item in items if item.get('name') == bom_item.get('item_code')) ) bom_item.expandable = 0 if bom_item.value in ('', None) else 1 return bom_items
def get_children(doctype, parent, company, is_root=False): from epaas.accounts.report.financial_statements import sort_accounts parent_fieldname = 'parent_' + doctype.lower().replace(' ', '_') fields = [ 'name as value', 'is_group as expandable' ] filters = [['docstatus', '<', 2]] filters.append(['ifnull(`{0}`,"")'.format(parent_fieldname), '=', '' if is_root else parent]) if is_root: fields += ['root_type', 'report_type', 'account_currency'] if doctype == 'Account' else [] filters.append(['company', '=', company]) else: fields += ['account_currency'] if doctype == 'Account' else [] fields += [parent_fieldname + ' as parent'] acc = dataent.get_list(doctype, fields=fields, filters=filters) if doctype == 'Account': sort_accounts(acc, is_root, key="value") company_currency = dataent.get_cached_value('Company', company, "default_currency") for each in acc: each["company_currency"] = company_currency each["balance"] = flt(get_balance_on(each.get("value"), in_account_currency=False)) if each.account_currency != company_currency: each["balance_in_account_currency"] = flt(get_balance_on(each.get("value"))) return acc
def execute(filters=None): user, doctype, show_permissions = filters.get("user"), filters.get( "doctype"), filters.get("show_permissions") if not validate(user, doctype): return [], [] columns, fields = get_columns_and_fields(doctype) data = dataent.get_list(doctype, fields=fields, as_list=True, user=user) if show_permissions: columns = columns + [ "Read", "Write", "Create", "Delete", "Submit", "Cancel", "Amend", "Print", "Email", "Report", "Import", "Export", "Share" ] data = list(data) for i, item in enumerate(data): temp = dataent.permissions.get_doc_permissions( dataent.get_doc(doctype, item[0]), False, user) data[i] = item + ( temp.get("read"), temp.get("write"), temp.get("create"), temp.get("delete"), temp.get("submit"), temp.get("cancel"), temp.get("amend"), temp.get("print"), temp.get("email"), temp.get("report"), temp.get("import"), temp.get("export"), temp.get("share"), ) return columns, data
def test_contextual_user_permission(self): # should be applicable for across all doctypes add_user_permission('Blogger', '_Test Blogger', '*****@*****.**') # should be applicable only while accessing Blog Post add_user_permission('Blogger', '_Test Blogger 1', '*****@*****.**', applicable_for='Blog Post') # should be applicable only while accessing User add_user_permission('Blogger', '_Test Blogger 2', '*****@*****.**', applicable_for='User') posts = dataent.get_all('Blog Post', fields=['name', 'blogger']) # Get all posts for admin self.assertEqual(len(posts), 4) dataent.set_user('*****@*****.**') posts = dataent.get_list('Blog Post', fields=['name', 'blogger']) # Should get only posts with allowed blogger via user permission # only '_Test Blogger', '_Test Blogger 1' are allowed in Blog Post self.assertEqual(len(posts), 3) for post in posts: self.assertIn( post.blogger, ['_Test Blogger', '_Test Blogger 1'], 'A post from {} is not expected.'.format(post.blogger))
def execute(): '''Update company monthly sales history based on sales invoices''' dataent.reload_doctype("Company") companies = [d['name'] for d in dataent.get_list("Company")] for company in companies: update_company_current_month_sales(company) update_company_monthly_sales(company)
def load_kanban_column_fields(self): values = dataent.get_list( 'Kanban Board', fields=['field_name'], filters={'reference_doctype': self.name}) fields = [x['field_name'] for x in values] fields = list(set(fields)) self.set("__kanban_column_fields", fields, as_value=True)
def test_run(self): create_plan() description = 'data migration todo' new_todo = dataent.get_doc({ 'doctype': 'ToDo', 'description': description }).insert() event_subject = 'data migration event' dataent.get_doc(dict( doctype='Event', subject=event_subject, repeat_on='Every Month', starts_on=dataent.utils.now_datetime() )).insert() run = dataent.get_doc({ 'doctype': 'Data Migration Run', 'data_migration_plan': 'ToDo Sync', 'data_migration_connector': 'Local Connector' }).insert() run.run() self.assertEqual(run.db_get('status'), 'Success') self.assertEqual(run.db_get('push_insert'), 1) self.assertEqual(run.db_get('pull_insert'), 1) todo = dataent.get_doc('ToDo', new_todo.name) self.assertTrue(todo.todo_sync_id) # Pushed Event event = dataent.get_doc('Event', todo.todo_sync_id) self.assertEqual(event.subject, description) # Pulled ToDo created_todo = dataent.get_doc('ToDo', {'description': event_subject}) self.assertEqual(created_todo.description, event_subject) todo_list = dataent.get_list('ToDo', filters={'description': 'Data migration todo'}, fields=['name']) todo_name = todo_list[0].name todo = dataent.get_doc('ToDo', todo_name) todo.description = 'Data migration todo updated' todo.save() run = dataent.get_doc({ 'doctype': 'Data Migration Run', 'data_migration_plan': 'ToDo Sync', 'data_migration_connector': 'Local Connector' }).insert() run.run() # Update self.assertEqual(run.db_get('status'), 'Success') self.assertEqual(run.db_get('pull_update'), 1)
def get_shareholder_doc(self, shareholder): # Get Shareholder doc based on the Shareholder title doc = dataent.get_list('Shareholder', filters=[('Shareholder', 'title', '=', shareholder)]) if len(doc) == 1: return dataent.get_doc('Shareholder', doc[0]['name']) else: #It will necessarily by 0 indicating it doesn't exist return False
def get_student_guardians(student): """Returns List of Guardians of a Student. :param student: Student. """ guardians = dataent.get_list("Student Guardian", fields=["guardian"], filters={"parent": student}) return guardians
def check_attendance_records_exist(course_schedule=None, student_group=None, date=None): """Check if Attendance Records are made against the specified Course Schedule or Student Group for given date. :param course_schedule: Course Schedule. :param student_group: Student Group. :param date: Date. """ if course_schedule: return dataent.get_list("Student Attendance", filters={"course_schedule": course_schedule}) else: return dataent.get_list("Student Attendance", filters={ "student_group": student_group, "date": date })
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 = dataent.get_list("Student Group Student", fields=["student", "student_name"], filters={"parent": student_group}, order_by="group_roll_number") else: students = dataent.get_list("Student Group Student", fields=["student", "student_name"], filters={ "parent": student_group, "active": 1 }, order_by="group_roll_number") return students
def on_cancel(self): attendance_list = dataent.get_list("Attendance", { 'employee': self.employee, 'attendance_request': self.name }) if attendance_list: for attendance in attendance_list: attendance_obj = dataent.get_doc("Attendance", attendance['name']) attendance_obj.cancel()