def create_user(self):
doctype = "User"
if db.exists(doctype, self.user):
return
user = frappe.new_doc(doctype)
user.update({
"email": self.user,
"first_name": self.first_name,
"last_name": self.last_name,
"full_name": self.full_name,
"enabled": 1 if self.status == "Active" else 0,
"username": self.full_name.replace(" ", "_"),
})
new_role = _("Resident")
if not db.exists("Role", new_role):
frappe.get_doc({
"doctype": "Role",
"role_name": new_role
}).save(ignore_permissions=True)
user.add_roles(new_role)
user.save(ignore_permissions=True)
def validate_if_exists(self):
doctype = self.doctype
name = self.generate_autoname()
reversed_name = self.generate_autoname(reversed=True)
error_message = """
Se encontró una {doctype} en el sistema que coincide
con estos valores: <br>
<a href="{url_to_form}"><strong>{doctype}</strong>: {name}</a>
"""
exists = database.exists(doctype, name)
exists_in_reversed = database.exists(doctype, reversed_name)
if not exists and not exists_in_reversed:
return
if not self.is_new() and self.name == name:
return
url_to_form = frappe.utils.get_url_to_form(
doctype, reversed_name if exists_in_reversed else name)
frappe.throw(
error_message.format(
doctype=doctype,
url_to_form=url_to_form,
name=reversed_name if exists_in_reversed else name))
def create_customer_if_not_exists(self):
party_doctype = "Customer"
filters = {
"tax_id": self.tax_id,
}
doc = frappe.new_doc(party_doctype)
if db.exists(party_doctype, filters):
doc = frappe.get_doc(party_doctype, filters)
doc.update({
"customer_name": self.full_name,
"customer_type": "Individual",
"tax_id": self.tax_id,
"customer_phones": [],
"customer_reference": [],
})
self.add_customer_numbers(doc)
self.add_customer_references(doc, "guarantor_1")
self.add_customer_references(doc, "guarantor_2")
self.add_customer_references(doc, "guarantor_3")
self.add_customer_references(doc, "co_debtor", True)
# let's make sure that the customer saves
doc.flags.ignore_mandatory = True
doc.flags.ignore_permissions = True
self.customer = doc.name
doc.save()
def get_item(source_doc):
ref_doctype = "Product Assembly"
ref_docname = source_doc.product_assembly
doctype = "Item"
filters = {
"ref_doctype": ref_doctype,
"ref_docname": ref_docname,
}
errmsg = translate("Item not found for Product Assembly: {}")
if not database.exists(doctype, filters):
frappe.throw(errmsg.format(ref_docname))
item_doc = frappe.get_doc(doctype, filters)
args = {
"item_code": item_doc.name,
"item_name": item_doc.item_name,
"parent": target_doc.name,
"parentfield": "items",
"parenttype": "Quotation",
"description": source_doc.product_assembly_specification,
"company": defaults.company,
"doctype": "Quotation",
"currency": source_doc.currency,
"qty": source_doc.qty_to_produce,
"rate": source_doc.rate_per_unit,
}
return get_item_details(args)
def generate_hash_and_validate(self):
# don't validate for compound products
unique_hash = self.generate_hash()
doctype = self.doctype
filters = {
"unique_hash": unique_hash,
}
if not self.is_new():
filters.update({
"name": ["!=", self.name]
})
exists = cstr(database.exists(doctype, filters))
url_to_form = frappe.utils.get_url_to_form(doctype, exists)
err_msg = """
Ya existe un Producto con las mismas especificaciones
<br>
<strong>{doctype}</strong>
<a href="{url_to_form}">{name}</a>
"""
if exists and not self.is_compound_product:
frappe.throw(
err_msg
.format(doctype=translate(doctype),
url_to_form=url_to_form,
name=exists)
)
self.unique_hash = unique_hash
def update_naming_series(self):
setter = frappe.new_doc("Property Setter")
filters = {
'doc_type': "Sales Invoice",
'field_name': 'naming_series',
'doctype_or_field': 'DocField',
'property': "options",
'property_type': "Select"
}
if database.exists("Property Setter", filters):
setter = frappe.get_doc("Property Setter", filters)
series = [""]
series += self.get_series()
setter.update({
'doc_type': "Sales Invoice",
'field_name': 'naming_series',
'doctype_or_field': 'DocField',
'property': "options",
'property_type': "Select",
'value': "\n".join(series)
})
setter.save()
database.commit()
def update_tasks(doc):
doctype = "Project Template"
docname = doc.project_template
if not docname:
return False
template = frappe.get_doc(doctype, docname)
# update tasks from template
for task in template.tasks:
doctype = "Task"
filters = {
"subject": task.subject,
"project": doc.name,
"task_weight": task.task_weight,
}
exists = database.exists(doctype, filters)
if not exists:
continue
taskdoc = frappe.get_doc(doctype, filters)
taskdoc.update({
"department": doc.department,
"idx": task.idx,
})
taskdoc.flags.ignore_permissions = True
taskdoc.save()
def get_linked_production_order(self):
doctype = "Production Order"
filters = {"project_center": self.name}
if not database.exists(doctype, filters):
return None
return frappe.get_value(doctype, filters)
def get_loan_record(doc):
import fimax.utils
doctype = "Loan Record"
if not db.exists(doctype, doc.name):
return fimax.utils.create_loan_record(doc)
return get_doc(doctype, doc.name)
def update_status(self): doctype = "User" if not db.exists(doctype, self.user): return user = frappe.get_doc(doctype, self.user) user.enabled = 1 if self.status == "Active" else 0 user.save(ignore_permissions=True)
def add_reqd_custom_fields_in_user():
if db.exists("Custom Field", "User-dark_theme"):
return
from condos import user_custom_fields
for docdict in user_custom_fields:
frappe.get_doc(docdict) \
.save(ignore_permissions=True)
def get_party_details(party=None,
party_type="Customer",
ignore_permissions=False):
if not party:
return {}
if not db.exists(party_type, party):
frappe.throw(_("{0}: {1} does not exists").format(party_type, party))
return _get_party_details(party, party_type, ignore_permissions)
def set_creator_object(doc):
doctype = doc.ref_doctype
docname = doc.ref_docname
if doctype and docname:
if database.exists(doctype, docname):
creator_doc = get_doc(doctype, docname)
doc.set_onload("creator", creator_doc)
doc.set_onload("is_child_creator", False)
else:
doc.set_onload("creator", {})
childdoctype = doc.ref_childtype
childdocname = doc.ref_childname
if childdoctype and childdocname:
if database.exists(childdoctype, childdocname):
creator_doc = get_doc(childdoctype, childdocname)
doc.set_onload("creator", creator_doc)
doc.set_onload("is_child_creator", False)
def execute():
core = "DocType"
doctype = "Paperboard Caliper"
if not database.exists(core, doctype):
return False
database.sql("""
Update `tab{0}`
Set caliper_uom = capliper_uom
Where
caliper_uom is null
And capliper_uom is not null
""".format(doctype))
def upadte_item_price(item, price_list, per_unit_price):
if db.exists("Item Price",{"item_code":item,"price_list":price_list}):
name = db.get_value("Item Price",{"item_code":item,"price_list":price_list},'name')
db.set_value("Item Price",name,"price_list_rate", per_unit_price)
else:
item_price = frappe.new_doc("Item Price")
item_price.price_list = price_list
item_price.item_code = item
item_price.price_list_rate = per_unit_price
item_price.save()
db.commit()
return "Item Price Updated!"
def get_item_group_doc(item_group):
doctype = "Item Group"
filters = {
"item_group_name": item_group,
}
exists = database.exists(doctype, filters)
doc = frappe.new_doc(doctype)
if exists:
doc = frappe.get_doc(doctype, filters)
return doc
def get_product_features(item_code):
doctype = "Item"
name = item_code
fields = ("ref_doctype", "ref_docname")
ref_doctype, ref_docname = database.get_value(
doctype, name, fields)
if not ref_doctype or not ref_docname \
or not database.exists(ref_doctype, ref_docname):
return []
doc = frappe.get_doc(ref_doctype, ref_docname)
options = doc.get_full_product_options()
return options.split(", ")
def update_status_to_loan_charges():
"""Update status for each Loan Charge based on the current
date and the paid amount"""
for doc in get_valid_loan_charges():
if not db.exists(doc.doctype, doc.name):
continue
# it exists, so then let's get it
doc = get_doc(doc.doctype, doc.name)
doc.run_method("update_references", cancel=False)
doc.run_method("update_status")
# submit to update the database
doc.submit()
def execute():
doctype = "Paperboard"
if not database.exists("DocType", doctype):
return False
doclist = frappe.get_all(doctype)
for opts in doclist:
doc = frappe.get_doc(doctype, opts)
oldname = doc.name
newname = doc.title
if newname == oldname:
continue
frappe.rename_doc(doctype, newname, oldname, force=True)
def get_item_doc(doctype, docname, cdt=None, cdn=None):
item_doctype = "Item"
filters = {
"ref_doctype": doctype,
"ref_docname": docname,
}
if cdt and cdn:
filters.update({
"ref_childtype": cdt,
"ref_childname": cdn,
})
if database.exists(item_doctype, filters):
return get_doc(item_doctype, filters)
return frappe.new_doc(item_doctype)
def validate_if_doc_exists(self):
item_doc = self.get_item_doc()
doctype = item_doc.ref_doctype
name = item_doc.ref_docname
errmsg = translate("This Item cannot be used as it does "
"not have a Product Profile")
if not doctype or not name:
frappe.throw(errmsg)
errmsg = translate(
"This Item cannot be used as its "
"references to a Product Profile does not exist anymore")
if not database.exists(doctype, name):
frappe.throw(errmsg)
def execute():
if not database.exists("DocType", "List of Material Detail"):
return False
doctype = "List of Material Detail"
doclist = frappe.get_all(doctype, as_list=True)
for name, in doclist:
doc = frappe.get_doc(doctype, name)
if doc.naming_selection \
or doc.naming_series:
continue
doc.naming_selection = "Naming Series"
doc.naming_series = "LIST-OF-MATERIAL-DETAIL-"
doc.db_update()
def validate_if_exists(self):
doctype = self.doctype
name = self.generate_autoname()
url_to_form = frappe.utils.get_url_to_form(doctype, name)
error_message = """
Se encontró una {doctype} en el sistema que coincide
con estos valores: <br>
<a href="{url_to_form}"><strong>{doctype}</strong>: {name}</a>
"""
if not database.exists(doctype, name):
return
frappe.throw(
error_message.format(doctype=doctype,
url_to_form=url_to_form,
name=name))
def add_reqd_roles():
"""adds default roles for the app to run"""
from condos.controllers.role import create_simple_role
doctype, role_list = "Role", (
_("Tenant"),
_("Leaser"),
_("Supervisor"),
_("Employee"),
_("Maintainer"),
_("Web User"),
)
for role in role_list:
if db.exists(doctype, role):
continue
create_simple_role(role) \
.save(ignore_permissions=True)
def onclick_update_price(self):
if self.item_price:
if db.exists("Item Price" ,{ "item_code":self.item_code ,"price_list":self.price_list}):
item_price = frappe.get_doc("Item Price",{"item_code":self.item_code, "price_list":self.price_list})
item_price.price_list_rate = self.item_price
if self.link_to == "Supplier" and self.price_list == "Standard Buying":
item_price.supplier = self.party
elif self.link_to == "Customer" and self.price_list == "Standard Selling":
item_price.customer = self.party
item_price.save()
else:
item_price = frappe.new_doc("Item Price")
item_price.price_list = self.price_list
item_price.item_code = self.item_code
item_price.price_list_rate = self.item_price
if self.link_to == "Supplier" and self.price_list == "Standard Buying":
item_price.supplier = self.party
elif self.link_to == "Customer" and self.price_list == "Standard Selling":
item_price.customer = self.party
item_price.save()
frappe.msgprint("Item Price Updated")
def on_submit(self):
data = frappe.get_list("Item Price", fields='item_code')
if db.exists("Item Price", {
"item_code": self.product_name,
"price_list": self.price_list
}):
item_price = frappe.get_doc("Item Price", {
"item_code": self.product_name,
"price_list": self.price_list
})
item_price.price_list_rate = self.price
item_price.price_list = self.price_list
item_price.save()
else:
item_price = frappe.new_doc("Item Price")
item_price.price_list = self.price_list
item_price.item_code = self.product_name
item_price.price_list_rate = self.price
item_price.save()
frappe.db.commit()
frappe.msgprint(_("Item Price Updated"))
def get_compound_product(self, throw_error=True):
if not self.is_compound_product:
if throw_error:
err_msg = translate(
"Product Assembly must be a marked as Compound Product")
frappe.throw(err_msg)
return False
doctype = "Compound Product"
filters = {
"product_profile": self.product_profile,
"product_assembly": self.name,
}
if not database.exists(doctype, filters):
err_msg = translate(
"A Compound Product linked to this "
"Product Assembly does not exist")
frappe.throw(err_msg)
return frappe.get_doc(doctype, filters)
def fetch_default_rate(product_option, option, options):
doctype = "Product Feature"
name = product_option
fieldname = "materials"
if not database.exists(doctype, name):
option.rate = 0.0000
return option.rate
del options[product_option]
doc = frappe.get_doc(doctype, name)
# total = .000
for supply in doc.get(fieldname):
doctype = "List of Material Detail"
name = supply.list_of_material_detail
fields = ("last_purchase_rate", "qty", "fixed_qty")
values = frappe \
.get_value(doctype, name, fields, as_dict=True)
# total += flt(values.last_purchase_rate) * flt(values.qty)
if not name in options:
options[name] = pydict(qty=0, rate=.000)
option = options[name]
# option.cost_specification = "{}: {}".format(
# product_option, name)
option.cost_specification = cstr(name)
option.qty = flt(values.qty)
option.rate = flt(values.last_purchase_rate)
option.fixed_qty = values.fixed_qty
def fetch_product_assembly(self):
doctype = self.meta \
.get_field("product_assembly") \
.options
docname = self.product_assembly
if docname:
product_assembly = frappe \
.get_doc(doctype, docname)
if not product_assembly.is_compound_product:
self.set_assembly_onload(product_assembly)
return [product_assembly]
doctype = "Compound Product"
filters = {
"enabled": True,
"product_assembly": self.product_assembly,
}
errmsg = \
translate("The Product you're trying to estimate is marked "
"as Compound Product, but no Enabled Compound "
"Product template was found")
if not database.exists(doctype, filters):
frappe.throw(errmsg)
product_compound = frappe.get_doc(doctype, filters)
sub_assemblies = [
d.get_product_assembly() for d in product_compound.parts
]
self.set_assembly_onload(product_assembly, sub_assemblies)
def create_report_files(site_name, report_name):
# users can change the installation path, the operating
# user or even have multiple benchs running in the same instance.
# by default it is located at `/home/frappe/frappe-bench`
# so, lets make sure we get the right path
# get the base `frappe-bench` path where the system
# is installed
_base_path = frappe.utils.get_bench_path()
# scrub to remove any trailing spaces or if it is a more complex name
# by more than one word
# we just want to make sure and do anything we can to guess
# what the user wants and do it right
_site_name = frappe.scrub(site_name)
_sites_path = "/".join([_base_path, "sites"])
# lets bring all the frappe sites setup on this instance
_all_sites = frappe.utils \
.get_sites(sites_path=_sites_path)
# if the site does not exist in this instance
# exit and let the user know
if _site_name not in _all_sites:
print ("Site {site} does not exist" \
.format(site=_site_name))
sys_exit()
if _site_name != "all":
_all_sites = [_site_name]
module_exists = False
for site in _all_sites:
# initialize frappe for the current site.
# reset thread locals `frappe.local`
frappe.init(site=site, sites_path=_sites_path)
# connect to site database instance
# frappe.connect will try to init again
# this is fine as we don't any other solution by now
frappe.connect(site=site)
# we now can import the frappe.db object
from frappe import db
# if the report exists in at least one site
# that could mean we are posibly overriding the content
# of the controllers
# so, lets make sure that this never happens
# if we prove it to be true, we don't want to write to the files
# this is why we use two loops
if not db.exists("Report", {
"report_name": report_name,
}):
# mark the flag as true
module_exists = True
# and skip this round
report = frappe.get_doc("Report", report_name)
report_path = frappe.get_module_path(report.module, "report",
report_name)
frappe.create_folder(report_path, with_init=True)
report.create_report_py()
# lets close the connection and release werkzeug local
frappe.destroy()
