def update_order(board_name, order): '''Save the order of cards in columns''' board = frappe.get_doc('Kanban Board', board_name) doctype = board.reference_doctype fieldname = board.field_name order_dict = json.loads(order) updated_cards = [] for col_name, cards in iteritems(order_dict): order_list = [] for card in cards: column = frappe.get_value( doctype, {'name': card}, fieldname ) if column != col_name: frappe.set_value(doctype, card, fieldname, col_name) updated_cards.append(dict( name=card, column=col_name )) for column in board.columns: if column.column_name == col_name: column.order = json.dumps(cards) board.save() return board, updated_cards
def test_set_value(self): todo = frappe.get_doc(dict(doctype='ToDo', description='test')).insert() frappe.set_value('ToDo', todo.name, 'description', 'test 1') self.assertEqual(frappe.get_value('ToDo', todo.name, 'description'), 'test 1') frappe.set_value('ToDo', todo.name, {'description': 'test 2'}) self.assertEqual(frappe.get_value('ToDo', todo.name, 'description'), 'test 2')
def on_cancel(self): for payment in self.payment_allocation: if payment.worker: get_worker = frappe.db.sql("""select name, outstanding_wages from `tabWorker` where name = %s """, payment.worker, as_dict=1) current_os_wage = get_worker[0].outstanding_wages os_wages = current_os_wage + payment.t_payment frappe.set_value("Worker", payment.worker, "outstanding_wages", os_wages)
def set_default_if_missing(self): if cint(self.selling): if not frappe.db.get_value("Selling Settings", None, "selling_price_list"): frappe.set_value("Selling Settings", "Selling Settings", "selling_price_list", self.name) elif cint(self.buying): if not frappe.db.get_value("Buying Settings", None, "buying_price_list"): frappe.set_value("Buying Settings", "Buying Settings", "buying_price_list", self.name)
def on_submit(self): last_reading = frappe.get_list("Vehicle", fields=["odometer_reading", "reading_time"], filters = { "name": self.vehicle }) if (self.reading_time >= last_reading[0].reading_time): frappe.set_value("Vehicle",self.vehicle,"odometer_reading", self.odometer_reading) frappe.set_value("Vehicle",self.vehicle,"reading_time", self.reading_time)
def on_submit(self): for payment in self.payment_allocation: if payment.worker: if not payment.t_payment: frappe.throw(_("Payment must be entered")) elif payment.t_payment < 0: frappe.throw(_("Payment cannot be negative")) os_wages = payment.t_os_wage - payment.t_payment frappe.set_value("Worker", payment.worker, "outstanding_wages", os_wages)
def make_insurance_claim(doc): if doc.insurance_subscription: from hms_tz.hms_tz.utils import create_insurance_claim insurance_claim, claim_status = create_insurance_claim( doc, doc.order_doctype, doc.order, doc.quantity, doc.billing_item) if insurance_claim: frappe.set_value(doc.doctype, doc.name, 'insurance_claim', insurance_claim) frappe.set_value(doc.doctype, doc.name, 'claim_status', claim_status) doc.reload()
def make_bank_account(): ba = frappe.get_doc({ "doctype": "Account", "account_name": bank_name, "account_type": "Bank", "group_or_ledger": "Ledger", "parent_account": "Bank Accounts - " + company_abbr, "company": company }).insert() frappe.set_value("Company", company, "default_bank_account", ba.name) frappe.db.commit()
def make_insurance_claim(doc): if doc.insurance_subscription: from hms_tz.hms_tz.utils import create_insurance_claim, get_service_item_and_practitioner_charge billing_item, rate = get_service_item_and_practitioner_charge(doc) insurance_claim, claim_status = create_insurance_claim( doc, 'Appointment Type', doc.appointment_type, 1, billing_item) if insurance_claim: frappe.set_value(doc.doctype, doc.name, 'insurance_claim', insurance_claim) frappe.set_value(doc.doctype, doc.name, 'claim_status', claim_status) doc.reload()
def make_bank_account(): ba = frappe.get_doc({ "doctype": "Account", "account_name": settings.bank_name, "account_type": "Bank", "is_group": 0, "parent_account": "Bank Accounts - " + settings.company_abbr, "company": settings.company }).insert() frappe.set_value("Company", settings.company, "default_bank_account", ba.name) frappe.db.commit()
def make_bank_account(): ba = frappe.get_doc({ "doctype": "Account", "account_name": bank_name, "account_type": "Bank", "group_or_ledger": "Ledger", "parent_account": "银行账户 - " + company_abbr, "company": company }).insert() frappe.set_value("Company", company, "default_bank_account", ba.name) frappe.db.commit()
def _set_item_pl_rate(effective_date, item_code, price_list, price_list_rate, uom=None, conversion_factor=None): from frappe.model.utils import get_fetch_values from erpnext.stock.get_item_details import get_item_price if not price_list_rate: frappe.msgprint(_("Rate for Item {0} is 0 in Price List {1}. Please confirm rate").format(item_code, price_list)) effective_date = getdate(effective_date) item_price_args = { "item_code": item_code, "price_list": price_list, "uom": uom, "min_qty": 0, "transaction_date": effective_date, } current_effective_item_price = get_item_price(item_price_args, item_code) current_effective_item_price = current_effective_item_price[0] if current_effective_item_price else None existing_item_price = past_item_price = None if current_effective_item_price and getdate(current_effective_item_price[3]) == effective_date: existing_item_price = current_effective_item_price else: past_item_price = current_effective_item_price item_price_args['period'] = 'future' future_item_price = get_item_price(item_price_args, item_code) future_item_price = future_item_price[0] if future_item_price else None # Update or add item price if existing_item_price: doc = frappe.get_doc("Item Price", existing_item_price[0]) doc.price_list_rate = convert_item_uom_for(price_list_rate, item_code, uom, doc.uom, conversion_factor) else: doc = frappe.new_doc("Item Price") doc.item_code = item_code doc.price_list = price_list doc.uom = uom doc.price_list_rate = flt(price_list_rate) doc.update(get_fetch_values("Item Price", 'item_code', item_code)) doc.update(get_fetch_values("Item Price", 'price_list', price_list)) doc.valid_from = effective_date if future_item_price: doc.valid_upto = frappe.utils.add_days(future_item_price[3], -1) doc.save() # Update previous item price before_effective_date = frappe.utils.add_days(effective_date, -1) if past_item_price and past_item_price[4] != before_effective_date: frappe.set_value("Item Price", past_item_price[0], 'valid_upto', before_effective_date) frappe.msgprint(_("Price updated for Item {0} in Price List {1}").format(item_code, price_list), alert=1)
def make_insurance_claim(doc): if doc.insurance_subscription: from hms_tz.hms_tz.utils import create_insurance_claim billing_item, = frappe.get_cached_value('Lab Test Template', doc.template, ['item']) insurance_claim, claim_status = create_insurance_claim( doc, 'Lab Test Template', doc.template, 1, billing_item) if insurance_claim: frappe.set_value(doc.doctype, doc.name, 'insurance_claim', insurance_claim) frappe.set_value(doc.doctype, doc.name, 'claim_status', claim_status) doc.reload()
def set_insurance_card_detail_in_patient(doc): his_list = frappe.get_all("Healthcare Insurance Subscription", filters={ "patient": doc.patient, "docstatus": 1, }, fields=["coverage_plan_card_number"]) str_coverage_plan_card_number = "" for card in his_list: if card.coverage_plan_card_number: str_coverage_plan_card_number += card.coverage_plan_card_number + ", " frappe.set_value("Patient", doc.patient, "insurance_card_detail", str_coverage_plan_card_number)
def toggle_tax_category_fields(hidden): frappe.set_value( "Custom Field", { "dt": "Sales Invoice Item", "fieldname": "product_tax_category" }, "hidden", hidden, ) frappe.set_value("Custom Field", { "dt": "Item", "fieldname": "product_tax_category" }, "hidden", hidden)
def make_insurance_claim(doc): if doc.insurance_subscription: from hms_tz.hms_tz.utils import create_insurance_claim (billing_item, ) = frappe.get_cached_value( "Clinical Procedure Template", doc.procedure_template, ["item"]) insurance_claim, claim_status = create_insurance_claim( doc, "Clinical Procedure Template", doc.procedure_template, 1, billing_item) if insurance_claim: frappe.set_value(doc.doctype, doc.name, "insurance_claim", insurance_claim) frappe.set_value(doc.doctype, doc.name, "claim_status", claim_status)
def add_translation(language, source_text, translated_text, context=None, doctype=None, docname=None, docfield=None): """ Precedence while reading key:doctype:name:fieldname key:doctype:name key:parenttype:parent key:doctype:fieldname key:doctype key:parenttype key """ if doctype: context = doctype if doctype and docname: context += f":{docname}" if doctype and docfield: meta = frappe.get_meta(doctype) if not meta.get_field(docfield): frappe.throw("Field {} do not belong to doctype {}".format( docfield, doctype)) context += f":{docfield}" existing_tr = frappe.db.get_value( "Translation", frappe._dict(language=language, source_text=source_text, context=context)) if existing_tr: frappe.set_value("Translation", existing_tr, "translated_text", translated_text) tr_doc = frappe.get_doc("Translation", existing_tr) else: tr_doc = frappe.get_doc( frappe._dict(doctype="Translation", language=language, source_text=source_text, translated_text=translated_text, context=context)).insert() return tr_doc
def update_auth_file(self): if frappe.get_value("Wechat Auth File", self.name, "name"): frappe.set_value("Wechat Auth File", self.name, "route", self.file_name) frappe.set_value("Wechat Auth File", self.name, "content", self.file_content) else: doc = frappe.get_doc({ "doctype": "Wechat Auth File", "title": self.name, "route": self.file_name, "app": self.name, "content": self.file_content, }) doc.insert(ignore_permissions=True)
def execute(): for doctype in ['Expense Claim', 'Leave Application']: active_workflow = get_workflow_name(doctype) if not active_workflow: continue workflow_states = frappe.get_all('Workflow Document State', filters=[['parent', '=', active_workflow]], fields=['*']) for state in workflow_states: if state.update_field: continue status_field = 'approval_status' if doctype=="Expense Claim" else 'status' frappe.set_value('Workflow Document State', state.name, 'update_field', status_field) frappe.set_value('Workflow Document State', state.name, 'update_value', state.state)
def sync_all(in_background=False): if not in_background: frappe.msgprint('Sync has started and will run in the background...') verify_whitelisted_call() frappe.enqueue( 'bench_manager.bench_manager.doctype.bench_settings.bench_settings.sync_sites' ) frappe.enqueue( 'bench_manager.bench_manager.doctype.bench_settings.bench_settings.sync_apps' ) frappe.enqueue( 'bench_manager.bench_manager.doctype.bench_settings.bench_settings.sync_backups' ) frappe.set_value('Bench Settings', None, 'last_sync_timestamp', frappe.utils.time.time())
def execute(): frappe.reload_doctype('Role') frappe.reload_doctype('User') roles = frappe.get_all("Role", fields=["name"]) for role in roles: if role.name not in (_('Guest'), _('Administrator'), _('System Manager'), _('HR System Manager'), _('All'), _('Employee'), _('HR Manager'), _('HR User'), _('Projects User'), _('Projects Manager'), 'Guest', 'Administrator', 'System Manager', 'HR System Manager', 'All', 'Employee', 'HR Manager', 'HR User', 'Projects User', 'Projects Manager'): #if frappe.db.exists('Role', role_name) and role_name != role.name: frappe.set_value('Role', role.name, 'disabled', 1) frappe.set_value('Role', role.name, 'hr_role', 0)
def create_additional_salary_journal(doc, method): #frappe.msgprint("Method fired is: " + str(method)) if (frappe.get_value("Salary Component", doc.salary_component, "create_cash_journal")): salary_component = frappe.get_doc("Salary Component", doc.salary_component) cash_account = frappe.db.get_single_value("Payware Settings", "default_account_for_additional_component_cash_journal") component_account = frappe.db.get_value("Salary Component Account", {"parent": doc.salary_component, "company": doc.company}, "default_account") # frappe.msgprint("Expense account is: " + str(component_account)) if method == "on_submit": dr_account = component_account cr_account = cash_account elif method == "on_cancel": dr_account = cash_account cr_account = component_account else: frappe.msgprint("Unknown method on create_additional_salary_journal") return #frappe.msgprint("Method fired: " + method) precision = frappe.get_precision("Journal Entry Account", "debit_in_account_currency") journal_entry = frappe.new_doc('Journal Entry') journal_entry.voucher_type = 'Cash Entry' journal_entry.user_remark = _('{2} by {1} for {3}').format(doc.doctype, doc.name, doc.salary_component, doc.employee_name) journal_entry.company = doc.company journal_entry.posting_date = doc.payroll_date payment_amount = flt(doc.amount, precision) journal_entry.set("accounts", [ { "account": dr_account, "debit_in_account_currency": payment_amount }, { "account": cr_account, "credit_in_account_currency": payment_amount } ]) journal_entry.save(ignore_permissions = True) if method == "on_submit": frappe.set_value(doc.doctype, doc.name, "journal_name", journal_entry.name) msg_to_print = doc.doctype + " journal " + journal_entry.name + " has been created." elif method == "on_cancel": msg_to_print = doc.doctype + " reverse journal " + journal_entry.name + " has been created." frappe.msgprint(msg_to_print) if (doc.auto_created_based_on): frappe.set_value("Additional Salary", doc.auto_created_based_on, "last_transaction_amount", doc.amount)
def setup_holiday_list(): """Setup Holiday List for the current year""" year = now_datetime().year holiday_list = frappe.get_doc({ "doctype": "Holiday List", "holiday_list_name": str(year), "from_date": "{0}-01-01".format(year), "to_date": "{0}-12-31".format(year), }) holiday_list.insert() holiday_list.weekly_off = "Saturday" holiday_list.get_weekly_off_dates() holiday_list.weekly_off = "Sunday" holiday_list.get_weekly_off_dates() holiday_list.save() frappe.set_value("Company", erpnext.get_default_company(), "default_holiday_list", holiday_list.name)
def test_batch_name_with_naming_series(self): stock_settings = frappe.get_single('Stock Settings') use_naming_series = cint(stock_settings.use_naming_series) if not use_naming_series: frappe.set_value('Stock Settings', 'Stock Settings', 'use_naming_series', 1) batch = self.make_new_batch('_Test Stock Item For Batch Test1') batch_name = batch.name self.assertTrue(batch_name.startswith('BATCH-')) # reset Stock Settings if not use_naming_series: frappe.set_value('Stock Settings', 'Stock Settings', 'use_naming_series', 0)
def contribute_translation(language, contributor, source_name, target_name, doc_name): data = {"data": json.dumps({ "language": language, "contributor": contributor, "source_name": source_name, "target_name": target_name, "posting_date": frappe.utils.nowdate() })} try: response = make_post_request(url=frappe.get_hooks("translation_contribution_url")[0], data=data) except Exception: frappe.msgprint("Something went wrong while contributing translation. Please check error log for more details") if response.get("message").get("message") == "Already exists": frappe.msgprint("Translation already exists") elif response.get("message").get("message") == "Added to contribution list": frappe.set_value("Translation", doc_name, "contributed_translation_doctype_name", response.get("message").get("doc_name")) frappe.msgprint("Translation successfully contributed")
def set_customer_info(fieldname, customer, value=""): if fieldname == 'loyalty_program': frappe.db.set_value('Customer', customer, 'loyalty_program', value) contact = frappe.get_cached_value('Customer', customer, 'customer_primary_contact') or "" if contact: contact_doc = frappe.get_doc('Contact', contact) if fieldname == 'email_id': contact_doc.set('email_ids', [{ 'email_id': value, 'is_primary': 1 }]) frappe.db.set_value('Customer', customer, 'email_id', value) elif fieldname == 'mobile_no': contact_doc.set('phone_nos', [{ 'phone': value, 'is_primary_mobile_no': 1 }]) frappe.db.set_value('Customer', customer, 'mobile_no', value) contact_doc.save() else: contact_doc = frappe.new_doc('Contact') contact_doc.first_name = customer contact_doc.is_primary_contact = 1 contact_doc.is_billing_contact = 1 if fieldname == "mobile_no": contact_doc.add_phone(value, is_primary_mobile_no=1, is_primary_phone=1) if fieldname == 'email_id': contact_doc.add_email(value, is_primary=1) contact_doc.append("links", { "link_doctype": "Customer", "link_name": customer }) contact_doc.flags.ignore_mandatory = True contact_doc.save() frappe.set_value("Customer", customer, "customer_primary_contact", contact_doc.name)
def _set_item_pl_rate(effective_date, item_code, price_list, price_list_rate): from frappe.model.utils import get_fetch_values item_prices = frappe.db.sql(""" select name, valid_from, valid_upto from `tabItem Price` where selling = 1 and item_code = %s and price_list = %s order by valid_from """, [item_code, price_list], as_dict=1) existing_item_price = filter(lambda d: d.valid_from == effective_date, item_prices) existing_item_price = existing_item_price[ 0] if existing_item_price else None past_item_price = filter( lambda d: not d.valid_from or d.valid_from < effective_date, item_prices) past_item_price = past_item_price[-1] if past_item_price else None future_item_price = filter( lambda d: d.valid_from and d.valid_from > effective_date, item_prices) future_item_price = future_item_price[0] if future_item_price else None # Update or add item price if existing_item_price: doc = frappe.get_doc("Item Price", existing_item_price.name) else: doc = frappe.new_doc("Item Price") doc.item_code = item_code doc.price_list = price_list doc.update(get_fetch_values("Item Price", 'item_code', item_code)) doc.update(get_fetch_values("Item Price", 'price_list', price_list)) doc.price_list_rate = flt(price_list_rate) doc.valid_from = effective_date if future_item_price: doc.valid_upto = frappe.utils.add_days(future_item_price.valid_from, -1) doc.save() # Update previous item price before_effective_date = frappe.utils.add_days(effective_date, -1) if past_item_price and past_item_price.valid_upto != before_effective_date: frappe.set_value("Item Price", past_item_price.name, 'valid_upto', before_effective_date)
def set_customer_info(fieldname, customer, value=""): if fieldname == "loyalty_program": frappe.db.set_value("Customer", customer, "loyalty_program", value) contact = (frappe.get_cached_value("Customer", customer, "customer_primary_contact") or "") if contact: contact_doc = frappe.get_doc("Contact", contact) if fieldname == "email_id": contact_doc.set("email_ids", [{ "email_id": value, "is_primary": 1 }]) frappe.db.set_value("Customer", customer, "email_id", value) elif fieldname == "mobile_no": contact_doc.set("phone_nos", [{ "phone": value, "is_primary_mobile_no": 1 }]) frappe.db.set_value("Customer", customer, "mobile_no", value) contact_doc.save() else: contact_doc = frappe.new_doc("Contact") contact_doc.first_name = customer contact_doc.is_primary_contact = 1 contact_doc.is_billing_contact = 1 if fieldname == "mobile_no": contact_doc.add_phone(value, is_primary_mobile_no=1, is_primary_phone=1) if fieldname == "email_id": contact_doc.add_email(value, is_primary=1) contact_doc.append("links", { "link_doctype": "Customer", "link_name": customer }) contact_doc.flags.ignore_mandatory = True contact_doc.save() frappe.set_value("Customer", customer, "customer_primary_contact", contact_doc.name)
def execute(): for doctype in ['Expense Claim', 'Leave Application']: active_workflow = get_workflow_name(doctype) if not active_workflow: continue workflow_states = frappe.get_all( 'Workflow Document State', filters=[['parent', '=', active_workflow]], fields=['*']) for state in workflow_states: if state.update_field: continue status_field = 'approval_status' if doctype == "Expense Claim" else 'status' frappe.set_value('Workflow Document State', state.name, 'update_field', status_field) frappe.set_value('Workflow Document State', state.name, 'update_value', state.state)
def save_new_records(test_records): for record in test_records: kwargs = dict( doctype=record.get("doctype"), docname=record.get("date") + '-' + record.get("from_currency") + '-' + record.get("to_currency"), fieldname="exchange_rate", value=record.get("exchange_rate"), ) try: frappe.set_value(**kwargs) except frappe.DoesNotExistError: curr_exchange = frappe.new_doc(record.get("doctype")) curr_exchange.date = record["date"] curr_exchange.from_currency = record["from_currency"] curr_exchange.to_currency = record["to_currency"] curr_exchange.exchange_rate = record["exchange_rate"] curr_exchange.insert()
def wechat_bind(app, user, openid, expires=None): doc_name = frappe.get_value("Wechat Binding", {"user": user, "app": app}) if doc_name: frappe.set_value("Wechat Binding", doc_name, "openid", openid) frappe.set_value("Wechat Binding", doc_name, "expires", expires) return _("Binding is done") doc = frappe.get_doc({ "doctype": "Wechat Binding", "user": user, "app": app, "openid": openid, "expires": expires }) doc.insert(ignore_permissions=True) frappe.db.commit() return _("Binding is done")
def confirmed(row, doc): row = frappe._dict(json.loads(row)) doc = frappe._dict(json.loads(doc)) if row.invoiced or not row.left: return encounter = frappe.get_doc("Patient Encounter", doc.admission_encounter) service_unit_type, warehouse = frappe.get_value( "Healthcare Service Unit", row.service_unit, ["service_unit_type", "warehouse"]) item_code = frappe.get_value("Healthcare Service Unit Type", service_unit_type, "item_code") item_rate = 0 if encounter.insurance_subscription: item_rate = get_item_rate( item_code, encounter.company, encounter.insurance_subscription, encounter.insurance_company, ) if not item_rate: frappe.throw( _("There is no price in Insurance Subscription {0} for item {1}" ).format(encounter.insurance_subscription, item_code)) elif encounter.mode_of_payment: price_list = frappe.get_value("Mode of Payment", encounter.mode_of_payment, "price_list") if not price_list: frappe.throw( _("There is no in mode of payment {0}").format( encounter.mode_of_payment)) if price_list: item_rate = get_item_price(item_code, price_list, encounter.company) if not item_rate: frappe.throw( _("There is no price in price list {0} for item {1}"). format(price_list, item_code)) if item_rate: delivery_note = create_delivery_note(encounter, item_code, item_rate, warehouse, row, doc.primary_practitioner) frappe.set_value(row.doctype, row.name, "is_confirmed", 1) return delivery_note
def ensure_job_run(): jobs = get_scheduled_jobs(as_df=True) now = frappe.utils.now_datetime() failed_jobs = jobs[jobs.status == 'Failure'] unfinished_jobs = jobs[jobs.expected_finish < now] if not unfinished_jobs.empty: unfinished_jobs = unfinished_jobs[unfinished_jobs.status == 'Started'] to_retry = pd.concat([failed_jobs, unfinished_jobs]) site_name = frappe.local.site running_jobs = set([ job for job in (get_jobs(site=site_name).get(site_name) or []) if job in to_retry.index.values ]) for method, row in to_retry.iterrows(): frappe.set_value('Job Run', row.job_run_id, 'status', 'Retried') if method in running_jobs: continue running_jobs.add(method) retry_job(method, row.queue_name)
def generate_additional_salary_records(): today_date = today() auto_repeat_frequency = { "Monthly": 1, "Annually": 12 } additional_salary_list = frappe.get_all("Additional Salary", filters={"docstatus": "1", "auto_repeat_frequency": ("!=", "None"), "auto_repeat_end_date": ("!=", ""), "auto_repeat_end_date": (">=", today_date)}, fields={"name", "auto_repeat_end_date", "last_transaction_date", "last_transaction_amount", "auto_repeat_frequency", "payroll_date", "employee", "salary_component", "employee_name", "type", "overwrite_salary_structure_amount", "amount"}) # frappe.msgprint("Additional Salary List lookedup: " + str(additional_salary_list)) if additional_salary_list: # frappe.msgprint("In the salary loop") for additional_salary_doc in additional_salary_list: #additional_salary_doc.last_transaction_date if additional_salary_doc.last_transaction_date == None: additional_salary_doc.last_transaction_date = additional_salary_doc.payroll_date if additional_salary_doc.last_transaction_amount == 0: additional_salary_doc.last_transaction_amount = additional_salary_doc.amount if additional_salary_doc.auto_repeat_frequency == "Weekly": next_date = add_days(getdate(additional_salary_doc.last_transaction_date), 7) else: frequency_factor = auto_repeat_frequency.get(additional_salary_doc.auto_repeat_frequency, "Invalid frequency") if frequency_factor == "Invalid frequency": frappe.throw("Invalid frequency: {0} for {1} not found. Contact the developers!".format(additional_salary_doc.auto_repeat_frequency, additional_salary_doc.name)) next_date = add_months(getdate(additional_salary_doc.last_transaction_date), frequency_factor) # Create 13 days in advance - specificlaly to allow mid salary advance. # frappe.msgprint("next date" + str(next_date) + " todays date string " + str(add_days(getdate(today_date), 13))) if next_date <= add_days(getdate(today_date), 13): additional_salary = frappe.new_doc('Additional Salary') additional_salary.employee = additional_salary_doc.employee additional_salary.payroll_date = next_date additional_salary.salary_component = additional_salary_doc.salary_component additional_salary.employee_name = additional_salary_doc.employee_name additional_salary.amount = additional_salary_doc.last_transaction_amount additional_salary.company = additional_salary_doc.company additional_salary.overwrite_salary_structure_amount = additional_salary_doc.overwrite_salary_structure_amount additional_salary.type = additional_salary_doc.type additional_salary.auto_repeat_frequency = "None" additional_salary.auto_created_based_on = additional_salary_doc.name additional_salary.auto_repeat_end_date = None additional_salary.last_transaction_date = None additional_salary.save(ignore_permissions = True) frappe.set_value("Additional Salary", additional_salary_doc.name, "last_transaction_date", next_date) frappe.msgprint("New additional salary created for " + additional_salary_doc.auto_repeat_frequency + " dated " + str(next_date))
def execute(): for doctype in ["Expense Claim", "Leave Application"]: active_workflow = get_workflow_name(doctype) if not active_workflow: continue workflow_states = frappe.get_all( "Workflow Document State", filters=[["parent", "=", active_workflow]], fields=["*"]) for state in workflow_states: if state.update_field: continue status_field = "approval_status" if doctype == "Expense Claim" else "status" frappe.set_value("Workflow Document State", state.name, "update_field", status_field) frappe.set_value("Workflow Document State", state.name, "update_value", state.state)
def set_value_resolver(obj, info: GraphQLResolveInfo, **kwargs): doctype = kwargs.get("doctype") name = kwargs.get("name") value = kwargs.get('value') fieldname = kwargs.get("fieldname") if frappe.get_meta(doctype).get_field(fieldname).fieldtype \ in table_fields: value = frappe.parse_json(value) frappe.set_value(doctype=doctype, docname=name, fieldname=fieldname, value=value) frappe.clear_document_cache(doctype, name) doc = frappe.get_doc(doctype, name).as_dict() return { "doctype": doctype, "name": name, "fieldname": kwargs.get("fieldname"), "value": kwargs.get("value"), "doc": doc }
def update_module_roles(projects_module): projects_module_roles = "" frappe.reload_doctype('Role') frappe.reload_doctype('User') arr = [ 'Guest', 'Administrator', 'System Manager', 'HR System Manager', 'All', 'Employee', 'HR Manager', 'HR User' ] roles = frappe.get_all("Role", fields=["name"]) if get_company_module_roles( 'projects_module') == 1 or projects_module == 1: arr.append('Projects User') arr.append('Projects Manager') for role in roles: if role.name not in tuple(arr): frappe.set_value('Role', role.name, 'disabled', 1) else: frappe.set_value('Role', role.name, 'disabled', 0) print str(role.name)
def add_pricing_rules(mquotation, method=None): """This function adds all the items to pricing rules""" frappe.msgprint(_("Adding Pricing Rules")) quotation = frappe.get_doc("Supplier Quotation", mquotation) # Loop through all of the items in the price list for item_doc in quotation.items: # check to see if there are any pricing rules that fall into the specified quantity/supplier # frappe.msgprint(_("Checking pricing rules of {0} for previous prices".format(item_doc.item_code))) item = frappe.get_doc("Item", item_doc.item_code) args = { "doctype": item_doc.doctype, "parent_type": item_doc.parenttype, "name": item_doc.name, "item_code": item_doc.item_code, "transaction_type": "buying", "supplier": quotation.supplier, "qty": item_doc.qty, "price_list": quotation.buying_price_list, "company": quotation.company, } args = frappe._dict(args) pr_result = get_pricing_rule_for_item(args) if not pr_result.pricing_rule: frappe.msgprint(_("There are no pricing rules for this item")) pr_title = item_doc.item_code + "-" + quotation.supplier + "-" + str(item_doc.qty) new_rule = frappe.get_doc( { "doctype": "Pricing Rule", "min_qty": item_doc.qty, "apply_on": "Item Code", "item_code": item_doc.item_code, "priority": 1, "buying": "1", "applicable_for": "Supplier", "company": quotation.company, "price_or_discount": "Price", "price": item_doc.rate, "supplier": quotation.supplier, "for_price_list": quotation.buying_price_list, "title": pr_title, "from_supplier_quotation": quotation.name, } ) new_rule.insert() else: frappe.msgprint(_("Pricing Rule {0} applies for this item".format(pr_result.pricing_rule))) # Check to see if the pricing rule matches quantity min exactly pricing_rule = frappe.get_doc("Pricing Rule", pr_result.pricing_rule) if item_doc.qty == pricing_rule.min_qty: # This pricing rule rate just needs to be changed frappe.msgprint(_("Updating Pricing Rule")) frappe.set_value("Pricing Rule", pricing_rule.name, "price", item_doc.rate) frappe.set_value("Pricing Rule", pricing_rule.name, "from_supplier_quotation", quotation.name) else: frappe.msgprint(_("Creating new rule and incrementing priority")) # This rule is lower in qty than the current rule. We need to add a new pricing rule and update the priorities for each of the higher quantity pricing rules pr_title = item_doc.item_code + "-" + quotation.supplier + "-" + str(item_doc.qty) new_rule = frappe.get_doc( { "doctype": "Pricing Rule", "min_qty": item_doc.qty, "apply_on": "Item Code", "item_code": item_doc.item_code, "priority": pricing_rule.priority, "buying": "1", "applicable_for": "Supplier", "company": quotation.company, "price_or_discount": "Price", "price": item_doc.rate, "supplier": quotation.supplier, "for_price_list": quotation.buying_price_list, "title": pr_title, "from_supplier_quotation": quotation.name, } ) new_rule.insert() # Run through each of the higher quantity pricing rules and increase their priority by one unfiltered_rules = get_pricing_rules(args) pricing_rules = filter(lambda x: (flt(item_doc.qty) <= flt(x.min_qty)), unfiltered_rules) for pr in pricing_rules: frappe.set_value("Pricing Rule", pr.name, "priority", str(int(pr.priority) + 1))
def execute(): frappe.reload_doc("setup", "doctype", "country") import_country_and_currency() for name, country in iteritems(get_all()): frappe.set_value("Country", name, "code", country.get("code"))
def remove_role(role): frappe.db.sql('delete from tabUserRole where role=%s', role) frappe.set_value('Role', role, 'disabled', 1)
def test_serial_no_based_delivery(self): frappe.set_value("Stock Settings", None, "automatically_set_serial_nos_based_on_fifo", 1) from erpnext.stock.doctype.item.test_item import make_item item = make_item("_Reserved_Serialized_Item", {"is_stock_item": 1, "maintain_stock": 1, "has_serial_no": 1, "serial_no_series": "SI.####", "valuation_rate": 500, "item_defaults": [ { "default_warehouse": "_Test Warehouse - _TC", "company": "_Test Company" }] }) frappe.db.sql("""delete from `tabSerial No` where item_code=%s""", (item.item_code)) make_item("_Test Item A", {"maintain_stock": 1, "valuation_rate": 100, "item_defaults": [ { "default_warehouse": "_Test Warehouse - _TC", "company": "_Test Company" }] }) make_item("_Test Item B", {"maintain_stock": 1, "valuation_rate": 200, "item_defaults": [ { "default_warehouse": "_Test Warehouse - _TC", "company": "_Test Company" }] }) from erpnext.manufacturing.doctype.production_plan.test_production_plan import make_bom make_bom(item=item.item_code, rate=1000, raw_materials = ['_Test Item A', '_Test Item B']) so = make_sales_order(**{ "item_list": [{ "item_code": item.item_code, "ensure_delivery_based_on_produced_serial_no": 1, "qty": 1, "rate":1000 }] }) so.submit() from erpnext.manufacturing.doctype.work_order.test_work_order import \ make_wo_order_test_record work_order = make_wo_order_test_record(item=item.item_code, qty=1, do_not_save=True) work_order.fg_warehouse = "_Test Warehouse - _TC" work_order.sales_order = so.name work_order.submit() make_stock_entry(item_code=item.item_code, target="_Test Warehouse - _TC", qty=1) item_serial_no = frappe.get_doc("Serial No", {"item_code": item.item_code}) from erpnext.manufacturing.doctype.work_order.work_order import \ make_stock_entry as make_production_stock_entry se = frappe.get_doc(make_production_stock_entry(work_order.name, "Manufacture", 1)) se.submit() reserved_serial_no = se.get("items")[2].serial_no serial_no_so = frappe.get_value("Serial No", reserved_serial_no, "sales_order") self.assertEqual(serial_no_so, so.name) dn = make_delivery_note(so.name) dn.save() self.assertEqual(reserved_serial_no, dn.get("items")[0].serial_no) item_line = dn.get("items")[0] item_line.serial_no = item_serial_no.name self.assertRaises(frappe.ValidationError, dn.submit) item_line = dn.get("items")[0] item_line.serial_no = reserved_serial_no self.assertTrue(dn.submit) dn.load_from_db() dn.cancel() si = make_sales_invoice(so.name) si.update_stock = 1 si.save() self.assertEqual(si.get("items")[0].serial_no, reserved_serial_no) item_line = si.get("items")[0] item_line.serial_no = item_serial_no.name self.assertRaises(frappe.ValidationError, dn.submit) item_line = si.get("items")[0] item_line.serial_no = reserved_serial_no self.assertTrue(si.submit) si.submit() si.load_from_db() si.cancel() si = make_sales_invoice(so.name) si.update_stock = 0 si.submit() from erpnext.accounts.doctype.sales_invoice.sales_invoice import \ make_delivery_note as make_delivery_note_from_invoice dn = make_delivery_note_from_invoice(si.name) dn.save() dn.submit() self.assertEqual(dn.get("items")[0].serial_no, reserved_serial_no) dn.load_from_db() dn.cancel() si.load_from_db() si.cancel() se.load_from_db() se.cancel() self.assertFalse(frappe.db.exists("Serial No", {"sales_order": so.name}))
def on_cancel(self): for worker in self.worker_attendance: if worker.worker_name: old_os_wages = frappe.db.get_value("Worker", {"name": worker.worker_name}, "outstanding_wages") os_wages = old_os_wages - (worker.rate * worker.hours) frappe.set_value("Worker", worker.worker_name, "outstanding_wages", os_wages)