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_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 []