seitime-frappe/frappe/modules/utils.py

# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
# License: MIT. See LICENSE
"""
	Utilities for using modules
"""
import json
import os
from glob import glob
from textwrap import dedent
from typing import TYPE_CHECKING, Dict, Optional, Tuple, Union

import frappe
from frappe import _, get_module_path, scrub
from frappe.utils import cint, cstr, now_datetime

if TYPE_CHECKING:
	from types import ModuleType

	from frappe.model.document import Document


doctype_python_modules = {}


def export_module_json(doc: "Document", is_standard: bool, module: str) -> str:
	"""Make a folder for the given doc and add its json file (make it a standard
	object that will be synced)

	Returns the absolute file_path without the extension.
	Eg: For exporting a Print Format "_Test Print Format 1", the return value will be
	`/home/gavin/frappe-bench/apps/frappe/frappe/core/print_format/_test_print_format_1/_test_print_format_1`
	"""
	if is_standard and frappe.flags.in_import and frappe.get_conf().developer_mode:
		return

	from frappe.modules.export_file import export_to_files

	export_to_files(
		record_list=[[doc.doctype, doc.name]], record_module=module, create_init=is_standard
	)

	return os.path.join(get_module_path(module), scrub(doc.doctype), scrub(doc.name), scrub(doc.name))


def get_doc_module(module: str, doctype: str, name: str) -> "ModuleType":
	"""Get custom module for given document"""
	name = scrub(name)
	module = scrub(module)
	doctype = scrub(doctype)
	app = frappe.local.module_app[module]
	return frappe.get_module(f"{app}.{module}.{doctype}.{name}.{name}")


@frappe.whitelist()
def export_customizations(
	module: str, doctype: str, sync_on_migrate: bool = False, with_permissions: bool = False
):
	"""Export Custom Field and Property Setter for the current document to the app folder.
	This will be synced with bench migrate"""

	if not frappe.get_conf().developer_mode:
		frappe.throw(_("Only allowed to export customizations in developer mode"))

	sync_on_migrate = cint(sync_on_migrate)
	with_permissions = cint(with_permissions)
	custom = {
		"custom_fields": frappe.get_all("Custom Field", fields="*", filters={"dt": doctype}),
		"property_setters": frappe.get_all("Property Setter", fields="*", filters={"doc_type": doctype}),
		"custom_perms": [],
		"links": frappe.get_all("DocType Link", fields="*", filters={"parent": doctype}),
		"doctype": doctype,
		"sync_on_migrate": sync_on_migrate,
	}

	if with_permissions:
		custom["custom_perms"] = frappe.get_all(
			"Custom DocPerm", fields="*", filters={"parent": doctype}
		)

	# also update the custom fields and property setters for all child tables
	for d in frappe.get_meta(doctype).get_table_fields():
		export_customizations(
			module=module,
			doctype=d.options,
			sync_on_migrate=sync_on_migrate,
			with_permissions=with_permissions,
		)

	if custom["custom_fields"] or custom["property_setters"] or custom["custom_perms"]:
		folder_path = os.path.join(get_module_path(module), "custom")
		file_path = os.path.join(folder_path, f"{scrub(doctype)}.json")

		os.makedirs(folder_path, exist_ok=True)
		with open(file_path, "w") as f:
			f.write(frappe.as_json(custom))

		frappe.msgprint(
			_("Customizations for <b>{0}</b> exported to:<br>{1}").format(doctype, file_path)
		)
		return file_path


def sync_customizations(app: Optional[str] = None):
	"""Sync custom fields and property setters from custom folder in each app module"""
	apps = frappe.get_installed_apps() if not app else [app]

	for app_name in apps:
		for json_file in glob(frappe.get_app_path(app_name, "**", "custom", "*.json")):
			with open(json_file, "r") as f:
				data = json.loads(f.read())

			if data.get("sync_on_migrate"):
				sync_customizations_for_doctype(data, os.path.dirname(json_file))


def sync_customizations_for_doctype(data: Dict, folder: str):
	"""Sync doctype customzations for a particular data set"""
	from frappe.core.doctype.doctype.doctype import validate_fields_for_doctype

	doctype = data["doctype"]
	update_schema = False

	def sync(key, custom_doctype, doctype_fieldname):
		doctypes = list(set(map(lambda row: row.get(doctype_fieldname), data[key])))

		# sync single doctype exculding the child doctype
		def sync_single_doctype(doc_type):
			def _insert(data):
				if data.get(doctype_fieldname) == doc_type:
					data["doctype"] = custom_doctype
					doc = frappe.get_doc(data)
					doc.db_insert()

			if custom_doctype != "Custom Field":
				frappe.db.delete(custom_doctype, {doctype_fieldname: doc_type})

				for d in data[key]:
					_insert(d)

			else:
				for d in data[key]:
					field = frappe.db.get_value("Custom Field", {"dt": doc_type, "fieldname": d["fieldname"]})
					if not field:
						d["owner"] = "Administrator"
						_insert(d)
					else:
						custom_field = frappe.get_doc("Custom Field", field)
						custom_field.flags.ignore_validate = True
						custom_field.update(d)
						custom_field.db_update()

		for doc_type in doctypes:
			# only sync the parent doctype and child doctype if there isn't any other child table json file
			if doc_type == doctype or not os.path.exists(os.path.join(folder, scrub(doc_type) + ".json")):
				sync_single_doctype(doc_type)

	if data["custom_fields"]:
		sync("custom_fields", "Custom Field", "dt")
		update_schema = True

	if data["property_setters"]:
		sync("property_setters", "Property Setter", "doc_type")

	if data.get("custom_perms"):
		sync("custom_perms", "Custom DocPerm", "parent")

	print(f"Updating customizations for {doctype}")
	validate_fields_for_doctype(doctype)

	if update_schema and not frappe.db.get_value("DocType", doctype, "issingle"):
		frappe.db.updatedb(doctype)


