예제 #1
0
	def test_import_only_children(self):
		user_email = "*****@*****.**"
		if frappe.db.exists("User", user_email):
			frappe.delete_doc("User", user_email)

		frappe.get_doc({"doctype": "User", "email": user_email, "first_name": "Test Import UserRole"}).insert()

		exporter.get_template("UserRole", "User", all_doctypes="No", with_data="No")
		content = read_csv_content(frappe.response.result)
		content.append(["", "*****@*****.**", "Blogger"])
		importer.upload(content)

		user = frappe.get_doc("User", user_email)
		self.assertEquals(len(user.get("user_roles")), 1)
		self.assertTrue(user.get("user_roles")[0].role, "Blogger")

		# overwrite
		exporter.get_template("UserRole", "User", all_doctypes="No", with_data="No")
		content = read_csv_content(frappe.response.result)
		content.append(["", "*****@*****.**", "Website Manager"])
		importer.upload(content, overwrite=True)

		user = frappe.get_doc("User", user_email)
		self.assertEquals(len(user.get("user_roles")), 1)
		self.assertTrue(user.get("user_roles")[0].role, "Website Manager")
예제 #2
0
파일: item.py 프로젝트: nishta/planning
	def sync_variants(self):
		variant_item_codes = self.get_variant_item_codes()

		# delete missing variants
		existing_variants = [d.name for d in frappe.get_all("Item",
			filters={"variant_of":self.name})]

		updated, deleted = [], []
		for existing_variant in existing_variants:
			if existing_variant not in variant_item_codes:
				frappe.delete_doc("Item", existing_variant)
				deleted.append(existing_variant)
			else:
				self.update_variant(existing_variant)
				updated.append(existing_variant)

		inserted = []
		for item_code in variant_item_codes:
			if item_code not in existing_variants:
				self.make_variant(item_code)
				inserted.append(item_code)

		if inserted:
			frappe.msgprint(_("Item Variants {0} created").format(", ".join(inserted)))

		if updated:
			frappe.msgprint(_("Item Variants {0} updated").format(", ".join(updated)))

		if deleted:
			frappe.msgprint(_("Item Variants {0} deleted").format(", ".join(deleted)))
예제 #3
0
def execute():
	if frappe.db.exists('DocType', 'View log'):
		# for mac users direct renaming would not work since mysql for mac saves table name in lower case
		# so while renaming `tabView log` to `tabView Log` we get "Table 'tabView Log' already exists" error
		# more info https://stackoverflow.com/a/44753093/5955589 ,
		# https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_lower_case_table_names

		# here we are creating a temp table to store view log data
		frappe.db.sql("CREATE TABLE `ViewLogTemp` AS SELECT * FROM `tabView log`")

		# deleting old View log table
		frappe.db.sql("DROP table `tabView log`")
		frappe.delete_doc('DocType', 'View log')

		# reloading view log doctype to create `tabView Log` table
		frappe.reload_doc('core', 'doctype', 'view_log')

		# Move the data to newly created `tabView Log` table
		frappe.db.sql("INSERT INTO `tabView Log` SELECT * FROM `ViewLogTemp`")
		frappe.db.commit()

		# Delete temporary table
		frappe.db.sql("DROP table `ViewLogTemp`")
	else:
		frappe.reload_doc('core', 'doctype', 'view_log')
예제 #4
0
	def test_coa_based_on_existing_company(self):
		company = frappe.new_doc("Company")
		company.company_name = "COA from Existing Company"
		company.abbr = "CFEC"
		company.default_currency = "INR"
		company.create_chart_of_accounts_based_on = "Existing Company"
		company.existing_company = "_Test Company"
		company.save()
		
		expected_results = {
			"Debtors - CFEC": {
				"account_type": "Receivable",
				"is_group": 0,
				"root_type": "Asset",
				"parent_account": "Accounts Receivable - CFEC",
			},
			"_Test Cash - CFEC": {
				"account_type": "Cash",
				"is_group": 0,
				"root_type": "Asset",
				"parent_account": "Cash In Hand - CFEC"
			}
		}
		
		for account, acc_property in expected_results.items():
			acc = frappe.get_doc("Account", account)
			for prop, val in acc_property.items():
				self.assertEqual(acc.get(prop), val)

		self.delete_mode_of_payment("COA from Existing Company")
		frappe.delete_doc("Company", "COA from Existing Company")
def execute():
	frappe.reload_doc("accounts", "doctype", "pricing_rule")
	
	frappe.db.auto_commit_on_many_writes = True
	
	for d in frappe.db.sql("""select * from `tabCustomer Discount` 
		where ifnull(parent, '') != '' and docstatus < 2""", as_dict=1):
			if not d.item_group:
				item_group = frappe.db.sql("""select name from `tabItem Group` 
					where ifnull(parent_item_group, '') = ''""")[0][0]
			else:
				item_group = d.item_group
				
			frappe.get_doc({
				"doctype": "Pricing Rule",
				"apply_on": "Item Group",
				"item_group": item_group,
				"applicable_for": "Customer",
				"customer": d.parent,
				"price_or_discount": "Discount",
				"discount_percentage": d.discount
			}).insert()
	
	frappe.db.auto_commit_on_many_writes = False		
	
	frappe.delete_doc("DocType", "Customer Discount")
예제 #6
0
        def remove_sal_slip(self):
		cond = ''
		for f in ['company', 'branch', 'department', 'division', 'designation', 'employee']:
			if self.get(f):
				cond += " and t1." + f + " = '" + self.get(f).replace("'", "\'") + "'"
                
                ss_list = frappe.db.sql_list("""
                                select t1.name from `tabSalary Slip` as t1
                                where t1.fiscal_year = '%s'
                                and t1.month = '%s'
                                and t1.docstatus = 0
                                %s
                                """ % (self.fiscal_year, self.month, cond))
                                
                if ss_list:
                        frappe.delete_doc("Salary Slip", frappe.db.sql_list("""
                                select t1.name from `tabSalary Slip` as t1
                                where t1.fiscal_year = '%s'
                                and t1.month = '%s'
                                and t1.docstatus = 0
                                %s
                                """ % (self.fiscal_year, self.month, cond)), for_reload=True)
                        frappe.msgprint(_("Un-submitted Salary Slip(s) for the Month:{0} and Year:{1} removed successfully.")\
                                        .format(self.month, self.fiscal_year))
                else:
                        frappe.msgprint(_("No Un-submitted Salary Slip(s) Found."))
