def make_payment_gl_entries(self, gl_entries): # Make Cash GL Entries if cint(self.is_paid) and self.cash_bank_account and self.paid_amount: bank_account_currency = get_account_currency(self.cash_bank_account) # CASH, make payment entries gl_entries.append( self.get_gl_dict({ "account": self.credit_to, "party_type": "Supplier", "party": self.supplier, "against": self.cash_bank_account, "debit": self.base_paid_amount, "debit_in_account_currency": self.base_paid_amount \ if self.party_account_currency==self.company_currency else self.paid_amount, "against_voucher": self.return_against if cint(self.is_return) and self.return_against else self.name, "against_voucher_type": self.doctype, "cost_center": self.cost_center }, self.party_account_currency) ) gl_entries.append( self.get_gl_dict({ "account": self.cash_bank_account, "against": self.supplier, "credit": self.base_paid_amount, "credit_in_account_currency": self.base_paid_amount \ if bank_account_currency==self.company_currency else self.paid_amount, "cost_center": self.cost_center }, bank_account_currency) )
def disable_users(limits=None): if not limits: return if limits.get('users'): system_manager = get_system_managers(only_name=True) user_list = ['Administrator', 'Guest'] if system_manager: user_list.append(system_manager[-1]) #exclude system manager from active user list # active_users = dataent.db.sql_list("""select name from tabUser # where name not in ('Administrator', 'Guest', %s) and user_type = 'System User' and enabled=1 # order by creation desc""", system_manager) active_users = dataent.get_all("User", filters={"user_type":"System User", "enabled":1, "name": ["not in", user_list]}, fields=["name"]) user_limit = cint(limits.get('users')) - 1 if len(active_users) > user_limit: # if allowed user limit 1 then deactivate all additional users # else extract additional user from active user list and deactivate them if cint(limits.get('users')) != 1: active_users = active_users[:-1 * user_limit] for user in active_users: dataent.db.set_value("User", user, 'enabled', 0) from dataent.core.doctype.user.user import get_total_users if get_total_users() > cint(limits.get('users')): reset_simultaneous_sessions(cint(limits.get('users'))) dataent.db.commit()
def apply_property_setters(self): property_setters = dataent.db.sql( """select * from `tabProperty Setter` where doc_type=%s""", (self.name, ), as_dict=1) if not property_setters: return integer_docfield_properties = [ d.fieldname for d in dataent.get_meta('DocField').fields if d.fieldtype in ('Int', 'Check') ] for ps in property_setters: if ps.doctype_or_field == 'DocType': if ps.property_type in ('Int', 'Check'): ps.value = cint(ps.value) self.set(ps.property, ps.value) else: docfield = self.get("fields", {"fieldname": ps.field_name}, limit=1) if docfield: docfield = docfield[0] else: continue if ps.property in integer_docfield_properties: ps.value = cint(ps.value) docfield.set(ps.property, ps.value)
def get_current_tax_fraction(self, tax, item_tax_map): """ Get tax fraction for calculating tax exclusive amount from tax inclusive amount """ current_tax_fraction = 0 if cint(tax.included_in_print_rate): tax_rate = self._get_tax_rate(tax, item_tax_map) if tax.charge_type == "On Net Total": current_tax_fraction = tax_rate / 100.0 elif tax.charge_type == "On Previous Row Amount": current_tax_fraction = (tax_rate / 100.0) * \ self.doc.get("taxes")[cint(tax.row_id) - 1].tax_fraction_for_current_item elif tax.charge_type == "On Previous Row Total": current_tax_fraction = (tax_rate / 100.0) * \ self.doc.get("taxes")[cint(tax.row_id) - 1].grand_total_fraction_for_current_item if getattr(tax, "add_deduct_tax", None): current_tax_fraction *= -1.0 if (tax.add_deduct_tax == "Deduct") else 1.0 return current_tax_fraction
def _validate_length(self): if dataent.flags.in_install: return if self.meta.issingle: # single doctype value type is mediumtext return column_types_to_check_length = ('varchar', 'int', 'bigint') for fieldname, value in iteritems(self.get_valid_dict()): df = self.meta.get_field(fieldname) if not df or df.fieldtype == 'Check': # skip standard fields and Check fields continue column_type = type_map[df.fieldtype][0] or None default_column_max_length = type_map[df.fieldtype][1] or None if df and df.fieldtype in type_map and column_type in column_types_to_check_length: max_length = cint( df.get("length")) or cint(default_column_max_length) if len(cstr(value)) > max_length: if self.parentfield and self.idx: reference = _("{0}, Row {1}").format( _(self.doctype), self.idx) else: reference = "{0} {1}".format(_(self.doctype), self.name) dataent.throw(_("{0}: '{1}' ({3}) will get truncated, as max characters allowed is {2}")\ .format(reference, _(df.label), max_length, value), dataent.CharacterLengthExceededError, title=_('Value too big'))
def get_amount_based_on_payment_days(self, row, joining_date, relieving_date): amount, additional_amount = row.amount, row.additional_amount if (self.salary_structure and cint(row.depends_on_payment_days) and cint(self.total_working_days) and (not self.salary_slip_based_on_timesheet or getdate(self.start_date) < joining_date or getdate(self.end_date) > relieving_date)): additional_amount = flt( (flt(row.additional_amount) * flt(self.payment_days) / cint(self.total_working_days)), row.precision("additional_amount")) amount = flt((flt(row.default_amount) * flt(self.payment_days) / cint(self.total_working_days)), row.precision("amount")) + additional_amount elif not self.payment_days and not self.salary_slip_based_on_timesheet and cint( row.depends_on_payment_days): amount, additional_amount = 0, 0 elif not row.amount: amount = flt(row.default_amount) + flt(row.additional_amount) # apply rounding if dataent.get_cached_value("Salary Component", row.salary_component, "round_to_the_nearest_integer"): amount, additional_amount = rounded(amount), rounded( additional_amount) return amount, additional_amount
def get_context(self, context): context.show_search = True context.page_length = cint( dataent.db.get_single_value('Products Settings', 'products_per_page')) or 6 context.search_link = '/product_search' start = int(dataent.form_dict.start or 0) if start < 0: start = 0 context.update({ "items": get_product_list_for_group(product_group=self.name, start=start, limit=context.page_length + 1, search=dataent.form_dict.get("search")), "parents": get_parent_item_groups(self.parent_item_group), "title": self.name, "products_as_list": cint( dataent.db.get_single_value('Products Settings', 'products_as_list')) }) if self.slideshow: context.update(get_slideshow(self)) return context
def execute(filters=None): # key yyyy-mm new_customers_in = {} repeat_customers_in = {} customers = [] company_condition = "" if filters.get("company"): company_condition = ' and company=%(company)s' for si in dataent.db.sql( """select posting_date, customer, base_grand_total from `tabSales Invoice` where docstatus=1 and posting_date <= %(to_date)s {company_condition} order by posting_date""".format( company_condition=company_condition), filters, as_dict=1): key = si.posting_date.strftime("%Y-%m") if not si.customer in customers: new_customers_in.setdefault(key, [0, 0.0]) new_customers_in[key][0] += 1 new_customers_in[key][1] += si.base_grand_total customers.append(si.customer) else: repeat_customers_in.setdefault(key, [0, 0.0]) repeat_customers_in[key][0] += 1 repeat_customers_in[key][1] += si.base_grand_total # time series from_year, from_month, temp = filters.get("from_date").split("-") to_year, to_month, temp = filters.get("to_date").split("-") from_year, from_month, to_year, to_month = \ cint(from_year), cint(from_month), cint(to_year), cint(to_month) out = [] for year in range(from_year, to_year + 1): for month in range(from_month if year == from_year else 1, (to_month + 1) if year == to_year else 13): key = "{year}-{month:02d}".format(year=year, month=month) new = new_customers_in.get(key, [0, 0.0]) repeat = repeat_customers_in.get(key, [0, 0.0]) out.append([ year, calendar.month_name[month], new[0], repeat[0], new[0] + repeat[0], new[1], repeat[1], new[1] + repeat[1] ]) return [ _("Year"), _("Month"), _("New Customers") + ":Int", _("Repeat Customers") + ":Int", _("Total") + ":Int", _("New Customer Revenue") + ":Currency:150", _("Repeat Customer Revenue") + ":Currency:150", _("Total Revenue") + ":Currency:150" ], out
def validate(self): enable_password_policy = cint( self.enable_password_policy) and True or False minimum_password_score = cint( getattr(self, 'minimum_password_score', 0)) or 0 if enable_password_policy and minimum_password_score <= 0: dataent.throw(_("Please select Minimum Password Score")) elif not enable_password_policy: self.minimum_password_score = "" for key in ("session_expiry", "session_expiry_mobile"): if self.get(key): parts = self.get(key).split(":") if len(parts) != 2 or not (cint(parts[0]) or cint(parts[1])): dataent.throw( _("Session Expiry must be in format {0}").format( "hh:mm")) if self.enable_two_factor_auth: if self.two_factor_method == 'SMS': if not dataent.db.get_value('SMS Settings', None, 'sms_gateway_url'): dataent.throw( _('Please setup SMS before setting it as an authentication method, via SMS Settings' )) toggle_two_factor_auth(True, roles=['All']) else: self.bypass_2fa_for_retricted_ip_users = 0 self.bypass_restrict_ip_check_if_2fa_enabled = 0
def add_system_manager_role(self): # if adding system manager, do nothing if not cint(self.enabled) or ("System Manager" in [ user_role.role for user_role in self.get("roles") ]): return if (self.name not in STANDARD_USERS and self.user_type == "System User" and not self.get_other_system_managers() and cint( dataent.db.get_single_value('System Settings', 'setup_complete'))): msgprint( _("Adding System Manager to this User as there must be atleast one System Manager" )) self.append("roles", { "doctype": "Has Role", "role": "System Manager" }) if self.name == 'Administrator': # Administrator should always have System Manager Role self.extend("roles", [{ "doctype": "Has Role", "role": "System Manager" }, { "doctype": "Has Role", "role": "Administrator" }])
def update_status_updater_args(self): if cint(self.update_stock): self.status_updater.append({ 'source_dt': 'Purchase Invoice Item', 'target_dt': 'Purchase Order Item', 'join_field': 'po_detail', 'target_field': 'received_qty', 'target_parent_dt': 'Purchase Order', 'target_parent_field': 'per_received', 'target_ref_field': 'qty', 'source_field': 'received_qty', 'second_source_dt': 'Purchase Receipt Item', 'second_source_field': 'received_qty', 'second_join_field': 'purchase_order_item', 'percent_join_field':'purchase_order', 'overflow_type': 'receipt', 'extra_cond': """ and exists(select name from `tabPurchase Invoice` where name=`tabPurchase Invoice Item`.parent and update_stock = 1)""" }) if cint(self.is_return): self.status_updater.append({ 'source_dt': 'Purchase Invoice Item', 'target_dt': 'Purchase Order Item', 'join_field': 'po_detail', 'target_field': 'returned_qty', 'source_field': '-1 * qty', 'second_source_dt': 'Purchase Receipt Item', 'second_source_field': '-1 * qty', 'second_join_field': 'purchase_order_item', 'overflow_type': 'receipt', 'extra_cond': """ and exists (select name from `tabPurchase Invoice` where name=`tabPurchase Invoice Item`.parent and update_stock=1 and is_return=1)""" })
def get_default_outgoing_email_account(raise_exception_not_set=True): '''conf should be like: { "mail_server": "smtp.example.com", "mail_port": 587, "use_tls": 1, "mail_login": "******", "mail_password": "******", "auto_email_id": "*****@*****.**", "email_sender_name": "Example Notifications", "always_use_account_email_id_as_sender": 0, "always_use_account_name_as_sender_name": 0 } ''' email_account = _get_email_account({ "enable_outgoing": 1, "default_outgoing": 1 }) if email_account: email_account.password = email_account.get_password( raise_exception=False) if not email_account and dataent.conf.get("mail_server"): # from site_config.json email_account = dataent.new_doc("Email Account") email_account.update({ "smtp_server": dataent.conf.get("mail_server"), "smtp_port": dataent.conf.get("mail_port"), # legacy: use_ssl was used in site_config instead of use_tls, but meant the same thing "use_tls": cint(dataent.conf.get("use_tls") or 0) or cint(dataent.conf.get("use_ssl") or 0), "login_id": dataent.conf.get("mail_login"), "email_id": dataent.conf.get("auto_email_id") or dataent.conf.get("mail_login") or '*****@*****.**', "password": dataent.conf.get("mail_password"), "always_use_account_email_id_as_sender": dataent.conf.get("always_use_account_email_id_as_sender", 0), "always_use_account_name_as_sender_name": dataent.conf.get("always_use_account_name_as_sender_name", 0) }) email_account.from_site_config = True email_account.name = dataent.conf.get("email_sender_name") or "Dataent" if not email_account and not raise_exception_not_set: return None if dataent.are_emails_muted(): # create a stub email_account = dataent.new_doc("Email Account") email_account.update({"email_id": "*****@*****.**"}) return email_account
def clear_active_sessions(self): """Clear other sessions of the current user if `deny_multiple_sessions` is not set""" if not (cint(dataent.conf.get("deny_multiple_sessions")) or cint( dataent.db.get_system_setting('deny_multiple_sessions'))): return if dataent.session.user != "Guest": clear_sessions(dataent.session.user, keep_current=True)
def filter_pricing_rules(args, pricing_rules): # filter for qty if pricing_rules: stock_qty = flt(args.get('qty')) * args.get('conversion_factor', 1) pricing_rules = list( filter( lambda x: (flt(stock_qty) >= flt(x.min_qty) and (flt(stock_qty) <= x.max_qty if x.max_qty else True)), pricing_rules)) # add variant_of property in pricing rule for p in pricing_rules: if p.item_code and args.variant_of: p.variant_of = args.variant_of else: p.variant_of = None # find pricing rule with highest priority if pricing_rules: max_priority = max([cint(p.priority) for p in pricing_rules]) if max_priority: pricing_rules = list( filter(lambda x: cint(x.priority) == max_priority, pricing_rules)) # apply internal priority all_fields = [ "item_code", "item_group", "brand", "customer", "customer_group", "territory", "supplier", "supplier_group", "campaign", "sales_partner", "variant_of" ] if len(pricing_rules) > 1: for field_set in [["item_code", "variant_of", "item_group", "brand"], ["customer", "customer_group", "territory"], ["supplier", "supplier_group"]]: remaining_fields = list(set(all_fields) - set(field_set)) if if_all_rules_same(pricing_rules, remaining_fields): pricing_rules = apply_internal_priority( pricing_rules, field_set, args) break if len(pricing_rules) > 1: rate_or_discount = list( set([d.rate_or_discount for d in pricing_rules])) if len(rate_or_discount ) == 1 and rate_or_discount[0] == "Discount Percentage": pricing_rules = list(filter(lambda x: x.for_price_list==args.price_list, pricing_rules)) \ or pricing_rules if len(pricing_rules) > 1 and not args.for_shopping_cart: dataent.throw( _("Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}" ).format("\n".join([d.name for d in pricing_rules])), MultiplePricingRuleConflict) elif pricing_rules: return pricing_rules[0]
def check_if_enabled(self, user): """raise exception if user not enabled""" doc = dataent.get_doc("System Settings") if cint(doc.allow_consecutive_login_attempts) > 0: check_consecutive_login_attempts(user, doc) if user == 'Administrator': return if not cint(dataent.db.get_value('User', user, 'enabled')): self.fail('User disabled or missing', user=user)
def get_assessment_data(args=None): # [total, saved, submitted, remaining] chart_data = [0, 0, 0, 0] condition = '' if args["assessment_group"]: condition += "and assessment_group = %(assessment_group)s" if args["schedule_date"]: condition += "and schedule_date <= %(schedule_date)s" assessment_plan = dataent.db.sql(''' SELECT ap.name as assessment_plan, ap.assessment_name, ap.student_group, ap.schedule_date, (select count(*) from `tabStudent Group Student` sgs where sgs.parent=ap.student_group) as student_group_strength FROM `tabAssessment Plan` ap WHERE ap.docstatus = 1 {condition} ORDER BY ap.modified desc '''.format(condition=condition), (args), as_dict=1) assessment_plan_list = [d.assessment_plan for d in assessment_plan ] if assessment_plan else [''] assessment_result = get_assessment_result(assessment_plan_list) for d in assessment_plan: assessment_plan_details = assessment_result.get(d.assessment_plan) assessment_plan_details = dataent._dict() if not assessment_plan_details else \ dataent._dict(assessment_plan_details) if "saved" not in assessment_plan_details: assessment_plan_details.update({"saved": 0}) if "submitted" not in assessment_plan_details: assessment_plan_details.update({"submitted": 0}) # remaining students whose marks not entered remaining_students = cint(d.student_group_strength) - cint(assessment_plan_details.saved) -\ cint(assessment_plan_details.submitted) assessment_plan_details.update({"remaining": remaining_students}) d.update(assessment_plan_details) chart_data[0] += cint(d.student_group_strength) chart_data[1] += assessment_plan_details.saved chart_data[2] += assessment_plan_details.submitted chart_data[3] += assessment_plan_details.remaining chart = get_chart(chart_data[1:]) return assessment_plan, chart
def validate_asset_finance_books(self, row): if flt(row.expected_value_after_useful_life) >= flt( self.gross_purchase_amount): dataent.throw( _("Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount" ).format(row.idx)) if not row.depreciation_start_date: dataent.throw( _("Row {0}: Depreciation Start Date is required").format( row.idx)) if not self.is_existing_asset: self.opening_accumulated_depreciation = 0 self.number_of_depreciations_booked = 0 else: depreciable_amount = flt(self.gross_purchase_amount) - flt( row.expected_value_after_useful_life) if flt(self.opening_accumulated_depreciation) > depreciable_amount: dataent.throw( _("Opening Accumulated Depreciation must be less than equal to {0}" ).format(depreciable_amount)) if self.opening_accumulated_depreciation: if not self.number_of_depreciations_booked: dataent.throw( _("Please set Number of Depreciations Booked")) else: self.number_of_depreciations_booked = 0 if cint(self.number_of_depreciations_booked) > cint( row.total_number_of_depreciations): dataent.throw( _("Number of Depreciations Booked cannot be greater than Total Number of Depreciations" )) if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate(nowdate()): dataent.msgprint(_( "Depreciation Row {0}: Depreciation Start Date is entered as past date" ).format(row.idx), title=_('Warning'), indicator='red') if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate(self.purchase_date): dataent.throw( _("Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date" ).format(row.idx)) if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate( self.available_for_use_date): dataent.throw( _("Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date" ).format(row.idx))
def validate(self): self.validate_value("exchange_rate", ">", 0) if self.from_currency == self.to_currency: throw(_("From Currency and To Currency cannot be same")) if not cint(self.for_buying) and not cint(self.for_selling): throw( _("Currency Exchange must be applicable for Buying or for Selling." ))
def get_columns_from_docfields(self): """ get columns from docfields and custom fields """ fl = dataent.db.sql("SELECT * FROM tabDocField WHERE parent = %s", self.doctype, as_dict=1) lengths = {} precisions = {} uniques = {} # optional fields like _comments if not self.meta.istable: for fieldname in optional_columns: fl.append({"fieldname": fieldname, "fieldtype": "Text"}) # add _seen column if track_seen if getattr(self.meta, 'track_seen', False): fl.append({'fieldname': '_seen', 'fieldtype': 'Text'}) if not dataent.flags.in_install_db and ( dataent.flags.in_install != "dataent" or dataent.flags.ignore_in_install): custom_fl = dataent.db.sql("""\ SELECT * FROM `tabCustom Field` WHERE dt = %s AND docstatus < 2""", (self.doctype, ), as_dict=1) if custom_fl: fl += custom_fl # apply length, precision and unique from property setters for ps in dataent.get_all( "Property Setter", fields=["field_name", "property", "value"], filters={ "doc_type": self.doctype, "doctype_or_field": "DocField", "property": ["in", ["precision", "length", "unique"]] }): if ps.property == "length": lengths[ps.field_name] = cint(ps.value) elif ps.property == "precision": precisions[ps.field_name] = cint(ps.value) elif ps.property == "unique": uniques[ps.field_name] = cint(ps.value) for f in fl: self.columns[f['fieldname']] = DbColumn( self, f['fieldname'], f['fieldtype'], lengths.get(f["fieldname"]) or f.get('length'), f.get('default'), f.get('search_index'), f.get('options'), uniques.get(f["fieldname"], f.get('unique')), precisions.get(f['fieldname']) or f.get('precision'))
def get_month_details(year, month): ysd = dataent.db.get_value("Fiscal Year", year, "year_start_date") if ysd: import calendar, datetime diff_mnt = cint(month) - cint(ysd.month) if diff_mnt < 0: diff_mnt = 12 - int(ysd.month) + cint(month) msd = ysd + relativedelta(months=diff_mnt) # month start date month_days = cint(calendar.monthrange(cint(msd.year), cint(month))[1]) # days in month mid_start = datetime.date(msd.year, cint(month), 16) # month mid start date mid_end = datetime.date(msd.year, cint(month), 15) # month mid end date med = datetime.date(msd.year, cint(month), month_days) # month end date return dataent._dict({ 'year': msd.year, 'month_start_date': msd, 'month_end_date': med, 'month_mid_start_date': mid_start, 'month_mid_end_date': mid_end, 'month_days': month_days }) else: dataent.throw(_("Fiscal Year {0} not found").format(year))
def enable_2fa(bypass_two_factor_auth=0, bypass_restrict_ip_check=0): '''Enable Two factor in system settings.''' system_settings = dataent.get_doc('System Settings') system_settings.enable_two_factor_auth = 1 system_settings.bypass_2fa_for_retricted_ip_users = cint( bypass_two_factor_auth) system_settings.bypass_restrict_ip_check_if_2fa_enabled = cint( bypass_restrict_ip_check) system_settings.two_factor_method = 'OTP App' system_settings.save(ignore_permissions=True) dataent.db.commit()
def test_reserved_qty_for_production_cancel(self): self.test_reserved_qty_for_production_submit() self.wo_order.cancel() bin1_on_cancel = get_bin(self.item, self.warehouse) # reserved_qty_for_producion updated self.assertEqual(cint(self.bin1_at_start.reserved_qty_for_production), cint(bin1_on_cancel.reserved_qty_for_production)) self.assertEqual(self.bin1_at_start.projected_qty, cint(bin1_on_cancel.projected_qty))
def check_enable_disable(self): # do not allow disabling administrator/guest if not cint(self.enabled) and self.name in STANDARD_USERS: dataent.throw(_("User {0} cannot be disabled").format(self.name)) if not cint(self.enabled): self.a_system_manager_should_exist() # clear sessions if disabled if not cint(self.enabled) and getattr(dataent.local, "login_manager", None): dataent.local.login_manager.logout(user=self.name)
def export_customizations(module, doctype, sync_on_migrate=0, with_permissions=0): """Export Custom Field and Property Setter for the current document to the app folder. This will be synced with bench migrate""" sync_on_migrate = cint(sync_on_migrate) with_permissions = cint(with_permissions) if not dataent.get_conf().developer_mode: raise Exception('Not developer mode') custom = { 'custom_fields': [], 'property_setters': [], 'custom_perms': [], 'doctype': doctype, 'sync_on_migrate': sync_on_migrate } def add(_doctype): custom['custom_fields'] += dataent.get_all('Custom Field', fields='*', filters={'dt': _doctype}) custom['property_setters'] += dataent.get_all( 'Property Setter', fields='*', filters={'doc_type': _doctype}) add(doctype) if with_permissions: custom['custom_perms'] = dataent.get_all('Custom DocPerm', fields='*', filters={'parent': doctype}) # also update the custom fields and property setters for all child tables for d in dataent.get_meta(doctype).get_table_fields(): export_customizations(module, d.options, sync_on_migrate, with_permissions) if custom["custom_fields"] or custom["property_setters"] or custom[ "custom_perms"]: folder_path = os.path.join(get_module_path(module), 'custom') if not os.path.exists(folder_path): os.makedirs(folder_path) path = os.path.join(folder_path, scrub(doctype) + '.json') with open(path, 'w') as f: f.write(dataent.as_json(custom)) dataent.msgprint( _('Customizations for <b>{0}</b> exported to:<br>{1}').format( doctype, path))
def set_default_if_missing(self): if cint(self.selling): if not dataent.db.get_value("Selling Settings", None, "selling_price_list"): dataent.set_value("Selling Settings", "Selling Settings", "selling_price_list", self.name) elif cint(self.buying): if not dataent.db.get_value("Buying Settings", None, "buying_price_list"): dataent.set_value("Buying Settings", "Buying Settings", "buying_price_list", self.name)
def validate_stock_exists_for_template_item(self): if self.stock_ledger_created() and self._doc_before_save: if (cint(self._doc_before_save.has_variants) != cint( self.has_variants) or self._doc_before_save.variant_of != self.variant_of): dataent.throw( _("Cannot change Variant properties after stock transaction. You will have to make a new Item to do this." ).format(self.name), StockExistsForTemplate) if self.has_variants or self.variant_of: if not self.is_child_table_same('attributes'): dataent.throw( _('Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item' ))
def _fix_numeric_types(self): for df in self.meta.get("fields"): if df.fieldtype == "Check": self.set(df.fieldname, cint(self.get(df.fieldname))) elif self.get(df.fieldname) is not None: if df.fieldtype == "Int": self.set(df.fieldname, cint(self.get(df.fieldname))) elif df.fieldtype in ("Float", "Currency", "Percent"): self.set(df.fieldname, flt(self.get(df.fieldname))) if self.docstatus is not None: self.docstatus = cint(self.docstatus)
def validate_students(self): program_enrollment = get_program_enrollment(self.academic_year, self.academic_term, self.program, self.batch, self.course) students = [d.student for d in program_enrollment] if program_enrollment else [] for d in self.students: if not dataent.db.get_value("Student", d.student, "enabled") and d.active and not self.disabled: dataent.throw(_("{0} - {1} is inactive student".format(d.group_roll_number, d.student_name))) if (self.group_based_on == "Batch") and cint(dataent.defaults.get_defaults().validate_batch)\ and d.student not in students: dataent.throw(_("{0} - {1} is not enrolled in the Batch {2}".format(d.group_roll_number, d.student_name, self.batch))) if (self.group_based_on == "Course") and cint(dataent.defaults.get_defaults().validate_course)\ and (d.student not in students): dataent.throw(_("{0} - {1} is not enrolled in the Course {2}".format(d.group_roll_number, d.student_name, self.course)))
def get_feed(start, page_length, name): """get feed""" result = dataent.db.sql("""select name, owner, modified, creation, reference_doctype, reference_name, subject from `tabPatient Medical Record` where patient=%(patient)s order by creation desc limit %(start)s, %(page_length)s""", { "start": cint(start), "page_length": cint(page_length), "patient": name }, as_dict=True) return result
def process(self): self.grouped = {} self.grouped_data = [] self.currency_precision = cint(dataent.db.get_default("currency_precision")) or 3 self.float_precision = cint(dataent.db.get_default("float_precision")) or 2 for row in self.si_list: if self.skip_row(row, self.product_bundles): continue row.base_amount = flt(row.base_net_amount, self.currency_precision) product_bundles = [] if row.update_stock: product_bundles = self.product_bundles.get(row.parenttype, {}).get(row.parent, dataent._dict()) elif row.dn_detail: product_bundles = self.product_bundles.get("Delivery Note", {})\ .get(row.delivery_note, dataent._dict()) row.item_row = row.dn_detail # get buying amount if row.item_code in product_bundles: row.buying_amount = flt(self.get_buying_amount_from_product_bundle(row, product_bundles[row.item_code]), self.currency_precision) else: row.buying_amount = flt(self.get_buying_amount(row, row.item_code), self.currency_precision) # get buying rate if row.qty: row.buying_rate = flt(row.buying_amount / row.qty, self.float_precision) row.base_rate = flt(row.base_amount / row.qty, self.float_precision) else: row.buying_rate, row.base_rate = 0.0, 0.0 # calculate gross profit row.gross_profit = flt(row.base_amount - row.buying_amount, self.currency_precision) if row.base_amount: row.gross_profit_percent = flt((row.gross_profit / row.base_amount) * 100.0, self.currency_precision) else: row.gross_profit_percent = 0.0 # add to grouped self.grouped.setdefault(row.get(scrub(self.filters.group_by)), []).append(row) if self.grouped: self.get_average_rate_based_on_group_by()