def scrub_dt_dn(dt: str, dn: str) -> Tuple[str, str]:
	"""Returns in lowercase and code friendly names of doctype and name for certain types"""
	return scrub(dt), scrub(dn)


def get_doc_path(module: str, doctype: str, name: str) -> str:
	"""Returns path of a doc in a module"""
	return os.path.join(get_module_path(module), *scrub_dt_dn(doctype, name))


def reload_doc(
	module: str,
	dt: str = None,
	dn: str = None,
	force: bool = False,
	reset_permissions: bool = False,
):
	"""Reload Document from model (`[module]/<doctype>/[name]/[name].json`) files"""
	from frappe.modules.import_file import import_files

	return import_files(module, dt, dn, force=force, reset_permissions=reset_permissions)


def export_doc(doctype, name, module=None):
	"""Write a doc to standard path."""
	from frappe.modules.export_file import write_document_file

	print(f"Exporting Document {doctype} {name}")
	module = module or frappe.db.get_value("DocType", name, "module")
	write_document_file(frappe.get_doc(doctype, name), module)


def get_doctype_module(doctype: str) -> str:
	"""Returns **Module Def** name of given doctype."""
	return frappe.cache().get_value(
		"doctype_modules",
		generator=lambda: dict(frappe.qb.from_("DocType").select("name", "module").run()),
	)[doctype]


def load_doctype_module(doctype, module=None, prefix="", suffix=""):
	"""Returns the module object for given doctype.

	Note: This will return the standard defined module object for the doctype irrespective
	of the `override_doctype_class` hook.
	"""
	module = module or get_doctype_module(doctype)
	app = get_module_app(module)
	key = (app, doctype, prefix, suffix)
	module_name = get_module_name(doctype, module, prefix, suffix)

	if key not in doctype_python_modules:
		try:
			doctype_python_modules[key] = frappe.get_module(module_name)
		except ImportError as e:
			raise ImportError(f"Module import failed for {doctype} ({module_name} Error: {e})")

	return doctype_python_modules[key]


def get_module_name(
	doctype: str, module: str, prefix: str = "", suffix: str = "", app: Optional[str] = None
):
	app = scrub(app or get_module_app(module))
	module = scrub(module)
	doctype = scrub(doctype)
	return f"{app}.{module}.doctype.{doctype}.{prefix}{doctype}{suffix}"


def get_module_app(module: str) -> str:
	return frappe.local.module_app[scrub(module)]


def get_app_publisher(module: str) -> str:
	app = frappe.local.module_app[scrub(module)]
	if not app:
		frappe.throw(_("App not found for module: {0}").format(module))
	return frappe.get_hooks(hook="app_publisher", app_name=app)[0]


def make_boilerplate(
	template: str, doc: Union["Document", "frappe._dict"], opts: Union[Dict, "frappe._dict"] = None
):
	target_path = get_doc_path(doc.module, doc.doctype, doc.name)
	template_name = template.replace("controller", scrub(doc.name))
	if template_name.endswith("._py"):
		template_name = template_name[:-4] + ".py"
	target_file_path = os.path.join(target_path, template_name)
	template_file_path = os.path.join(
		get_module_path("core"), "doctype", scrub(doc.doctype), "boilerplate", template
	)

	if os.path.exists(target_file_path):
		print(f"{target_file_path} already exists, skipping...")
		return

	doc = doc or frappe._dict()
	opts = opts or frappe._dict()
	app_publisher = get_app_publisher(doc.module)
	base_class = "Document"
	base_class_import = "from frappe.model.document import Document"
	controller_body = "pass"

	if doc.get("is_tree"):
		base_class = "NestedSet"
		base_class_import = "from frappe.utils.nestedset import NestedSet"

	if doc.get("is_virtual"):
		controller_body = dedent(
			"""
			def db_insert(self):
				pass

			def load_from_db(self):
				pass

			def db_update(self):
				pass

			def get_list(self, args):
				pass

			def get_count(self, args):
				pass

			def get_stats(self, args):
				pass
			"""
		)

	with open(target_file_path, "w") as target, open(template_file_path, "r") as source:
		template = source.read()
		controller_file_content = cstr(template).format(
			app_publisher=app_publisher,
			year=now_datetime().year,
			classname=doc.name.replace(" ", "").replace("-", ""),
			base_class_import=base_class_import,
			base_class=base_class,
			doctype=doc.name,
			**opts,
			custom_controller=controller_body,
		)
		target.write(frappe.as_unicode(controller_file_content))