예제 #7
0
	def test_auto_insert_price(self):
		from erpnext.stock.doctype.item.test_item import make_item
		make_item("_Test Item for Auto Price List", {"is_stock_item": 0})
		frappe.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 1)

		item_price = frappe.db.get_value("Item Price", {"price_list": "_Test Price List",
			"item_code": "_Test Item for Auto Price List"})
		if item_price:
			frappe.delete_doc("Item Price", item_price)

		make_sales_order(item_code = "_Test Item for Auto Price List", selling_price_list="_Test Price List", rate=100)

		self.assertEquals(frappe.db.get_value("Item Price",
			{"price_list": "_Test Price List", "item_code": "_Test Item for Auto Price List"}, "price_list_rate"), 100)


		# do not update price list
		frappe.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 0)

		item_price = frappe.db.get_value("Item Price", {"price_list": "_Test Price List",
			"item_code": "_Test Item for Auto Price List"})
		if item_price:
			frappe.delete_doc("Item Price", item_price)

		make_sales_order(item_code = "_Test Item for Auto Price List", selling_price_list="_Test Price List", rate=100)

		self.assertEquals(frappe.db.get_value("Item Price",
			{"price_list": "_Test Price List", "item_code": "_Test Item for Auto Price List"}, "price_list_rate"), None)

		frappe.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 1)
예제 #8
0
파일: file.py 프로젝트: frappe/frappe
    def unzip(self):
        """Unzip current file and replace it by its children"""
        if not ".zip" in self.file_name:
            frappe.msgprint(_("Not a zip file"))
            return

        zip_path = frappe.get_site_path(self.file_url.strip("/"))
        base_url = os.path.dirname(self.file_url)
        with zipfile.ZipFile(zip_path) as zf:
            zf.extractall(os.path.dirname(zip_path))
            for info in zf.infolist():
                if not info.filename.startswith("__MACOSX"):
                    file_url = file_url = base_url + "/" + info.filename
                    file_name = frappe.db.get_value("File", dict(file_url=file_url))
                    if file_name:
                        file_doc = frappe.get_doc("File", file_name)
                    else:
                        file_doc = frappe.new_doc("File")
                    file_doc.file_name = info.filename
                    file_doc.file_size = info.file_size
                    file_doc.folder = self.folder
                    file_doc.is_private = self.is_private
                    file_doc.file_url = file_url
                    file_doc.attached_to_doctype = self.attached_to_doctype
                    file_doc.attached_to_name = self.attached_to_name
                    file_doc.save()

        frappe.delete_doc("File", self.name)
예제 #9
0
def setup_charts(delete_existing=True):
	frappe.local.flags.allow_unverified_charts = True

	# delete
	if delete_existing:
		for company in frappe.get_all("Company"):
			if company.name not in ("Wind Power LLC", "Test Company"):
				print "deleting {0}".format(company.name)
				frappe.delete_doc("Company", company.name)
				frappe.db.commit()

	print "-"*40
	for country in frappe.get_all("Country", fields=["name", "code"]):
		charts = get_charts_for_country(country.name)
		for i, chart in enumerate(charts):
			if (chart != "Standard" or country.name == "United States"):
				if not frappe.db.exists("Company", chart):
					print chart.encode('utf-8')

					company = frappe.new_doc("Company")
					company.company_name = chart
					company.country = country.name
					company.chart_of_accounts = chart
					company.abbr = country.code + str(i+1)
					company.default_currency = "USD"
					company.insert()
					frappe.db.commit()
예제 #10
0
	def sync_tasks(self):
		"""sync tasks and remove table"""
		if self.flags.dont_sync_tasks: return

		task_names = []
		for t in self.tasks:
			if t.task_id:
				task = frappe.get_doc("Task", t.task_id)
			else:
				task = frappe.new_doc("Task")
				task.project = self.name
			task.update({
				"subject": t.title,
				"status": t.status,
				"exp_start_date": t.start_date,
				"exp_end_date": t.end_date,
				"description": t.description,
				"task_weight": t.task_weight
			})

			task.flags.ignore_links = True
			task.flags.from_project = True
			task.flags.ignore_feed = True
			task.save(ignore_permissions = True)
			task_names.append(task.name)

		# delete
		for t in frappe.get_all("Task", ["name"], {"project": self.name, "name": ("not in", task_names)}):
			frappe.delete_doc("Task", t.name)

		self.update_percent_complete()
		self.update_costing()
예제 #11
0
def execute():
	frappe.reload_doc("core", "doctype", "docperm")
	frappe.reload_doc("core", "doctype", "docshare")
	frappe.reload_doc('email', 'doctype', 'email_account')

	# default share to all writes
	frappe.db.sql("""update tabDocPerm set `share`=1 where ifnull(`write`,0)=1 and ifnull(`permlevel`,0)=0""")

	# every user must have access to his / her own detail
	users = frappe.get_all("User", filters={"user_type": "System User"})
	usernames = [user.name for user in users]
	for user in usernames:
		frappe.share.add("User", user, user, share=1)

	# move event user to shared
	if frappe.db.exists("DocType", "Event User"):
		for event in frappe.get_all("Event User", fields=["parent", "person"]):
			if event.person in usernames:
				if not frappe.db.exists("Event", event.parent):
					frappe.db.sql("delete from `tabEvent User` where parent = %s",event.parent)
				else:
					frappe.share.add("Event", event.parent, event.person, write=1)

		frappe.delete_doc("DocType", "Event User")

	# move note user to shared
	if frappe.db.exists("DocType", "Note User"):
		for note in frappe.get_all("Note User", fields=["parent", "user", "permission"]):
			perm = {"read": 1} if note.permission=="Read" else {"write": 1}
			if note.user in usernames:
				frappe.share.add("Note", note.parent, note.user, **perm)

		frappe.delete_doc("DocType", "Note User")
