def get_attached_images(doctype, names): '''get list of image urls attached in form returns {name: ['image.jpg', 'image.png']}''' if isinstance(names, string_types): names = json.loads(names) img_urls = dataent.db.get_list( 'File', filters={ 'attached_to_doctype': doctype, 'attached_to_name': ('in', names), 'is_folder': 0 }, fields=['file_url', 'attached_to_name as docname']) out = dataent._dict() for i in img_urls: out[i.docname] = out.get(i.docname, []) out[i.docname].append(i.file_url) return out
class JobOpening(WebsiteGenerator): website = dataent._dict( template = "templates/generators/job_opening.html", condition_field = "publish", page_title_field = "job_title", ) def validate(self): if not self.route: self.route = dataent.scrub(self.job_title).replace('_', '-') self.validate_current_vacancies() def validate_current_vacancies(self): if not self.staffing_plan: staffing_plan = get_active_staffing_plan_details(self.company, self.designation) if staffing_plan: self.staffing_plan = staffing_plan[0].name self.planned_vacancies = staffing_plan[0].vacancies elif not self.planned_vacancies: planned_vacancies = dataent.db.sql(""" select vacancies from `tabStaffing Plan Detail` where parent=%s and designation=%s""", (self.staffing_plan, self.designation)) self.planned_vacancies = planned_vacancies[0][0] if planned_vacancies else None if self.staffing_plan and self.planned_vacancies: staffing_plan_company = dataent.db.get_value("Staffing Plan", self.staffing_plan, "company") lft, rgt = dataent.get_cached_value('Company', staffing_plan_company, ["lft", "rgt"]) designation_counts = get_designation_counts(self.designation, self.company) current_count = designation_counts['employee_count'] + designation_counts['job_openings'] if self.planned_vacancies <= current_count: dataent.throw(_("Job Openings for designation {0} already open \ or hiring completed as per Staffing Plan {1}" .format(self.designation, self.staffing_plan))) def get_context(self, context): context.parents = [{'route': 'jobs', 'title': _('All Jobs') }]
def create_production_plan(**args): args = dataent._dict(args) pln = dataent.get_doc({ 'doctype': 'Production Plan', 'company': args.company or '_Test Company', 'posting_date': nowdate(), 'include_non_stock_items': args.include_non_stock_items or 1, 'include_subcontracted_items': args.include_subcontracted_items or 1, 'ignore_existing_ordered_qty': args.ignore_existing_ordered_qty or 1, 'po_items': [{ 'use_multi_level_bom': args.use_multi_level_bom or 1, 'item_code': args.item_code, 'bom_no': dataent.db.get_value('Item', args.item_code, 'default_bom'), 'planned_qty': args.planned_qty or 1, 'planned_start_date': args.planned_start_date or now_datetime() }] }) mr_items = get_items_for_material_requests(pln.as_dict()) for d in mr_items: pln.append('mr_items', d) if not args.do_not_save: pln.insert() if not args.do_not_submit: pln.submit() return pln
def openid_profile(*args, **kwargs): picture = None first_name, last_name, avatar, name = dataent.db.get_value("User", dataent.session.user, ["first_name", "last_name", "user_image", "name"]) dataent_userid = dataent.db.get_value("User Social Login", {"parent":dataent.session.user, "provider": "dataent"}, "userid") request_url = urlparse(dataent.request.url) if avatar: if validate_url(avatar): picture = avatar else: picture = request_url.scheme + "://" + request_url.netloc + avatar user_profile = dataent._dict({ "sub": dataent_userid, "name": " ".join(filter(None, [first_name, last_name])), "given_name": first_name, "family_name": last_name, "email": name, "picture": picture }) dataent.local.response = user_profile
def fetch_as_dict(self, formatted=0, as_utf8=0): """Internal. Converts results to dict.""" result = self._cursor.fetchall() ret = [] needs_formatting = self.needs_formatting(result, formatted) if result: keys = [column[0] for column in self._cursor.description] for r in result: values = [] for i in range(len(r)): if needs_formatting: val = self.convert_to_simple_type(r[i], formatted) else: val = r[i] if as_utf8 and type(val) is text_type: val = val.encode('utf-8') values.append(val) ret.append(dataent._dict(zip(keys, values))) return ret
def upload_from_folder(path, is_private, dropbox_folder, dropbox_client, did_not_upload, error_log): if not os.path.exists(path): return if is_fresh_upload(): response = get_uploaded_files_meta(dropbox_folder, dropbox_client) else: response = dataent._dict({"entries": []}) path = text_type(path) for f in dataent.get_all("File", filters={"is_folder": 0, "is_private": is_private, "uploaded_to_dropbox": 0}, fields=['file_url', 'name', 'file_name']): if is_private: filename = f.file_url.replace('/private/files/', '') else: if not f.file_url: f.file_url = '/files/' + f.file_name; filename = f.file_url.replace('/files/', '') filepath = os.path.join(path, filename) if filename in ignore_list: continue found = False for file_metadata in response.entries: if (os.path.basename(filepath) == file_metadata.name and os.stat(encode(filepath)).st_size == int(file_metadata.size)): found = True update_file_dropbox_status(f.name) break if not found: try: upload_file_to_dropbox(filepath, dropbox_folder, dropbox_client) update_file_dropbox_status(f.name) except Exception: did_not_upload.append(filepath) error_log.append(dataent.get_traceback())
def get_child_exploded_items(self, bom_no, stock_qty): """ Add all items from Flat BOM of child BOM""" # Did not use qty_consumed_per_unit in the query, as it leads to rounding loss child_fb_items = dataent.db.sql("""select bom_item.item_code, bom_item.item_name, bom_item.description, bom_item.source_warehouse, bom_item.operation, bom_item.stock_uom, bom_item.stock_qty, bom_item.rate, bom_item.include_item_in_manufacturing, bom_item.stock_qty / ifnull(bom.quantity, 1) as qty_consumed_per_unit from `tabBOM Explosion Item` bom_item, tabBOM bom where bom_item.parent = bom.name and bom.name = %s and bom.docstatus = 1""", bom_no, as_dict = 1) for d in child_fb_items: self.add_to_cur_exploded_items(dataent._dict({ 'item_code' : d['item_code'], 'item_name' : d['item_name'], 'source_warehouse' : d['source_warehouse'], 'operation' : d['operation'], 'description' : d['description'], 'stock_uom' : d['stock_uom'], 'stock_qty' : d['qty_consumed_per_unit'] * stock_qty, 'rate' : flt(d['rate']), 'include_item_in_manufacturing': d.get('include_item_in_manufacturing', 0) }))
def get_ref_item_dict(valid_items, ref_item_row): from epaas.stock.doctype.serial_no.serial_no import get_serial_nos valid_items.setdefault( ref_item_row.item_code, dataent._dict({ "qty": 0, "rate": 0, "stock_qty": 0, "rejected_qty": 0, "received_qty": 0, "serial_no": [], "conversion_factor": ref_item_row.get("conversion_factor", 1), "batch_no": [] })) item_dict = valid_items[ref_item_row.item_code] item_dict["qty"] += ref_item_row.qty item_dict["stock_qty"] += ref_item_row.get('stock_qty', 0) if ref_item_row.get("rate", 0) > item_dict["rate"]: item_dict["rate"] = ref_item_row.get("rate", 0) if ref_item_row.parenttype in ['Purchase Invoice', 'Purchase Receipt']: item_dict["received_qty"] += ref_item_row.received_qty item_dict["rejected_qty"] += ref_item_row.rejected_qty if ref_item_row.get("serial_no"): item_dict["serial_no"] += get_serial_nos(ref_item_row.serial_no) if ref_item_row.get("batch_no"): item_dict["batch_no"].append(ref_item_row.batch_no) return valid_items
def get_report_content(self): '''Returns file in for the report in given format''' report = dataent.get_doc('Report', self.report) if self.report_type == 'Report Builder' and self.data_modified_till: self.filters = json.loads(self.filters) if self.filters else {} self.filters['modified'] = ( '>', now_datetime() - timedelta(hours=self.data_modified_till)) columns, data = report.get_data(limit=self.no_of_rows or 100, user=self.user, filters=self.filters, as_dict=True) # add serial numbers columns.insert(0, dataent._dict(fieldname='idx', label='', width='30px')) for i in range(len(data)): data[i]['idx'] = i + 1 if len(data) == 0 and self.send_if_data: return None if self.format == 'HTML': return self.get_html_table(columns, data) elif self.format == 'XLSX': spreadsheet_data = self.get_spreadsheet_data(columns, data) xlsx_file = make_xlsx(spreadsheet_data, "Auto Email Report") return xlsx_file.getvalue() elif self.format == 'CSV': spreadsheet_data = self.get_spreadsheet_data(columns, data) return to_csv(spreadsheet_data) else: dataent.throw(_('Invalid Output Format'))
def get_achieved_details(filters, sales_person, all_sales_persons, target_item_group, item_groups): start_date, end_date = get_fiscal_year(fiscal_year = filters["fiscal_year"])[1:] item_details = dataent.db.sql(""" SELECT st.sales_person, MONTHNAME(so.transaction_date) as month_name, CASE WHEN so.status = "Closed" THEN sum(soi.delivered_qty * soi.conversion_factor * (st.allocated_percentage/100)) ELSE sum(soi.stock_qty * (st.allocated_percentage/100)) END as qty, CASE WHEN so.status = "Closed" THEN sum(soi.delivered_qty * soi.conversion_factor * soi.base_net_rate * (st.allocated_percentage/100)) ELSE sum(soi.base_net_amount * (st.allocated_percentage/100)) END as amount from `tabSales Order Item` soi, `tabSales Order` so, `tabSales Team` st where soi.parent=so.name and so.docstatus=1 and st.parent=so.name and so.transaction_date>=%s and so.transaction_date<=%s and exists(SELECT name from `tabSales Person` where lft >= %s and rgt <= %s and name=st.sales_person) and exists(SELECT name from `tabItem Group` where lft >= %s and rgt <= %s and name=soi.item_group) group by sales_person, month_name """, (start_date, end_date, all_sales_persons[sales_person].lft, all_sales_persons[sales_person].rgt, item_groups[target_item_group].lft, item_groups[target_item_group].rgt), as_dict=1) actual_details = {} for d in item_details: actual_details.setdefault(d.month_name, dataent._dict({ "quantity" : 0, "amount" : 0 })) value_dict = actual_details[d.month_name] value_dict.quantity += flt(d.qty) value_dict.amount += flt(d.amount) return actual_details
def reconcile(self, args): for e in self.get('payments'): e.invoice_type = None if e.invoice_number and " | " in e.invoice_number: e.invoice_type, e.invoice_number = e.invoice_number.split( " | ") self.get_invoice_entries() self.validate_invoice() dr_or_cr = ("credit_in_account_currency" if epaas.get_party_account_type(self.party_type) == 'Receivable' else "debit_in_account_currency") lst = [] for e in self.get('payments'): if e.invoice_number and e.allocated_amount: lst.append( dataent._dict({ 'voucher_type': e.reference_type, 'voucher_no': e.reference_name, 'voucher_detail_no': e.reference_row, 'against_voucher_type': e.invoice_type, 'against_voucher': e.invoice_number, 'account': self.receivable_payable_account, 'party_type': self.party_type, 'party': self.party, 'is_advance': e.is_advance, 'dr_or_cr': dr_or_cr, 'unadjusted_amount': flt(e.amount), 'allocated_amount': flt(e.allocated_amount) })) if lst: from epaas.accounts.utils import reconcile_against_document reconcile_against_document(lst) msgprint(_("Successfully Reconciled")) self.get_unreconciled_entries()
def boot_session(bootinfo): """boot session - send website info if guest""" bootinfo.custom_css = dataent.db.get_value('Style Settings', None, 'custom_css') or '' bootinfo.website_settings = dataent.get_doc('Website Settings') if dataent.session['user'] != 'Guest': update_page_info(bootinfo) load_country_and_currency(bootinfo) bootinfo.sysdefaults.territory = dataent.db.get_single_value( 'Selling Settings', 'territory') bootinfo.sysdefaults.customer_group = dataent.db.get_single_value( 'Selling Settings', 'customer_group') bootinfo.sysdefaults.allow_stale = cint( dataent.db.get_single_value('Accounts Settings', 'allow_stale')) bootinfo.sysdefaults.quotation_valid_till = cint( dataent.db.get_single_value('Selling Settings', 'default_valid_till')) # if no company, show a dialog box to create a new company bootinfo.customer_count = dataent.db.sql( """select count(*) from tabCustomer""")[0][0] if not bootinfo.customer_count: bootinfo.setup_complete = dataent.db.sql("""select name from tabCompany limit 1""") and 'Yes' or 'No' bootinfo.docs += dataent.db.sql( """select name, default_currency, cost_center, default_terms, default_letter_head, default_bank_account, enable_perpetual_inventory, country from `tabCompany`""", as_dict=1, update={"doctype": ":Company"}) party_account_types = dataent.db.sql( """ select name, ifnull(account_type, '') from `tabParty Type`""") bootinfo.party_account_types = dataent._dict(party_account_types)
def get_columns(group_wise_columns, filters): columns = [] column_map = dataent._dict({ "parent": _("Sales Invoice") + ":Link/Sales Invoice:120", "posting_date": _("Posting Date") + ":Date", "posting_time": _("Posting Time"), "item_code": _("Item Code") + ":Link/Item", "item_name": _("Item Name"), "item_group": _("Item Group") + ":Link/Item Group", "brand": _("Brand"), "description": _("Description"), "warehouse": _("Warehouse") + ":Link/Warehouse", "qty": _("Qty") + ":Float", "base_rate": _("Avg. Selling Rate") + ":Currency/currency", "buying_rate": _("Valuation Rate") + ":Currency/currency", "base_amount": _("Selling Amount") + ":Currency/currency", "buying_amount": _("Buying Amount") + ":Currency/currency", "gross_profit": _("Gross Profit") + ":Currency/currency", "gross_profit_percent": _("Gross Profit %") + ":Percent", "project": _("Project") + ":Link/Project", "sales_person": _("Sales person"), "allocated_amount": _("Allocated Amount") + ":Currency/currency", "customer": _("Customer") + ":Link/Customer", "customer_group": _("Customer Group") + ":Link/Customer Group", "territory": _("Territory") + ":Link/Territory" }) for col in group_wise_columns.get(scrub(filters.group_by)): columns.append(column_map.get(col)) columns.append({ "fieldname": "currency", "label" : _("Currency"), "fieldtype": "Link", "options": "Currency" }) return columns
def get_invoice_tax_map(invoice_list, invoice_income_map, income_accounts): tax_details = dataent.db.sql("""select parent, account_head, sum(base_tax_amount_after_discount_amount) as tax_amount from `tabSales Taxes and Charges` where parent in (%s) group by parent, account_head""" % ', '.join(['%s'] * len(invoice_list)), tuple([inv.name for inv in invoice_list]), as_dict=1) invoice_tax_map = {} for d in tax_details: if d.account_head in income_accounts: if d.account_head in invoice_income_map[d.parent]: invoice_income_map[d.parent][d.account_head] += flt( d.tax_amount) else: invoice_income_map[d.parent][d.account_head] = flt( d.tax_amount) else: invoice_tax_map.setdefault(d.parent, dataent._dict()).setdefault( d.account_head, []) invoice_tax_map[d.parent][d.account_head] = flt(d.tax_amount) return invoice_income_map, invoice_tax_map
def get_page_info(self): route = dataent._dict() route.update({ "doc": self, "page_or_generator": "Generator", "ref_doctype": self.doctype, "idx": self.idx, "docname": self.name, "controller": get_module_name(self.doctype, self.meta.module), }) route.update(self.get_website_properties()) if not route.page_title: route.page_title = self.get(self.get_title_field()) return route
def get_gst_accounts(company, account_wise=False): gst_accounts = dataent._dict() gst_settings_accounts = dataent.get_all("GST Account", filters={ "parent": "GST Settings", "company": company }, fields=[ "cgst_account", "sgst_account", "igst_account", "cess_account" ]) if not gst_settings_accounts: dataent.throw(_("Please set GST Accounts in GST Settings")) for d in gst_settings_accounts: for acc, val in d.items(): if not account_wise: gst_accounts.setdefault(acc, []).append(val) elif val: gst_accounts[val] = acc return gst_accounts
def create_stock_reconciliation(**args): args = dataent._dict(args) sr = dataent.new_doc("Stock Reconciliation") sr.posting_date = args.posting_date or nowdate() sr.posting_time = args.posting_time or nowtime() sr.set_posting_time = 1 sr.company = args.company or "_Test Company" sr.expense_account = args.expense_account or \ ("Stock Adjustment - _TC" if dataent.get_all("Stock Ledger Entry") else "Temporary Opening - _TC") sr.cost_center = args.cost_center or "_Test Cost Center - _TC" sr.append( "items", { "item_code": args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty, "valuation_rate": args.rate }) try: sr.submit() except EmptyStockReconciliationItemsError: pass return sr
def get_lead_details(lead, posting_date=None, company=None): if not lead: return {} from epaas.accounts.party import set_address_details out = dataent._dict() lead_doc = dataent.get_doc("Lead", lead) lead = lead_doc out.update({ "territory": lead.territory, "customer_name": lead.company_name or lead.lead_name, "contact_display": " ".join(filter(None, [lead.salutation, lead.lead_name])), "contact_email": lead.email_id, "contact_mobile": lead.mobile_no, "contact_phone": lead.phone, }) set_address_details(out, lead, "Lead") taxes_and_charges = set_taxes( None, 'Lead', posting_date, company, billing_address=out.get('customer_address'), shipping_address=out.get('shipping_address_name')) if taxes_and_charges: out['taxes_and_charges'] = taxes_and_charges return out
def validate(self): self.set_lead_name() self._prev = dataent._dict({ "contact_date": dataent.db.get_value("Lead", self.name, "contact_date") if \ (not cint(self.get("__islocal"))) else None, "ends_on": dataent.db.get_value("Lead", self.name, "ends_on") if \ (not cint(self.get("__islocal"))) else None, "contact_by": dataent.db.get_value("Lead", self.name, "contact_by") if \ (not cint(self.get("__islocal"))) else None, }) self.set_status() self.check_email_id_is_unique() if self.email_id: if not self.flags.ignore_email_validation: validate_email_add(self.email_id, True) if self.email_id == self.lead_owner: dataent.throw(_("Lead Owner cannot be same as the Lead")) if self.email_id == self.contact_by: dataent.throw( _("Next Contact By cannot be same as the Lead Email Address" )) if self.is_new() or not self.image: self.image = has_gravatar(self.email_id) if self.contact_date and getdate(self.contact_date) < getdate( nowdate()): dataent.throw(_("Next Contact Date cannot be in the past")) if self.ends_on and self.contact_date and\ (self.ends_on < self.contact_date): dataent.throw( _("Ends On date cannot be before Next Contact Date."))
def get_usage_info(): '''Get data to show for Usage Info''' # imported here to prevent circular import from dataent.email.queue import get_emails_sent_this_month limits = get_limits() if not (limits and any( [limits.users, limits.space, limits.emails, limits.expiry])): # no limits! return limits.space = (limits.space or 0) * 1024.0 # to MB if not limits.space_usage: # hack! to show some progress limits.space_usage = { 'database_size': 26, 'files_size': 1, 'backup_size': 1, 'total': 28 } usage_info = dataent._dict({ 'limits': limits, 'enabled_users': len(get_enabled_system_users()), 'emails_sent': get_emails_sent_this_month(), 'space_usage': limits.space_usage['total'], }) if limits.expiry: usage_info['expires_on'] = formatdate(limits.expiry) usage_info['days_to_expiry'] = (getdate(limits.expiry) - getdate()).days if limits.upgrade_url: usage_info['upgrade_url'] = get_upgrade_url(limits.upgrade_url) return usage_info
def create_salary_slips(self): """ Creates salary slip for selected employees if already not created """ self.check_permission('write') self.created = 1 emp_list = [d.employee for d in self.get_emp_list()] if emp_list: args = dataent._dict({ "salary_slip_based_on_timesheet": self.salary_slip_based_on_timesheet, "payroll_frequency": self.payroll_frequency, "start_date": self.start_date, "end_date": self.end_date, "company": self.company, "posting_date": self.posting_date, "deduct_tax_for_unclaimed_employee_benefits": self.deduct_tax_for_unclaimed_employee_benefits, "deduct_tax_for_unsubmitted_tax_exemption_proof": self.deduct_tax_for_unsubmitted_tax_exemption_proof, "payroll_entry": self.name }) if len(emp_list) > 30: dataent.enqueue(create_salary_slips_for_employees, timeout=600, employees=emp_list, args=args) else: create_salary_slips_for_employees(emp_list, args, publish_progress=False)
def make_quotation(**args): qo = dataent.new_doc("Quotation") args = dataent._dict(args) if args.transaction_date: qo.transaction_date = args.transaction_date qo.company = args.company or "_Test Company" qo.party_name = args.party_name or "_Test Customer" qo.currency = args.currency or "INR" if args.selling_price_list: qo.selling_price_list = args.selling_price_list if "warehouse" not in args: args.warehouse = "_Test Warehouse - _TC" if args.item_list: for item in args.item_list: qo.append("items", item) else: qo.append( "items", { "item_code": args.item or args.item_code or "_Test Item", "warehouse": args.warehouse, "qty": args.qty or 10, "uom": args.uom or None, "rate": args.rate or 100 }) qo.delivery_date = add_days(qo.transaction_date, 10) if not args.do_not_save: qo.insert() if not args.do_not_submit: qo.submit() return qo
def make_blanket_order(**args): args = dataent._dict(args) bo = dataent.new_doc("Blanket Order") bo.blanket_order_type = args.blanket_order_type bo.company = args.company or "_Test Company" if args.blanket_order_type == "Selling": bo.customer = args.customer or "_Test Customer" else: bo.supplier = args.supplier or "_Test Supplier" bo.from_date = today() bo.to_date = add_months(bo.from_date, months=12) bo.append( "items", { "item_code": args.item_code or "_Test Item", "qty": args.quantity or 1000, "rate": args.rate or 100 }) bo.insert() bo.submit() return bo
def prepare_data(accounts, fiscal_year, balance_must_be, companies, company_currency): data = [] year_start_date = fiscal_year.year_start_date year_end_date = fiscal_year.year_end_date for d in accounts: # add to output has_value = False total = 0 row = dataent._dict({ "account_name": _(d.account_name), "account": _(d.account_name), "parent_account": _(d.parent_account), "indent": flt(d.indent), "year_start_date": year_start_date, "year_end_date": year_end_date, "currency": company_currency, "opening_balance": d.get("opening_balance", 0.0) * (1 if balance_must_be == "Debit" else -1) }) for company in companies: if d.get(company) and balance_must_be == "Credit": # change sign based on Debit or Credit, since calculation is done using (debit - credit) d[company] *= -1 row[company] = flt(d.get(company, 0.0), 3) if abs(row[company]) >= 0.005: # ignore zero values has_value = True total += flt(row[company]) row["has_value"] = has_value row["total"] = total data.append(row) return data
def flush(from_test=False): """flush email queue, every time: called from scheduler""" # additional check check_email_limit([]) auto_commit = not from_test if dataent.are_emails_muted(): msgprint(_("Emails are muted")) from_test = True smtpserver_dict = dataent._dict() for email in get_queue(): if cint(dataent.defaults.get_defaults().get("hold_queue"))==1: break if email.name: smtpserver = smtpserver_dict.get(email.sender) if not smtpserver: smtpserver = SMTPServer() smtpserver_dict[email.sender] = smtpserver send_one(email.name, smtpserver, auto_commit, from_test=from_test)
def get_list_context(context=None): filters = dict(published=1) category = dataent.db.get_value("Help Category", {"route": dataent.local.path}) if category: filters['category'] = category list_context = dataent._dict(title=category or _("Knowledge Base"), get_level_class=get_level_class, show_sidebar=True, sidebar_items=get_sidebar_items(), hide_filters=True, filters=filters, category=dataent.local.form_dict.category, no_breadcrumbs=True) if dataent.local.form_dict.txt: list_context.blog_subtitle = _('Filtered by "{0}"').format( dataent.local.form_dict.txt) # # list_context.update(dataent.get_doc("Blog Settings", "Blog Settings").as_dict()) return list_context
def notify(self, args): args = dataent._dict(args) # args -> message, message_to, subject if cint(self.follow_via_email): contact = args.message_to if not isinstance(contact, list): if not args.notify == "employee": contact = dataent.get_doc('User', contact).email or contact sender = dict() sender['email'] = dataent.get_doc('User', dataent.session.user).email sender['full_name'] = dataent.utils.get_fullname(sender['email']) try: dataent.sendmail( recipients=contact, sender=sender['email'], subject=args.subject, message=args.message, ) dataent.msgprint(_("Email sent to {0}").format(contact)) except dataent.OutgoingEmailError: pass
def add_user_permissions(data): ''' Add and update the user permissions ''' dataent.only_for('System Manager') if isinstance(data, dataent.string_types): data = json.loads(data) data = dataent._dict(data) d = check_applicable_doc_perm(data.user, data.doctype, data.docname) exists = dataent.db.exists( "User Permission", { "user": data.user, "allow": data.doctype, "for_value": data.docname, "apply_to_all_doctypes": 1 }) if data.apply_to_all_doctypes == 1 and not exists: remove_applicable(d, data.user, data.doctype, data.docname) insert_user_perm(data.user, data.doctype, data.docname, apply_to_all=1) return 1 elif len(data.applicable_doctypes) > 0 and data.apply_to_all_doctypes != 1: remove_apply_to_all(data.user, data.doctype, data.docname) update_applicable(d, data.applicable_doctypes, data.user, data.doctype, data.docname) for applicable in data.applicable_doctypes: if applicable not in d: insert_user_perm(data.user, data.doctype, data.docname, applicable=applicable) elif exists: insert_user_perm(data.user, data.doctype, data.docname, applicable=applicable) return 1 return 0
def execute(filters=None): if not filters: filters = {} validate_filters(filters) columns = get_columns(filters) entries = get_entries(filters) invoice_details = get_invoice_posting_date_map(filters) data = [] for d in entries: invoice = invoice_details.get(d.against_voucher) or dataent._dict() if d.reference_type == "Purchase Invoice": payment_amount = flt(d.debit) or -1 * flt(d.credit) else: payment_amount = flt(d.credit) or -1 * flt(d.debit) row = [ d.voucher_type, d.voucher_no, d.party_type, d.party, d.posting_date, d.against_voucher, invoice.posting_date, invoice.due_date, d.debit, d.credit, d.remarks ] if d.against_voucher: row += get_ageing_data(30, 60, 90, 120, d.posting_date, invoice.posting_date, payment_amount) else: row += ["", "", "", "", ""] if invoice.due_date: row.append( (getdate(d.posting_date) - getdate(invoice.due_date)).days or 0) data.append(row) return columns, data
def execute(): dataent.reload_doctype("Holiday List") default_holiday_list = dataent.db.get_value("Holiday List", {"is_default": 1}) if default_holiday_list: for company in dataent.get_all("Company", fields=["name", "default_holiday_list"]): if not company.default_holiday_list: dataent.db.set_value("Company", company.name, "default_holiday_list", default_holiday_list) fiscal_years = dataent._dict((fy.name, fy) for fy in dataent.get_all( "Fiscal Year", fields=["name", "year_start_date", "year_end_date"])) for holiday_list in dataent.get_all("Holiday List", fields=["name", "fiscal_year"]): fy = fiscal_years[holiday_list.fiscal_year] dataent.db.set_value("Holiday List", holiday_list.name, "from_date", fy.year_start_date) dataent.db.set_value("Holiday List", holiday_list.name, "to_date", fy.year_end_date)