def test_delete_leaf(self):
# for checking later
parent_item_group = frappe.db.get_value("Item Group",
"_Test Item Group B - 3",
"parent_item_group")
rgt = frappe.db.get_value("Item Group", parent_item_group, "rgt")
ancestors = get_ancestors_of("Item Group", "_Test Item Group B - 3")
ancestors = frappe.db.sql("""select name, rgt from `tabItem Group`
where name in ({})""".format(", ".join(["%s"] * len(ancestors))),
tuple(ancestors),
as_dict=True)
frappe.delete_doc("Item Group", "_Test Item Group B - 3")
records_to_test = test_records[2:]
del records_to_test[4]
self.test_basic_tree(records=records_to_test)
# rgt of each ancestor would reduce by 2
for item_group in ancestors:
new_lft, new_rgt = frappe.db.get_value("Item Group",
item_group.name,
["lft", "rgt"])
self.assertEquals(new_rgt, item_group.rgt - 2)
# insert it back
frappe.copy_doc(test_records[6]).insert()
self.test_basic_tree()
def test_delete_leaf(self):
# for checking later
parent_item_group = frappe.db.get_value("Item Group", "_Test Item Group B - 3", "parent_item_group")
rgt = frappe.db.get_value("Item Group", parent_item_group, "rgt")
ancestors = get_ancestors_of("Item Group", "_Test Item Group B - 3")
ancestors = frappe.db.sql(
"""select name, rgt from `tabItem Group`
where name in ({})""".format(
", ".join(["%s"] * len(ancestors))
),
tuple(ancestors),
as_dict=True,
)
frappe.delete_doc("Item Group", "_Test Item Group B - 3")
records_to_test = test_records[2:]
del records_to_test[4]
self.test_basic_tree(records=records_to_test)
# rgt of each ancestor would reduce by 2
for item_group in ancestors:
new_lft, new_rgt = frappe.db.get_value("Item Group", item_group.name, ["lft", "rgt"])
self.assertEquals(new_rgt, item_group.rgt - 2)
# insert it back
frappe.copy_doc(test_records[6]).insert()
self.test_basic_tree()
def update_account_number(name,
account_name,
account_number=None,
from_descendant=False):
account = frappe.db.get_value("Account", name, "company", as_dict=True)
if not account: return
old_acc_name, old_acc_number = frappe.db.get_value('Account', name, \
["account_name", "account_number"])
# check if account exists in parent company
ancestors = get_ancestors_of("Company", account.company)
allow_independent_account_creation = frappe.get_value(
"Company", account.company,
"allow_account_creation_against_child_company")
if ancestors and not allow_independent_account_creation:
for ancestor in ancestors:
if frappe.db.get_value("Account", {
'account_name': old_acc_name,
'company': ancestor
}, 'name'):
# same account in parent company exists
allow_child_account_creation = _(
"Allow Account Creation Against Child Company")
message = _(
"Account {0} exists in parent company {1}.").format(
frappe.bold(old_acc_name), frappe.bold(ancestor))
message += "<br>" + _(
"Renaming it is only allowed via parent company {0}, \
to avoid mismatch.").format(frappe.bold(ancestor)) + "<br><br>"
message += _(
"To overrule this, enable '{0}' in company {1}").format(
allow_child_account_creation,
frappe.bold(account.company))
frappe.throw(message, title=_("Rename Not Allowed"))
validate_account_number(name, account_number, account.company)
if account_number:
frappe.db.set_value("Account", name, "account_number",
account_number.strip())
else:
frappe.db.set_value("Account", name, "account_number", "")
frappe.db.set_value("Account", name, "account_name", account_name.strip())
if not from_descendant:
# Update and rename in child company accounts as well
descendants = get_descendants_of('Company', account.company)
if descendants:
sync_update_account_number_in_child(descendants, old_acc_name,
account_name, account_number,
old_acc_number)
new_name = get_account_autoname(account_number, account_name,
account.company)
if name != new_name:
frappe.rename_doc("Account", name, new_name, force=1)
return new_name
def get_territory_ancestry(self, territory):
if not hasattr(self, "_territory_ancestry"):
self._territory_ancestry = {}
if not self._territory_ancestry.get(territory):
self._territory_ancestry[territory] = get_ancestors_of("Territory", territory)
return self._territory_ancestry[territory]
def get_territory_ancestry(self, territory):
if not hasattr(self, "_territory_ancestry"):
self._territory_ancestry = {}
if not self._territory_ancestry.get(territory):
self._territory_ancestry[territory] = get_ancestors_of("Territory", territory)
return self._territory_ancestry[territory]
def get_customer_territory(customer):
customer_territories = []
customer_territory = frappe.db.get_value("Customer", customer,
"territory") if customer else None
if customer_territory:
ancestors = get_ancestors_of("Territory", customer_territory)
customer_territories = [customer_territory] + ancestors
return customer_territories
def get_customer_group(customer):
customer_groups = []
customer_group = frappe.db.get_value(
"Customer", customer, "customer_group") if customer else None
if customer_group:
ancestors = get_ancestors_of("Customer Group", customer_group)
customer_groups = [customer_group] + ancestors
return customer_groups
def get_territory_ancestry(self, territory):
from frappe.utils.nestedset import get_ancestors_of
if not hasattr(self, "_territory_ancestry"):
self._territory_ancestry = {}
if not self._territory_ancestry.get(territory):
self._territory_ancestry[territory] = get_ancestors_of("Territory", territory)
return self._territory_ancestry[territory]
def get_stock_owner_via_sales_person_tree(person):
"""
checks sales persons hierarchy and return group person if found. if person is not a sales person
returns none
:param person:
:return:
"""
if not frappe.db.exists("Sales Person", person):
return None
from frappe.utils import nestedset
sales_person = frappe.get_doc("Sales Person", person)
return sales_person.name if sales_person.is_group == 'Yes' else \
nestedset.get_ancestors_of("Sales Person", person)[0]
def get_root_company(company):
# return the topmost company in the hierarchy
ancestors = get_ancestors_of('Company', company, "lft asc")
return [ancestors[0]] if ancestors else []
def get_root_company(company):
# return the topmost company in the hierarchy
ancestors = get_ancestors_of('Company', company, "lft asc")
return [ancestors[0]] if ancestors else []