예제 #12
0
def import_doc(docdict, force=False, data_import=False, pre_process=None):
	frappe.flags.in_import = True
	docdict["__islocal"] = 1
	doc = frappe.get_doc(docdict)
	if pre_process:
		pre_process(doc)

	ignore = []

	if frappe.db.exists(doc.doctype, doc.name):
		old_doc = frappe.get_doc(doc.doctype, doc.name)

		if doc.doctype in ignore_values and not force:
			# update ignore values
			for key in ignore_values.get(doc.doctype) or []:
				doc.set(key, old_doc.get(key))

		# update ignored docs into new doc
		for df in doc.meta.get_table_fields():
			if df.options in ignore_doctypes and not force:
				doc.set(df.fieldname, [])
				ignore.append(df.options)

		# delete old
		frappe.delete_doc(doc.doctype, doc.name, force=1, ignore_doctypes=ignore, for_reload=True)

	doc.flags.ignore_children_type = ignore
	doc.flags.ignore_links = True
	if not data_import:
		doc.flags.ignore_validate = True
		doc.flags.ignore_permissions = True
		doc.flags.ignore_mandatory = True
	doc.insert()

	frappe.flags.in_import = False
	def test_time_log_batch(self):
		delete_time_log_and_batch()
		time_log = create_time_log()
		tlb = create_time_log_batch(time_log)

		tlb = frappe.get_doc("Time Log Batch", tlb.name)
		tlb.submit()

		si = frappe.get_doc(frappe.copy_doc(test_records[0]))
		si.get("entries")[0].time_log_batch = tlb.name
		si.insert()
		si.submit()

		self.assertEquals(frappe.db.get_value("Time Log Batch", tlb.name, "status"), "Billed")

		self.assertEquals(frappe.db.get_value("Time Log", time_log, "status"), "Billed")

		si.cancel()

		self.assertEquals(frappe.db.get_value("Time Log Batch", tlb.name, "status"), "Submitted")

		self.assertEquals(frappe.db.get_value("Time Log", time_log, "status"), "Batched for Billing")

		frappe.delete_doc("Sales Invoice", si.name)
		delete_time_log_and_batch()
예제 #14
0
    def delete_supplier_contact(self):
        for contact in frappe.db.sql_list(
            """select name from `tabContact`
			where supplier=%s""",
            self.name,
        ):
            frappe.delete_doc("Contact", contact)
예제 #15
0
	def on_trash(self):
		# remove template refernce from item and disable item
		if(self.item):
			try:
				frappe.delete_doc("Item",self.item, force=True)
			except Exception:
				frappe.throw(_("""Not permitted. Please disable the Test Template"""))
예제 #16
0
	def delete_task(self):
		if not self.get('deleted_task_list'): return

		for d in self.get('deleted_task_list'):
			frappe.delete_doc("Task", d)

		self.deleted_task_list = []
def on_packing_slip_cancel(doc, method):
    # delete the packing slip details entry from delivery note

    delivery_note = doc.delivery_note
    dn = frappe.get_doc("Delivery Note", delivery_note)

    if dn.docstatus == 1:
        frappe.throw("Packing Slip is Linked with Submitted Delivery Note : %s"%dn.name)
    elif dn.docstatus == 0:
        if dn.dn_status not in ["Draft","Packing Slips Created","Partialy Packed"]:
            frappe.throw("Delivery Note is in Freezed state can not cancel the Packing Slip")
        else:
            to_remove = []
            for ps in dn.packing_slip_details:
                if ps.packing_slip == doc.name:
                    to_remove.append(ps)
            if to_remove:
                [dn.remove(ch) for ch in to_remove]
                if not dn.packing_slip_details:
                    dn.dn_status = "Draft"
                    dn.not_packed_items = json.dumps({})
                else:
                    dn.dn_status = "Partialy Packed"
                    not_packed_items = json.loads(dn.not_packed_items)
                    for item in doc.bin_items:
                        qty = not_packed_items.get(item.item_code) + 1 if not_packed_items.get(item.item_code) else 1
                        not_packed_items.update({
                            item.item_code: qty
                        })
                    dn.not_packed_items = json.dumps(not_packed_items)
                dn.save(ignore_permissions = True)

                frappe.delete_doc("Packing Slip",doc.name, ignore_permissions=True)
예제 #18
0
파일: installer.py 프로젝트: ibratro/frappe
def remove_app(app_name, dry_run=False):
	"""Delete app and all linked to the app's module with the app."""

	if not dry_run:
		confirm = raw_input("All doctypes (including custom), modules related to this app will be deleted. Are you sure you want to continue (y/n) ? ")
		if confirm!="y":
			return

	from frappe.utils.backups import scheduled_backup
	print "Backing up..."
	scheduled_backup(ignore_files=True)

	# remove modules, doctypes, roles
	for module_name in frappe.get_module_list(app_name):
		for doctype in frappe.get_list("DocType", filters={"module": module_name},
			fields=["name", "issingle"]):
			print "removing {0}...".format(doctype.name)
			# drop table

			if not dry_run:
				if not doctype.issingle:
					frappe.db.sql("drop table `tab{0}`".format(doctype.name))
				frappe.delete_doc("DocType", doctype.name)

		print "removing Module {0}...".format(module_name)
		if not dry_run:
			frappe.delete_doc("Module Def", module_name)

	remove_from_installed_apps(app_name)
예제 #19
0
def setup_charts():
	frappe.local.flags.allow_unverified_charts = True

	# delete
	for company in frappe.get_all("Company"):
		if company.name != "Wind Power LLC":
			print "deleting {0}".format(company.name)
			frappe.delete_doc("Company", company.name)
			frappe.db.commit()

	for country in frappe.get_all("Country", fields=["name", "code"]):
		if country.name in countries:
			print "creating for {0}".format(country.name)

			charts = get_charts_for_country(country.name)

			for i, chart in enumerate(charts):
				company = frappe.new_doc("Company")
				company.company_name = "{0} - {1}".format(country.name, chart)
				company.country = country.name
				company.chart_of_accounts = chart
				company.abbr = country.code + str(i)
				company.default_currency = "USD"
				company.insert()
				frappe.db.commit()
