def execute():
dataent.reload_doc("email", "doctype", "email_template")
if not dataent.db.exists("Email Template", _('Leave Approval Notification')):
base_path = dataent.get_app_path("epaas", "hr", "doctype")
response = dataent.read_file(os.path.join(base_path, "leave_application/leave_application_email_template.html"))
dataent.get_doc({
'doctype': 'Email Template',
'name': _("Leave Approval Notification"),
'response': response,
'subject': _("Leave Approval Notification"),
'owner': dataent.session.user,
}).insert(ignore_permissions=True)
if not dataent.db.exists("Email Template", _('Leave Status Notification')):
base_path = dataent.get_app_path("epaas", "hr", "doctype")
response = dataent.read_file(os.path.join(base_path, "leave_application/leave_application_email_template.html"))
dataent.get_doc({
'doctype': 'Email Template',
'name': _("Leave Status Notification"),
'response': response,
'subject': _("Leave Status Notification"),
'owner': dataent.session.user,
}).insert(ignore_permissions=True)
def add_uom_data():
# add UOMs
uoms = json.loads(open(dataent.get_app_path("epaas", "setup", "setup_wizard", "data", "uom_data.json")).read())
for d in uoms:
if not dataent.db.exists('UOM', _(d.get("uom_name"))):
uom_doc = dataent.get_doc({
"doctype": "UOM",
"uom_name": _(d.get("uom_name")),
"name": _(d.get("uom_name")),
"must_be_whole_number": d.get("must_be_whole_number")
}).insert(ignore_permissions=True)
# bootstrap uom conversion factors
uom_conversions = json.loads(open(dataent.get_app_path("epaas", "setup", "setup_wizard", "data", "uom_conversion_data.json")).read())
for d in uom_conversions:
if not dataent.db.exists("UOM Category", _(d.get("category"))):
dataent.get_doc({
"doctype": "UOM Category",
"category_name": _(d.get("category"))
}).insert(ignore_permissions=True)
uom_conversion = dataent.get_doc({
"doctype": "UOM Conversion Factor",
"category": _(d.get("category")),
"from_uom": _(d.get("from_uom")),
"to_uom": _(d.get("to_uom")),
"value": d.get("value")
}).insert(ignore_permissions=True)
def trigger_make(source_path, event_type):
if "/docs/user/" in source_path:
# user file
target_path = dataent.get_app_path(target, 'www', 'docs', 'user',
os.path.relpath(source_path, start=dataent.get_app_path(app, 'docs', 'user')))
shutil.copy(source_path, target_path)
add_breadcrumbs_tag(target_path)
if source_path.endswith('/docs/index.md'):
target_path = dataent.get_app_path(target, 'www', 'docs', 'index.md')
shutil.copy(source_path, target_path)
def export_fixture(doctype, app):
if dataent.session.user != "Administrator":
raise dataent.PermissionError
if not os.path.exists(dataent.get_app_path(app, "fixtures")):
os.mkdir(dataent.get_app_path(app, "fixtures"))
export_json(doctype,
dataent.get_app_path(app, "fixtures",
dataent.scrub(doctype) + ".json"),
order_by="name asc")
def get_tests_for(app=None, test_list=None):
tests = []
if test_list:
# Get all tests from a particular txt file
app, test_list = test_list.split(os.path.sep, 1)
tests_path = dataent.get_app_path(app, test_list)
else:
# Get all tests for a particular app
tests_path = dataent.get_app_path(app, 'tests', 'ui', 'tests.txt')
if os.path.exists(tests_path):
with open(tests_path, 'r') as fileobj:
tests = fileobj.read().strip().splitlines()
return tests
def copy_user_assets(self):
'''Copy docs/user and docs/assets to the target app'''
print('Copying docs/user and docs/assets...')
shutil.rmtree(os.path.join(self.docs_path, 'user'), ignore_errors=True)
shutil.rmtree(os.path.join(self.docs_path, 'assets'),
ignore_errors=True)
shutil.copytree(os.path.join(self.app_path, 'docs', 'user'),
os.path.join(self.docs_path, 'user'))
shutil.copytree(
os.path.join(self.app_path, 'docs', 'assets'),
dataent.get_app_path(self.target_app, 'www', 'docs', 'assets'))
# copy index
shutil.copy(os.path.join(self.app_path, 'docs', 'index.md'),
dataent.get_app_path(self.target_app, 'www', 'docs'))
def add_to_modules_txt(self):
"""Adds to `[app]/modules.txt`"""
modules = None
if not dataent.local.module_app.get(dataent.scrub(self.name)):
with open(dataent.get_app_path(self.app_name, "modules.txt"), "r") as f:
content = f.read()
if not self.name in content.splitlines():
modules = list(filter(None, content.splitlines()))
modules.append(self.name)
if modules:
with open(dataent.get_app_path(self.app_name, "modules.txt"), "w") as f:
f.write("\n".join(modules))
dataent.clear_cache()
dataent.setup_module_map()
def create_modules_folder(self):
"""Creates a folder `[app]/[module]` and adds `__init__.py`"""
module_path = dataent.get_app_path(self.app_name, self.name)
if not os.path.exists(module_path):
os.mkdir(module_path)
with open(os.path.join(module_path, "__init__.py"), "w") as f:
f.write("")
def purifycss():
with open(source, 'r') as f:
src = f.read()
classes = []
for line in src.splitlines():
line = line.strip()
if not line:
continue
if line[0] == '@':
continue
classes.extend(re.findall('\.([^0-9][^ :&.{,(]*)', line))
classes = list(set(classes))
for app in target_apps:
for basepath, folders, files in os.walk(dataent.get_app_path(app)):
for fname in files:
if fname.endswith('.html') or fname.endswith('.md'):
#print 'checking {0}...'.format(fname)
with open(os.path.join(basepath, fname), 'r') as f:
src = f.read()
for c in classes:
if c in src:
classes.remove(c)
for c in sorted(classes):
print(c)
def get_change_log_for_app(app, from_version, to_version):
change_log_folder = os.path.join(dataent.get_app_path(app), "change_log")
if not os.path.exists(change_log_folder):
return
from_version = Version(from_version)
to_version = Version(to_version)
# remove pre-release part
to_version.prerelease = None
major_version_folders = [
"v{0}".format(i)
for i in range(from_version.major, to_version.major + 1)
]
app_change_log = []
for folder in os.listdir(change_log_folder):
if folder in major_version_folders:
for file in os.listdir(os.path.join(change_log_folder, folder)):
version = Version(
os.path.splitext(file)[0][1:].replace("_", "."))
if from_version < version <= to_version:
file_path = os.path.join(change_log_folder, folder, file)
content = dataent.read_file(file_path)
app_change_log.append([version, content])
app_change_log = sorted(app_change_log, key=lambda d: d[0], reverse=True)
# convert version to string and send
return [[cstr(d[0]), d[1]] for d in app_change_log]
def setup_integration_service(app_details, settings=None):
if not settings:
return
setup_service_settings(app_details["service_name"], settings)
doc_path = dataent.get_app_path("dataent", "integration_broker", "doctype",
"integration_service",
"integration_service.json")
if not os.path.exists(doc_path):
return
dataent.reload_doc("integration_broker", "doctype", "integration_service")
if dataent.db.exists("Integration Service", app_details["service_name"]):
integration_service = dataent.get_doc("Integration Service",
app_details["service_name"])
else:
integration_service = dataent.new_doc("Integration Service")
integration_service.service = app_details["service_name"]
integration_service.enabled = 1
integration_service.flags.ignore_mandatory = True
integration_service.save(ignore_permissions=True)
def render_include(content):
'''render {% raw %}{% include "app/path/filename" %}{% endraw %} in js file'''
content = cstr(content)
# try 5 levels of includes
for i in range(5):
if "{% include" in content:
paths = re.findall(r'''{% include\s['"](.*)['"]\s%}''', content)
if not paths:
dataent.throw('Invalid include path', InvalidIncludePath)
for path in paths:
app, app_path = path.split('/', 1)
with io.open(dataent.get_app_path(app, app_path),
'r',
encoding='utf-8') as f:
include = f.read()
if path.endswith('.html'):
include = html_to_js_template(path, include)
content = re.sub(
r'''{{% include\s['"]{0}['"]\s%}}'''.format(path),
include, content)
else:
break
return content
def setup_user():
dataent.db.sql('delete from tabUser where name not in ("Guest", "Administrator")')
for u in json.loads(open(dataent.get_app_path('epaas', 'demo', 'data', 'user.json')).read()):
user = dataent.new_doc("User")
user.update(u)
user.flags.no_welcome_mail = True
user.new_password = '******'
user.insert()
def get_all_messages_from_js_files(app_name=None):
"""Extracts all translatable strings from app `.js` files"""
messages = []
for app in ([app_name] if app_name else dataent.get_installed_apps()):
if os.path.exists(dataent.get_app_path(app, "public")):
for basepath, folders, files in os.walk(
dataent.get_app_path(app, "public")):
if "dataent/public/js/lib" in basepath:
continue
for fname in files:
if fname.endswith(".js") or fname.endswith(".html"):
messages.extend(
get_messages_from_file(
os.path.join(basepath, fname)))
return messages
def update_language_names():
'''Update dataent/geo/languages.json names (for use via patch)'''
with open(dataent.get_app_path('dataent', 'geo', 'languages.json'),
'r') as f:
data = json.loads(f.read())
for l in data:
dataent.db.set_value('Language', l['code'], 'language_name', l['name'])
def build(self, docs_version):
"""Build templates for docs models and Python API"""
self.docs_path = dataent.get_app_path(self.target_app, 'www', "docs")
self.path = os.path.join(self.docs_path, docs_version)
self.app_context["app"]["docs_version"] = docs_version
self.app_title = self.hooks.get("app_title")[0]
self.app_path = dataent.get_app_path(self.app)
print("Deleting current...")
shutil.rmtree(self.path, ignore_errors=True)
os.makedirs(self.path)
self.make_home_pages()
for basepath, folders, files in os.walk(self.app_path):
# make module home page
if "/doctype/" not in basepath and "doctype" in folders:
module = os.path.basename(basepath)
module_folder = os.path.join(self.models_base_path, module)
self.make_folder(module_folder,
template="templates/autodoc/module_home.html",
context={"name": module})
self.update_index_txt(module_folder)
# make for model files
if "/doctype/" in basepath:
parts = basepath.split("/")
#print parts
module, doctype = parts[-3], parts[-1]
if doctype != "boilerplate":
self.write_model_file(basepath, module, doctype)
# standard python module
if self.is_py_module(basepath, folders, files):
self.write_modules(basepath, folders, files)
#self.build_user_docs()
self.copy_user_assets()
self.add_sidebars()
self.add_breadcrumbs_for_user_pages()
def reload_doctypes_for_schools_icons():
# 'Schools' module changed to the 'Education'
# base_path = dataent.get_app_path('epaas', 'schools', 'doctype')
base_path = dataent.get_app_path('epaas', 'education', 'doctype')
for doctype in os.listdir(base_path):
if os.path.exists(os.path.join(base_path, doctype, doctype + '.json')) \
and doctype not in ("fee_component", "assessment", "assessment_result"):
dataent.reload_doc('education', 'doctype', doctype)
def get_page_info(path, app, start, basepath=None, app_path=None, fname=None):
'''Load page info'''
if fname is None:
fname = os.path.basename(path)
if app_path is None:
app_path = dataent.get_app_path(app)
if basepath is None:
basepath = os.path.dirname(path)
page_name, extn = fname.rsplit(".", 1)
# add website route
page_info = dataent._dict()
page_info.basename = page_name if extn in ('html', 'md') else fname
page_info.basepath = basepath
page_info.page_or_generator = "Page"
page_info.template = os.path.relpath(os.path.join(basepath, fname),
app_path)
if page_info.basename == 'index':
page_info.basename = ""
# get route from template name
page_info.route = page_info.template.replace(start, '').strip('/')
if os.path.basename(page_info.route) in ('index.html', 'index.md'):
page_info.route = os.path.dirname(page_info.route)
# remove the extension
if page_info.route.endswith('.md') or page_info.route.endswith('.html'):
page_info.route = page_info.route.rsplit('.', 1)[0]
page_info.name = page_info.page_name = page_info.route
# controller
page_info.controller_path = os.path.join(
basepath,
page_name.replace("-", "_") + ".py")
if os.path.exists(page_info.controller_path):
controller = app + "." + os.path.relpath(
page_info.controller_path, app_path).replace(os.path.sep, ".")[:-3]
page_info.controller = controller
# get the source
setup_source(page_info)
# extract properties from HTML comments
load_properties(page_info)
# if not page_info.title:
# print('no-title-for', page_info.route)
return page_info
def import_drug():
dataent.flags.in_import = True
data = json.loads(
open(dataent.get_app_path('epaas', 'demo', 'data',
'drug_list.json')).read())
for d in data:
doc = dataent.new_doc("Item")
doc.update(d)
doc.insert()
dataent.flags.in_import = False
def get_kernel():
global kernel
if not kernel:
kernel = aiml.Kernel()
for basepath, folders, files in os.walk(dataent.get_app_path('vidya', 'aiml')):
for filename in files:
if filename.endswith('.aiml'):
print 'learning {0}'.format(os.path.join(basepath, filename))
kernel.learn(os.path.join(basepath, filename))
return kernel
def load_templates(self):
if not self.custom:
module = load_doctype_module(self.name)
app = module.__name__.split(".")[0]
templates = {}
if hasattr(module, "form_grid_templates"):
for key, path in iteritems(module.form_grid_templates):
templates[key] = get_html_format(dataent.get_app_path(app, path))
self.set("__form_grid_templates", templates)
def main(app=None, module=None, doctype=None, verbose=False, tests=(),
force=False, profile=False, junit_xml_output=None, ui_tests=False,
doctype_list_path=None, skip_test_records=False, failfast=False):
global unittest_runner
if doctype_list_path:
app, doctype_list_path = doctype_list_path.split(os.path.sep, 1)
with open(dataent.get_app_path(app, doctype_list_path), 'r') as f:
doctype = f.read().strip().splitlines()
xmloutput_fh = None
if junit_xml_output:
xmloutput_fh = open(junit_xml_output, 'w')
unittest_runner = xmlrunner_wrapper(xmloutput_fh)
else:
unittest_runner = unittest.TextTestRunner
try:
dataent.flags.print_messages = verbose
dataent.flags.in_test = True
if not dataent.db:
dataent.connect()
# if not dataent.conf.get("db_name").startswith("test_"):
# raise Exception, 'db_name must start with "test_"'
# workaround! since there is no separate test db
dataent.clear_cache()
dataent.utils.scheduler.disable_scheduler()
set_test_email_config()
if not dataent.flags.skip_before_tests:
if verbose:
print('Running "before_tests" hooks')
for fn in dataent.get_hooks("before_tests", app_name=app):
dataent.get_attr(fn)()
if doctype:
ret = run_tests_for_doctype(doctype, verbose, tests, force, profile)
elif module:
ret = run_tests_for_module(module, verbose, tests, profile)
else:
ret = run_all_tests(app, verbose, profile, ui_tests, failfast=failfast)
dataent.db.commit()
# workaround! since there is no separate test db
dataent.clear_cache()
return ret
finally:
if xmloutput_fh:
xmloutput_fh.flush()
xmloutput_fh.close()
def export_languages_json():
'''Export list of all languages'''
languages = dataent.db.get_all('Language',
fields=['name', 'language_name'])
languages = [{'name': d.language_name, 'code': d.name} for d in languages]
languages.sort(key=lambda a: a['code'])
with open(dataent.get_app_path('dataent', 'geo', 'languages.json'),
'w') as f:
f.write(dataent.as_json(languages))
def watch(no_compress):
"""watch and rebuild if necessary"""
setup()
pacman = get_node_pacman()
dataent_app_path = os.path.abspath(os.path.join(app_paths[0], '..'))
check_yarn()
dataent_app_path = dataent.get_app_path('dataent', '..')
dataent.commands.popen('{pacman} run watch'.format(pacman=pacman),
cwd=dataent_app_path)
def setup_item():
items = json.loads(open(dataent.get_app_path('epaas', 'demo', 'data', 'item.json')).read())
for i in items:
item = dataent.new_doc('Item')
item.update(i)
if hasattr(item, 'item_defaults') and item.item_defaults[0].default_warehouse:
item.item_defaults[0].company = data.get("Manufacturing").get('company_name')
warehouse = dataent.get_all('Warehouse', filters={'warehouse_name': item.item_defaults[0].default_warehouse}, limit=1)
if warehouse:
item.item_defaults[0].default_warehouse = warehouse[0].name
item.insert()
def export_fixtures():
"""Export fixtures as JSON to `[app]/fixtures`"""
for app in dataent.get_installed_apps():
for fixture in dataent.get_hooks("fixtures", app_name=app):
filters = None
or_filters = None
if isinstance(fixture, dict):
filters = fixture.get("filters")
or_filters = fixture.get("or_filters")
fixture = fixture.get("doctype") or fixture.get("dt")
print("Exporting {0} app {1} filters {2}".format(
fixture, app, (filters if filters else or_filters)))
if not os.path.exists(dataent.get_app_path(app, "fixtures")):
os.mkdir(dataent.get_app_path(app, "fixtures"))
export_json(fixture,
dataent.get_app_path(app, "fixtures",
dataent.scrub(fixture) + ".json"),
filters=filters,
or_filters=or_filters)
def setup_account():
dataent.flags.in_import = True
data = json.loads(open(dataent.get_app_path('epaas', 'demo', 'data',
'account.json')).read())
for d in data:
doc = dataent.new_doc('Account')
doc.update(d)
doc.parent_account = dataent.db.get_value('Account', {'account_name': doc.parent_account})
doc.insert()
dataent.flags.in_import = False
def setUp(self):
dataent.set_user("Administrator")
# use the fixture data
import_doc(path=dataent.get_app_path("epaas", "epaas_integrations/doctype/shopify_settings/test_data/custom_field.json"),
ignore_links=True, overwrite=True)
dataent.reload_doctype("Customer")
dataent.reload_doctype("Sales Order")
dataent.reload_doctype("Delivery Note")
dataent.reload_doctype("Sales Invoice")
self.setup_shopify()
def sync_languages():
'''Sync dataent/geo/languages.json with Language'''
with open(dataent.get_app_path('dataent', 'geo', 'languages.json'),
'r') as f:
data = json.loads(f.read())
for l in data:
if not dataent.db.exists('Language', l['code']):
dataent.get_doc({
'doctype': 'Language',
'language_code': l['code'],
'language_name': l['name']
}).insert()
def is_static_file(path):
if ('.' not in path):
return False
extn = path.rsplit('.', 1)[-1]
if extn in ('html', 'md', 'js', 'xml', 'css', 'txt', 'py'):
return False
for app in dataent.get_installed_apps():
file_path = dataent.get_app_path(app, 'www') + '/' + path
if os.path.exists(file_path):
dataent.flags.file_path = file_path
return True
return False
