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