예제 #20
0
	def test_asset_sale(self):
		frappe.get_doc("Asset", "Macbook Pro 1").submit()
		post_depreciation_entries(date="2021-01-01")

		si = make_sales_invoice(asset="Macbook Pro 1", item_code="Macbook Pro", company="_Test Company")
		si.customer = "_Test Customer"
		si.due_date = nowdate()
		si.get("items")[0].rate = 25000
		si.insert()
		si.submit()

		self.assertEqual(frappe.db.get_value("Asset", "Macbook Pro 1", "status"), "Sold")

		expected_gle = (
			("_Test Accumulated Depreciations - _TC", 30000.0, 0.0),
			("_Test Fixed Asset - _TC", 0.0, 100000.0),
			("_Test Gain/Loss on Asset Disposal - _TC", 45000.0, 0.0),
			("Debtors - _TC", 25000.0, 0.0)
		)

		gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
			where voucher_type='Sales Invoice' and voucher_no = %s
			order by account""", si.name)

		self.assertEqual(gle, expected_gle)

		si.cancel()
		frappe.delete_doc("Sales Invoice", si.name)

		self.assertEqual(frappe.db.get_value("Asset", "Macbook Pro 1", "status"), "Partially Depreciated")
예제 #21
0
	def test_rename_account(self):
		if not frappe.db.exists("Account", "1210 - Debtors - _TC"):
			acc = frappe.new_doc("Account")
			acc.account_name = "Debtors"
			acc.parent_account = "Accounts Receivable - _TC"
			acc.account_number = "1210"
			acc.company = "_Test Company"
			acc.insert()

		account_number, account_name = frappe.db.get_value("Account", "1210 - Debtors - _TC",
			["account_number", "account_name"])
		self.assertEqual(account_number, "1210")
		self.assertEqual(account_name, "Debtors")

		frappe.rename_doc("Account", "1210 - Debtors - _TC", "1211 - Debtors 1 - _TC")

		new_acc = frappe.db.get_value("Account", "1211 - Debtors 1 - _TC",
			["account_name", "account_number"], as_dict=1)
		self.assertEqual(new_acc.account_name, "Debtors 1")
		self.assertEqual(new_acc.account_number, "1211")

		frappe.rename_doc("Account", "1211 - Debtors 1 - _TC", "Debtors 2")

		new_acc = frappe.db.get_value("Account", "1211 - Debtors 2 - _TC",
			["account_name", "account_number"], as_dict=1)
		self.assertEqual(new_acc.account_name, "Debtors 2")
		self.assertEqual(new_acc.account_number, "1211")

		frappe.delete_doc("Account", "1211 - Debtors 2 - _TC")
def execute():
	if frappe.db.table_exists("Offer Letter") and not frappe.db.table_exists("Job Offer"):
		frappe.rename_doc("DocType", "Offer Letter", "Job Offer", force=True)
		frappe.rename_doc("DocType", "Offer Letter Term", "Job Offer Term", force=True)
		frappe.reload_doc("hr", "doctype", "job_offer")
		frappe.reload_doc("hr", "doctype", "job_offer_term")
		frappe.delete_doc("Print Format", "Offer Letter")
예제 #23
0
def execute():
	frappe.reload_doctype("Email Digest")
	frappe.db.sql("""update `tabEmail Digest` set expense_year_to_date =
		income_year_to_date""")

	if frappe.db.exists("Email Digest", "Scheduler Errors"):
		frappe.delete_doc("Email Digest", "Scheduler Errors")
예제 #24
0
	def insert_web_page(self, route, fpath, page_name, priority, parent_website_route):
		page = frappe.get_doc({
			"doctype":"Web Page",
			"idx": priority,
			"page_name": page_name,
			"published": 1,
			"parent_website_route": parent_website_route
		})

		page.update(get_static_content(fpath, page_name, route))

		try:
			page.insert()
		except frappe.NameError:
			# page exists, if deleted static, delete it and try again
			old_route = frappe.get_doc("Website Route", {"ref_doctype":"Web Page",
				"docname": page.name})
			if old_route.static_file_timestamp and not os.path.exists(os.path.join(self.statics_path,
				old_route.name)):

				frappe.delete_doc("Web Page", page.name)
				page.insert() # retry


		# update timestamp
		route_doc = frappe.get_doc("Website Route", {"ref_doctype": "Web Page",
			"docname": page.name})
		route_doc.static_file_timestamp = cint(os.path.getmtime(fpath))
		route_doc.save()

		self.updated += 1
		print route_doc.name + " inserted"
		self.synced.append(route)
예제 #25
0
	def delete_existing_property_setter(self, property, fieldname=None):
		# first delete existing property setter
		existing_property_setter = frappe.db.get_value("Property Setter", {"doc_type": self.doc_type,
			"property": property, "field_name['']": fieldname or ''})

		if existing_property_setter:
			frappe.delete_doc("Property Setter", existing_property_setter)
예제 #26
0
    def test_save_customization_idx(self):
        d = self.get_customize_form("User")
        original_sequence = [df.fieldname for df in d.get("fields")]

        # move field to last
        location_field = d.get("fields", {"fieldname": "location"})[0]
        d.get("fields").remove(location_field)
        d.append("fields", location_field)
        d.run_method("save_customization")
        frappe.clear_cache(doctype=d.doc_type)

        property_setter_name, _idx = frappe.db.get_value(
            "Property Setter", {"doc_type": d.doc_type, "property": "_idx"}, ("name", "value")
        )
        self.assertTrue(_idx)

        _idx = json.loads(_idx)
        for i, df in enumerate(frappe.get_meta(d.doc_type).get("fields")):
            self.assertEquals(_idx[i], df.fieldname)

        frappe.delete_doc("Property Setter", property_setter_name)
        frappe.clear_cache(doctype=d.doc_type)

        for i, df in enumerate(frappe.get_meta(d.doc_type).get("fields")):
            self.assertEquals(original_sequence[i], df.fieldname)
예제 #27
0
def execute():
	# convert milestones to tasks
	frappe.reload_doctype("Project")
	frappe.reload_doc("projects", "doctype", "project_task")
	frappe.reload_doctype("Task")
	frappe.reload_doc("projects", "doctype", "task_depends_on")

	for m in frappe.get_all("Project Milestone", "*"):
		if (m.milestone and m.milestone_date
			and frappe.db.exists("Project", m.parent)):
			task = frappe.get_doc({
				"doctype": "Task",
				"subject": m.milestone,
				"expected_start_date": m.milestone_date,
				"status": "Open" if m.status=="Pending" else "Closed",
				"project": m.parent,
			})
			task.flags.ignore_mandatory = True
			task.insert(ignore_permissions=True)

	# remove project milestone
	frappe.delete_doc("DocType", "Project Milestone")

	# remove calendar events for milestone
	for e in frappe.get_all("Event", ["name"], {"ref_type": "Project"}):
		frappe.delete_doc("Event", e.name)
예제 #28
0
    def on_trash(self):
        # delete bin
        bins = frappe.db.sql("select * from `tabBin` where warehouse = %s", self.name, as_dict=1)
        for d in bins:
            if (
                d["actual_qty"]
                or d["reserved_qty"]
                or d["ordered_qty"]
                or d["indented_qty"]
                or d["projected_qty"]
                or d["planned_qty"]
            ):
                throw(
                    _("Warehouse {0} can not be deleted as quantity exists for Item {1}").format(
                        self.name, d["item_code"]
                    )
                )
            else:
                frappe.db.sql("delete from `tabBin` where name = %s", d["name"])

        warehouse_account = self.get_account(self.name)
        if warehouse_account:
            frappe.delete_doc("Account", warehouse_account)

        if self.check_if_sle_exists():
            throw(_("Warehouse can not be deleted as stock ledger entry exists for this warehouse."))

        if self.check_if_child_exists():
            throw(_("Child warehouse exists for this warehouse. You can not delete this warehouse."))

        self.update_nsm_model()
예제 #29
0
	def set_property_setter_for_idx(self):
		dt_meta = frappe.get_meta(self.dt)
		self.validate_insert_after(dt_meta)

		_idx = []

		existing_property_setter = frappe.db.get_value("Property Setter",
			{"doc_type": self.dt, "property": "_idx"}, ["name", "value"], as_dict=1)

		# if no existsing property setter, build based on meta
		if not existing_property_setter:
			for df in sorted(dt_meta.get("fields"), key=lambda x: x.idx):
				if df.fieldname != self.fieldname:
					_idx.append(df.fieldname)
		else:
			_idx = json.loads(existing_property_setter.value)

			# Delete existing property setter if field is not there
			if self.fieldname not in _idx:
				frappe.delete_doc("Property Setter", existing_property_setter.name)
				existing_property_setter = None

		# Create new peroperty setter if order changed
		if _idx and not existing_property_setter:
			field_idx = (_idx.index(self.insert_after) + 1) if (self.insert_after in _idx) else len(_idx)

			_idx.insert(field_idx, self.fieldname)

			frappe.make_property_setter({
				"doctype":self.dt,
				"doctype_or_field": "DocType",
				"property": "_idx",
				"value": json.dumps(_idx),
				"property_type": "Text"
			}, validate_fields_for_doctype=False)
예제 #30
0
def execute():
	frappe.reload_doctype("Web Form")
	frappe.delete_doc("Web Form", "Issues")
	frappe.delete_doc("Web Form", "Addresses")

	from erpnext.setup.install import add_web_forms
	add_web_forms()
예제 #31
0
def execute():

    frappe.db.sql("""update `tabPrint Format` set disabled=1 
		where name='fatura_6' and module ='Angola ERPNext' """)

    frappe.delete_doc("DocType", "TestGRID")
예제 #32
0
 def delete_job_card(self):
     for d in frappe.get_all("Job Card", ["name"],
                             {"work_order": self.name}):
         frappe.delete_doc("Job Card", d.name)
예제 #33
0
def delete_ip_medication_order(encounter):
	record = frappe.db.exists('Inpatient Medication Order', {'patient_encounter': encounter.name})
	if record:
		frappe.delete_doc('Inpatient Medication Order', record, force=1)
예제 #34
0
def delete_invoice(invoice):
    frappe.delete_doc("Sales Invoice", invoice, force=1)
    return "Inovice {0} Deleted".format(invoice)
예제 #35
0
    def delete_test_data(self):
        for f in frappe.db.sql('''select name, file_name from tabFile where
			is_home_folder = 0 and is_attachments_folder = 0 order by creation desc'''):
            frappe.delete_doc("File", f[0])
예제 #36
0
	def create_delete_custom_fields(self):
		if self.enable_sync:
			# create
			create_custom_field_id_and_check_status = False
			create_custom_field_email_check = False
			names = ["Customer-woocommerce_id","Sales Order-woocommerce_id","Item-woocommerce_id","Address-woocommerce_id"]
			names_check_box = ["Customer-woocommerce_check","Sales Order-woocommerce_check","Item-woocommerce_check","Address-woocommerce_check"]
			email_names = ["Customer-woocommerce_email","Address-woocommerce_email"]

			for i in zip(names,names_check_box):

				if not frappe.get_value("Custom Field",{"name":i[0]}) or not frappe.get_value("Custom Field",{"name":i[1]}):
					create_custom_field_id_and_check_status = True
					break


			if create_custom_field_id_and_check_status:
				names = ["Customer","Sales Order","Item","Address"]
				for name in names:
					custom = frappe.new_doc("Custom Field")
					custom.dt = name
					custom.label = "woocommerce_id"
					custom.read_only = 1
					custom.save()

					custom = frappe.new_doc("Custom Field")
					custom.dt = name
					custom.label = "woocommerce_check"
					custom.fieldtype = "Check"
					custom.read_only = 1
					custom.save()

			for i in email_names:

				if not frappe.get_value("Custom Field",{"name":i}):
					create_custom_field_email_check = True
					break;

			if create_custom_field_email_check:
				names = ["Customer","Address"]
				for name in names:
					custom = frappe.new_doc("Custom Field")
					custom.dt = name
					custom.label = "woocommerce_email"
					custom.read_only = 1
					custom.save()

			if not frappe.get_value("Item Group",{"name": "WooCommerce Products"}):
				item_group = frappe.new_doc("Item Group")
				item_group.item_group_name = "WooCommerce Products"
				item_group.parent_item_group = _("All Item Groups")
				item_group.save()


		elif not self.enable_sync:
			# delete
			names = ["Customer-woocommerce_id","Sales Order-woocommerce_id","Item-woocommerce_id","Address-woocommerce_id"]
			names_check_box = ["Customer-woocommerce_check","Sales Order-woocommerce_check","Item-woocommerce_check","Address-woocommerce_check"]
			email_names = ["Customer-woocommerce_email","Address-woocommerce_email"]
			for name in names:
				frappe.delete_doc("Custom Field",name)

			for name in names_check_box:
				frappe.delete_doc("Custom Field",name)

			for name in email_names:
				frappe.delete_doc("Custom Field",name)

			frappe.delete_doc("Item Group","WooCommerce Products")

		frappe.db.commit()
예제 #37
0
 def tearDown(self):
     frappe.delete_doc("Custom Field", "User-test_custom_field")
     frappe.db.commit()
     frappe.clear_cache(doctype="User")
예제 #38
0
def delete_vital_signs_from_medical_record(doc):
	medical_record_id = frappe.db.sql("select name from `tabPatient Medical Record` where reference_name=%s",(doc.name))
	if medical_record_id and medical_record_id[0][0]:
		frappe.delete_doc("Patient Medical Record", medical_record_id[0][0])
예제 #39
0
 def tearDown(self):
     frappe.delete_doc('Cash Flow Mapping', 'Test Mapping')
예제 #40
0
 def on_trash(self):
     for dev in self.devices:
         frappe.delete_doc("IOT Device Config", dev.device)
예제 #41
0
def clean_doc(doc_type, doc_id):
	for d in frappe.db.get_values("Wechat Send Doc", {"document_type": doc_type, "document_id": doc_id}, "name"):
		frappe.delete_doc("Wechat Send Doc", d[0])
예제 #42
0
 def setUp(self):
     if frappe.db.exists("Cash Flow Mapping", "Test Mapping"):
         frappe.delete_doc('Cash Flow Mappping', 'Test Mapping')
예제 #43
0
 def on_trash(self):
     if self.script_type == "Scheduler Event":
         for job in self.scheduled_jobs:
             frappe.delete_doc("Scheduled Job Type", job.name)
예제 #44
0
 def clear_scheduled_events(self):
     """Deletes existing scheduled jobs by Server Script if self.event_frequency has changed"""
     if self.script_type == "Scheduler Event" and self.has_value_changed(
             "event_frequency"):
         for scheduled_job in self.scheduled_jobs:
             frappe.delete_doc("Scheduled Job Type", scheduled_job.name)
예제 #45
0
    def test_db_keywords_as_fields(self):
        """Tests if DB keywords work as docfield names. If they're wrapped with grave accents."""
        # Using random.choices, picked out a list of 40 keywords for testing
        all_keywords = {
            "mariadb": [
                "CHARACTER",
                "DELAYED",
                "LINES",
                "EXISTS",
                "YEAR_MONTH",
                "LOCALTIME",
                "BOTH",
                "MEDIUMINT",
                "LEFT",
                "BINARY",
                "DEFAULT",
                "KILL",
                "WRITE",
                "SQL_SMALL_RESULT",
                "CURRENT_TIME",
                "CROSS",
                "INHERITS",
                "SELECT",
                "TABLE",
                "ALTER",
                "CURRENT_TIMESTAMP",
                "XOR",
                "CASE",
                "ALL",
                "WHERE",
                "INT",
                "TO",
                "SOME",
                "DAY_MINUTE",
                "ERRORS",
                "OPTIMIZE",
                "REPLACE",
                "HIGH_PRIORITY",
                "VARBINARY",
                "HELP",
                "IS",
                "CHAR",
                "DESCRIBE",
                "KEY",
            ],
            "postgres": [
                "WORK",
                "LANCOMPILER",
                "REAL",
                "HAVING",
                "REPEATABLE",
                "DATA",
                "USING",
                "BIT",
                "DEALLOCATE",
                "SERIALIZABLE",
                "CURSOR",
                "INHERITS",
                "ARRAY",
                "TRUE",
                "IGNORE",
                "PARAMETER_MODE",
                "ROW",
                "CHECKPOINT",
                "SHOW",
                "BY",
                "SIZE",
                "SCALE",
                "UNENCRYPTED",
                "WITH",
                "AND",
                "CONVERT",
                "FIRST",
                "SCOPE",
                "WRITE",
                "INTERVAL",
                "CHARACTER_SET_SCHEMA",
                "ADD",
                "SCROLL",
                "NULL",
                "WHEN",
                "TRANSACTION_ACTIVE",
                "INT",
                "FORTRAN",
                "STABLE",
            ],
        }
        created_docs = []

        # edit by rushabh: added [:1]
        # don't run every keyword! - if one works, they all do
        fields = all_keywords[frappe.conf.db_type][:1]
        test_doctype = "ToDo"

        def add_custom_field(field):
            create_custom_field(
                test_doctype,
                {
                    "fieldname": field.lower(),
                    "label": field.title(),
                    "fieldtype": "Data",
                },
            )

        # Create custom fields for test_doctype
        for field in fields:
            add_custom_field(field)

        # Create documents under that doctype and query them via ORM
        for _ in range(10):
            docfields = {key.lower(): random_string(10) for key in fields}
            doc = frappe.get_doc({
                "doctype": test_doctype,
                "description": random_string(20),
                **docfields
            })
            doc.insert()
            created_docs.append(doc.name)

        random_field = choice(fields).lower()
        random_doc = choice(created_docs)
        random_value = random_string(20)

        # Testing read
        self.assertEqual(
            list(frappe.get_all("ToDo", fields=[random_field], limit=1)[0])[0],
            random_field)
        self.assertEqual(
            list(
                frappe.get_all("ToDo",
                               fields=[f"`{random_field}` as total"],
                               limit=1)[0])[0], "total")

        # Testing read for distinct and sql functions
        self.assertEqual(
            list(
                frappe.get_all(
                    "ToDo",
                    fields=[f"`{random_field}` as total"],
                    distinct=True,
                    limit=1,
                )[0])[0],
            "total",
        )
        self.assertEqual(
            list(
                frappe.get_all(
                    "ToDo",
                    fields=[f"`{random_field}`"],
                    distinct=True,
                    limit=1,
                )[0])[0],
            random_field,
        )
        self.assertEqual(
            list(
                frappe.get_all("ToDo",
                               fields=[f"count(`{random_field}`)"],
                               limit=1)[0])[0],
            "count" if frappe.conf.db_type == "postgres" else
            f"count(`{random_field}`)",
        )

        # Testing update
        frappe.db.set_value(test_doctype, random_doc, random_field,
                            random_value)
        self.assertEqual(
            frappe.db.get_value(test_doctype, random_doc, random_field),
            random_value)

        # Cleanup - delete records and remove custom fields
        for doc in created_docs:
            frappe.delete_doc(test_doctype, doc)
        clear_custom_fields(test_doctype)
 def delete_timesheet(self):
     for timesheet in frappe.get_all("Timesheet", ["name"],
                                     {"production_order": self.name}):
         frappe.delete_doc("Timesheet", timesheet.name)
예제 #47
0
	def delete_supplier_contact(self):
		for contact in frappe.db.sql_list("""select name from `tabContact`
			where supplier=%s""", self.name):
				frappe.delete_doc("Contact", contact)
예제 #48
0
파일: rename_doc.py 프로젝트: moh5q/erpnext
def rename_doc(doctype,
               old,
               new,
               force=False,
               merge=False,
               ignore_permissions=False,
               ignore_if_exists=False):
    """
		Renames a doc(dt, old) to doc(dt, new) and
		updates all linked fields of type "Link"
	"""
    if not frappe.db.exists(doctype, old):
        return

    if ignore_if_exists and frappe.db.exists(doctype, new):
        return

    if old == new:
        frappe.msgprint(_('Please select a new name to rename'))
        return

    force = cint(force)
    merge = cint(merge)

    meta = frappe.get_meta(doctype)

    # call before_rename
    old_doc = frappe.get_doc(doctype, old)
    out = old_doc.run_method("before_rename", old, new, merge) or {}
    new = (out.get("new") or new) if isinstance(out, dict) else (out or new)

    if doctype != "DocType":
        new = validate_rename(doctype, new, meta, merge, force,
                              ignore_permissions)

    if not merge:
        rename_parent_and_child(doctype, old, new, meta)

    # update link fields' values
    link_fields = get_link_fields(doctype)
    update_link_field_values(link_fields, old, new, doctype)

    rename_dynamic_links(doctype, old, new)

    # save the user settings in the db
    update_user_settings(old, new, link_fields)

    if doctype == 'DocType':
        rename_doctype(doctype, old, new, force)

    update_attachments(doctype, old, new)

    rename_versions(doctype, old, new)

    # call after_rename
    new_doc = frappe.get_doc(doctype, new)

    # copy any flags if required
    new_doc._local = getattr(old_doc, "_local", None)

    new_doc.run_method("after_rename", old, new, merge)

    if not merge:
        rename_password(doctype, old, new)

    # update user_permissions
    frappe.db.sql(
        """update tabDefaultValue set defvalue=%s where parenttype='User Permission'
		and defkey=%s and defvalue=%s""", (new, doctype, old))

    if merge:
        new_doc.add_comment(
            'Edit',
            _("merged {0} into {1}").format(frappe.bold(old),
                                            frappe.bold(new)))
    else:
        new_doc.add_comment(
            'Edit',
            _("renamed from {0} to {1}").format(frappe.bold(old),
                                                frappe.bold(new)))

    if merge:
        frappe.delete_doc(doctype, old)

    frappe.clear_cache()
    frappe.enqueue('frappe.utils.global_search.rebuild_for_doctype',
                   doctype=doctype)

    return new
예제 #49
0
def delete_custom_role(field, docname):
    name = frappe.db.get_value('Custom Role', {field: docname}, "name")
    if name:
        frappe.delete_doc('Custom Role', name)
예제 #50
0
def handle():
    """
	Handler for `/api` methods

	### Examples:

	`/api/method/{methodname}` will call a whitelisted method

	`/api/resource/{doctype}` will query a table
		examples:
		- `?fields=["name", "owner"]`
		- `?filters=[["Task", "name", "like", "%005"]]`
		- `?limit_start=0`
		- `?limit_page_length=20`

	`/api/resource/{doctype}/{name}` will point to a resource
		`GET` will return doclist
		`POST` will insert
		`PUT` will update
		`DELETE` will delete

	`/api/resource/{doctype}/{name}?run_method={method}` will run a whitelisted controller method
	"""

    validate_oauth()
    validate_auth_via_api_keys()

    parts = frappe.request.path[1:].split("/", 3)
    call = doctype = name = None

    if len(parts) > 1:
        call = parts[1]

    if len(parts) > 2:
        doctype = parts[2]

    if len(parts) > 3:
        name = parts[3]

    if call == "method":
        frappe.local.form_dict.cmd = doctype
        return frappe.handler.handle()

    elif call == "resource":
        if "run_method" in frappe.local.form_dict:
            method = frappe.local.form_dict.pop("run_method")
            doc = frappe.get_doc(doctype, name)
            doc.is_whitelisted(method)

            if frappe.local.request.method == "GET":
                if not doc.has_permission("read"):
                    frappe.throw(_("Not permitted"), frappe.PermissionError)
                frappe.local.response.update(
                    {"data": doc.run_method(method, **frappe.local.form_dict)})

            if frappe.local.request.method == "POST":
                if not doc.has_permission("write"):
                    frappe.throw(_("Not permitted"), frappe.PermissionError)

                frappe.local.response.update(
                    {"data": doc.run_method(method, **frappe.local.form_dict)})
                frappe.db.commit()

        else:
            if name:
                if frappe.local.request.method == "GET":
                    doc = frappe.get_doc(doctype, name)
                    if not doc.has_permission("read"):
                        raise frappe.PermissionError
                    frappe.local.response.update({"data": doc})

                if frappe.local.request.method == "PUT":
                    data = json.loads(frappe.local.form_dict.data)
                    doc = frappe.get_doc(doctype, name)

                    if "flags" in data:
                        del data["flags"]

                    # Not checking permissions here because it's checked in doc.save
                    doc.update(data)

                    frappe.local.response.update(
                        {"data": doc.save().as_dict()})
                    frappe.db.commit()

                if frappe.local.request.method == "DELETE":
                    # Not checking permissions here because it's checked in delete_doc
                    frappe.delete_doc(doctype, name, ignore_missing=False)
                    frappe.local.response.http_status_code = 202
                    frappe.local.response.message = "ok"
                    frappe.db.commit()

            elif doctype:
                if frappe.local.request.method == "GET":
                    if frappe.local.form_dict.get('fields'):
                        frappe.local.form_dict['fields'] = json.loads(
                            frappe.local.form_dict['fields'])
                    frappe.local.form_dict.setdefault('limit_page_length', 20)
                    frappe.local.response.update({
                        "data":
                        frappe.call(frappe.client.get_list, doctype,
                                    **frappe.local.form_dict)
                    })

                if frappe.local.request.method == "POST":
                    if frappe.local.form_dict.data is None:
                        data = json.loads(frappe.local.request.get_data())
                    else:
                        data = json.loads(frappe.local.form_dict.data)
                    data.update({"doctype": doctype})
                    frappe.local.response.update(
                        {"data": frappe.get_doc(data).insert().as_dict()})
                    frappe.db.commit()
            else:
                raise frappe.DoesNotExistError

    else:
        raise frappe.DoesNotExistError

    return build_response("json")
예제 #51
0
def pre_process(events):
    if events["status"] == "cancelled":
        if frappe.db.exists("Event", dict(gcalendar_sync_id=events["id"])):
            e = frappe.get_doc("Event", dict(gcalendar_sync_id=events["id"]))
            frappe.delete_doc("Event", e.name)
        return {}

    elif events["status"] == "confirmed":
        if 'date' in events["start"]:
            datevar = 'date'
            start_dt = parse(events["start"]['date'])
            end_dt = parse(events["end"]['date'])
        elif 'dateTime' in events["start"]:
            datevar = 'dateTime'
            start_dt = parse(events["start"]['dateTime'])
            end_dt = parse(events["end"]['dateTime'])

        if start_dt.tzinfo is None or start_dt.tzinfo.utcoffset(
                start_dt) is None:
            if "timeZone" in events["start"]:
                event_tz = events["start"]["timeZone"]
            else:
                event_tz = events["calendar_tz"]
            start_dt = timezone(event_tz).localize(start_dt)

        if end_dt.tzinfo is None or end_dt.tzinfo.utcoffset(end_dt) is None:
            if "timeZone" in events["end"]:
                event_tz = events["end"]["timeZone"]
            else:
                event_tz = events["calendar_tz"]
            end_dt = timezone(event_tz).localize(end_dt)

        default_tz = frappe.db.get_value("System Settings", None, "time_zone")

        event = {
            'id':
            events["id"],
            'summary':
            events["summary"],
            'start_datetime':
            start_dt.astimezone(
                timezone(default_tz)).strftime('%Y-%m-%d %H:%M:%S'),
            'end_datetime':
            end_dt.astimezone(
                timezone(default_tz)).strftime('%Y-%m-%d %H:%M:%S'),
            'account':
            events['account']
        }

        if "recurrence" in events:
            recurrence = get_recurrence_event_fields_value(
                events['recurrence'][0], events["start"][datevar])

            event.update(recurrence)

        if 'description' in events:
            event.update({'description': events["description"]})
        else:
            event.update({'description': ""})

        if datevar == 'date':
            event.update({'all_day': 1})

        return event
def execute():
    if frappe.db.exists("Custom Field", "Stock Entry-qty"):
        frappe.delete_doc("Custom Field", "Stock Entry-qty", force=True)
    if 'qty' in frappe.db.get_table_columns("Stock Entry"):
        frappe.db.sql_ddl("alter table `tabStock Entry` drop column qty")
예제 #53
0
	def on_trash(self):
		for d in frappe.get_all("Newsletter List Subscriber", "name", {"newsletter_list": self.name}):
			frappe.delete_doc("Newsletter List Subscriber", d.name)
def delete_variant(variant_code):
    frappe.delete_doc("Item", variant_code)
예제 #55
0
    def on_cancel(self):
        frappe.delete_doc(
            "Salary Slip",
            frappe.db.sql_list(
                """select name from `tabSalary Slip`
			where payroll_entry=%s """, (self.name)))
예제 #56
0
def execute():
    # Update Social Logins in User
    run_patch()

    # Create Social Login Key(s) from Social Login Keys
    frappe.reload_doc("integrations",
                      "doctype",
                      "social_login_key",
                      force=True)

    if not frappe.db.exists('DocType', 'Social Login Keys'):
        return

    social_login_keys = frappe.get_doc("Social Login Keys",
                                       "Social Login Keys")
    if social_login_keys.get("facebook_client_id") or social_login_keys.get(
            "facebook_client_secret"):
        facebook_login_key = frappe.new_doc("Social Login Key")
        facebook_login_key.get_social_login_provider("Facebook",
                                                     initialize=True)
        facebook_login_key.social_login_provider = "Facebook"
        facebook_login_key.client_id = social_login_keys.get(
            "facebook_client_id")
        facebook_login_key.client_secret = social_login_keys.get(
            "facebook_client_secret")
        if not (facebook_login_key.client_secret
                and facebook_login_key.client_id):
            facebook_login_key.enable_social_login = 0
        facebook_login_key.save()

    if social_login_keys.get("frappe_server_url"):
        frappe_login_key = frappe.new_doc("Social Login Key")
        frappe_login_key.get_social_login_provider("Frappe", initialize=True)
        frappe_login_key.social_login_provider = "Frappe"
        frappe_login_key.base_url = social_login_keys.get("frappe_server_url")
        frappe_login_key.client_id = social_login_keys.get("frappe_client_id")
        frappe_login_key.client_secret = social_login_keys.get(
            "frappe_client_secret")
        if not (frappe_login_key.client_secret and frappe_login_key.client_id
                and frappe_login_key.base_url):
            frappe_login_key.enable_social_login = 0
        frappe_login_key.save()

    if social_login_keys.get("github_client_id") or social_login_keys.get(
            "github_client_secret"):
        github_login_key = frappe.new_doc("Social Login Key")
        github_login_key.get_social_login_provider("GitHub", initialize=True)
        github_login_key.social_login_provider = "GitHub"
        github_login_key.client_id = social_login_keys.get("github_client_id")
        github_login_key.client_secret = social_login_keys.get(
            "github_client_secret")
        if not (github_login_key.client_secret and github_login_key.client_id):
            github_login_key.enable_social_login = 0
        github_login_key.save()

    if social_login_keys.get("google_client_id") or social_login_keys.get(
            "google_client_secret"):
        google_login_key = frappe.new_doc("Social Login Key")
        google_login_key.get_social_login_provider("Google", initialize=True)
        google_login_key.social_login_provider = "Google"
        google_login_key.client_id = social_login_keys.get("google_client_id")
        google_login_key.client_secret = social_login_keys.get(
            "google_client_secret")
        if not (google_login_key.client_secret and google_login_key.client_id):
            google_login_key.enable_social_login = 0
        google_login_key.save()

    frappe.delete_doc("DocType", "Social Login Keys")
예제 #57
0
def rename_doc(doctype,
               old,
               new,
               force=False,
               merge=False,
               ignore_permissions=False):
    """
		Renames a doc(dt, old) to doc(dt, new) and
		updates all linked fields of type "Link"
	"""
    if not frappe.db.exists(doctype, old):
        return

    force = cint(force)
    merge = cint(merge)

    meta = frappe.get_meta(doctype)

    # call before_rename
    old_doc = frappe.get_doc(doctype, old)
    out = old_doc.run_method("before_rename", old, new, merge) or {}
    new = (out.get("new") or new) if isinstance(out, dict) else (out or new)

    if doctype != "DocType":
        new = validate_rename(doctype, new, meta, merge, force,
                              ignore_permissions)

    if not merge:
        rename_parent_and_child(doctype, old, new, meta)

    # update link fields' values
    link_fields = get_link_fields(doctype)
    update_link_field_values(link_fields, old, new, doctype)

    rename_dynamic_links(doctype, old, new)

    if doctype == 'DocType':
        rename_doctype(doctype, old, new, force)

    update_comments(doctype, old, new, force)
    update_attachments(doctype, old, new)

    if merge:
        frappe.delete_doc(doctype, old)

    # call after_rename
    new_doc = frappe.get_doc(doctype, new)

    # copy any flags if required
    new_doc._local = getattr(old_doc, "_local", None)

    new_doc.run_method("after_rename", old, new, merge)

    rename_versions(doctype, old, new)

    # update user_permissions
    frappe.db.sql(
        """update tabDefaultValue set defvalue=%s where parenttype='User Permission'
		and defkey=%s and defvalue=%s""", (new, doctype, old))
    frappe.clear_cache()

    return new
예제 #58
0
	def setUp(self):
		frappe.delete_doc('Email Account', 'Test Email Account Password')
		frappe.delete_doc('Email Account', 'Test Email Account Password-new')
예제 #59
0
def remove(doctype, name, user, flags=None):
	share_name = frappe.db.get_value("DocShare", {"user": user, "share_name": name,
		"share_doctype": doctype})

	if share_name:
		frappe.delete_doc("DocShare", share_name)
예제 #60
0
	def delete_draft_work_order(self):
		for d in frappe.get_all('Work Order', fields = ["name"],
			filters = {'docstatus': 0, 'production_plan': ("=", self.name)}):
			frappe.delete_doc('Work Order', d.name)