def list_apps(context): "List apps in site" site = get_site(context) dataent.init(site=site) dataent.connect() print("\n".join(dataent.get_installed_apps())) dataent.destroy()
def watch(): "Watch and concatenate JS and CSS files as and when they change" # if os.environ.get('CI'): # return import dataent.build dataent.init('') dataent.build.watch(True)
def _reinstall(site, admin_password=None, mariadb_root_username=None, mariadb_root_password=None, yes=False, verbose=False): if not yes: click.confirm( 'This will wipe your database. Are you sure you want to reinstall?', abort=True) try: dataent.init(site=site) dataent.connect() dataent.clear_cache() installed = dataent.get_installed_apps() dataent.clear_cache() except Exception: installed = [] finally: if dataent.db: dataent.db.close() dataent.destroy() dataent.init(site=site) _new_site(dataent.conf.db_name, site, verbose=verbose, force=True, reinstall=True, install_apps=installed, mariadb_root_username=mariadb_root_username, mariadb_root_password=mariadb_root_password, admin_password=admin_password)
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False, no_email=True): "Import CSV using data import" from dataent.core.doctype.data_import import importer from dataent.utils.csvutils import read_csv_content site = get_site(context) if not os.path.exists(path): path = os.path.join('..', path) if not os.path.exists(path): print('Invalid path {0}'.format(path)) sys.exit(1) with open(path, 'r') as csvfile: content = read_csv_content(csvfile.read()) dataent.init(site=site) dataent.connect() try: importer.upload(content, submit_after_import=submit_after_import, no_email=no_email, ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert, via_console=True) dataent.db.commit() except Exception: print(dataent.get_traceback()) dataent.destroy()
def scheduler(context, state, site=None): from dataent.installer import update_site_config import dataent.utils.scheduler if not site: site = get_site(context) try: dataent.init(site=site) if state == 'pause': update_site_config('pause_scheduler', 1) elif state == 'resume': update_site_config('pause_scheduler', 0) elif state == 'disable': dataent.connect() dataent.utils.scheduler.disable_scheduler() dataent.db.commit() elif state == 'enable': dataent.connect() dataent.utils.scheduler.enable_scheduler() dataent.db.commit() print('Scheduler {0}d for site {1}'.format(state, site)) finally: dataent.destroy()
def backup(context, with_files=False, backup_path_db=None, backup_path_files=None, backup_path_private_files=None, quiet=False): "Backup" from dataent.utils.backups import scheduled_backup verbose = context.verbose for site in context.sites: dataent.init(site=site) dataent.connect() odb = scheduled_backup( ignore_files=not with_files, backup_path_db=backup_path_db, backup_path_files=backup_path_files, backup_path_private_files=backup_path_private_files, force=True) if verbose: from dataent.utils import now print("database backup taken -", odb.backup_path_db, "- on", now()) if with_files: print("files backup taken -", odb.backup_path_files, "- on", now()) print("private files backup taken -", odb.backup_path_private_files, "- on", now()) dataent.destroy()
def new_site(site, mariadb_root_username=None, mariadb_root_password=None, admin_password=None, verbose=False, install_apps=None, source_sql=None, force=None, install_app=None, db_name=None): "Create a new site" dataent.init(site=site, new_site=True) _new_site(db_name, site, mariadb_root_username=mariadb_root_username, mariadb_root_password=mariadb_root_password, admin_password=admin_password, verbose=verbose, install_apps=install_app, source_sql=source_sql, force=force) if len(dataent.utils.get_sites()) == 1: use(site)
def enqueue_events_for_site(site, queued_jobs): def log_and_raise(): dataent.logger(__name__).error( 'Exception in Enqueue Events for Site {0}'.format(site) + '\n' + dataent.get_traceback()) raise # pylint: disable=misplaced-bare-raise try: dataent.init(site=site) if dataent.local.conf.maintenance_mode: return if dataent.local.conf.pause_scheduler: return dataent.connect() if is_scheduler_disabled(): return enqueue_events(site=site, queued_jobs=queued_jobs) dataent.logger(__name__).debug( 'Queued events for site {0}'.format(site)) except pymysql.OperationalError as e: if e.args[0] == ER.ACCESS_DENIED_ERROR: dataent.logger(__name__).debug( 'Access denied for site {0}'.format(site)) else: log_and_raise() except: log_and_raise() finally: dataent.destroy()
def request(context, args=None, path=None): "Run a request as an admin" import dataent.handler import dataent.api for site in context.sites: try: dataent.init(site=site) dataent.connect() if args: if "?" in args: dataent.local.form_dict = dataent._dict( [a.split("=") for a in args.split("?")[-1].split("&")]) else: dataent.local.form_dict = dataent._dict() if args.startswith("/api/method"): dataent.local.form_dict.cmd = args.split("?")[0].split( "/")[-1] elif path: with open(os.path.join('..', path), 'r') as f: args = json.loads(f.read()) dataent.local.form_dict = dataent._dict(args) dataent.handler.execute_cmd(dataent.form_dict.cmd) print(dataent.response) finally: dataent.destroy()
def console(context): "Start ipython console for a site" site = get_site(context) dataent.init(site=site) dataent.connect() dataent.local.lang = dataent.db.get_default("lang") import IPython IPython.embed(display_banner="")
def export_csv(context, doctype, path): "Export data import template with data for DocType" from dataent.core.doctype.data_import import data_import for site in context.sites: try: dataent.init(site=site) dataent.connect() data_import.export_csv(doctype, path) finally: dataent.destroy()
def remove_from_installed_apps(context, app): "Remove app from site's installed-apps list" from dataent.installer import remove_from_installed_apps for site in context.sites: try: dataent.init(site=site) dataent.connect() remove_from_installed_apps(app) finally: dataent.destroy()
def trigger_scheduler_event(context, event): "Trigger a scheduler event" import dataent.utils.scheduler for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.utils.scheduler.trigger(site, event, now=True) finally: dataent.destroy()
def install_app(context, app): "Install a new app to site" from dataent.installer import install_app as _install_app for site in context.sites: dataent.init(site=site) dataent.connect() try: _install_app(app, verbose=context.verbose) finally: dataent.destroy()
def reload_doctype(context, doctype): "Reload schema for a DocType" for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.reload_doctype(doctype, force=context.force) dataent.db.commit() finally: dataent.destroy()
def uninstall(context, app, dry_run=False, yes=False): "Remove app and linked modules from site" from dataent.installer import remove_app for site in context.sites: try: dataent.init(site=site) dataent.connect() remove_app(app, dry_run, yes) finally: dataent.destroy()
def export_doc(context, doctype, docname): "Export a single document to csv" import dataent.modules for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.modules.export_doc(doctype, docname) finally: dataent.destroy()
def export_fixtures(context): "Export fixtures" from dataent.utils.fixtures import export_fixtures for site in context.sites: try: dataent.init(site=site) dataent.connect() export_fixtures() finally: dataent.destroy()
def clear_website_cache(context): "Clear website cache" import dataent.website.render for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.website.render.clear_cache() finally: dataent.destroy()
def export_json(context, doctype, path, name=None): "Export doclist as json to the given path, use '-' as name for Singles." from dataent.core.doctype.data_import import data_import for site in context.sites: try: dataent.init(site=site) dataent.connect() data_import.export_json(doctype, path, name=name) finally: dataent.destroy()
def run_patch(context, module): "Run a particular patch" import dataent.modules.patch_handler for site in context.sites: dataent.init(site=site) try: dataent.connect() dataent.modules.patch_handler.run_single(module, force=context.force) finally: dataent.destroy()
def set_maintenance_mode(context, state, site=None): from dataent.installer import update_site_config if not site: site = get_site(context) try: dataent.init(site=site) update_site_config('maintenance_mode', 1 if (state == 'on') else 0) finally: dataent.destroy()
def destroy_all_sessions(context, reason=None): "Clear sessions of all users (logs them out)" import dataent.sessions for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.sessions.clear_all_sessions(reason) dataent.db.commit() finally: dataent.destroy()
def build(app=None, make_copy=False, restore=False, verbose=False): "Minify + concatenate JS and CSS files, build translations" import dataent.build import dataent dataent.init('') # don't minify in developer_mode for faster builds no_compress = dataent.local.conf.developer_mode or False dataent.build.bundle(no_compress, app=app, make_copy=make_copy, restore=restore, verbose=verbose)
def disable_scheduler(context): "Disable scheduler" import dataent.utils.scheduler for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.utils.scheduler.disable_scheduler() dataent.db.commit() print("Disabled for", site) finally: dataent.destroy()
def run_tests(context, app=None, module=None, doctype=None, test=(), driver=None, profile=False, coverage=False, junit_xml_output=False, ui_tests=False, doctype_list_path=None, skip_test_records=False, skip_before_tests=False, failfast=False): "Run tests" import dataent.test_runner tests = test site = get_site(context) dataent.init(site=site) dataent.flags.skip_before_tests = skip_before_tests dataent.flags.skip_test_records = skip_test_records if coverage: # Generate coverage report only for app that is being tested source_path = os.path.join(get_bench_path(), 'apps', app or 'dataent') cov = Coverage(source=[source_path], omit=['*.html', '*.js', '*.css']) cov.start() ret = dataent.test_runner.main(app, module, doctype, context.verbose, tests=tests, force=context.force, profile=profile, junit_xml_output=junit_xml_output, ui_tests=ui_tests, doctype_list_path=doctype_list_path, failfast=failfast) if coverage: cov.stop() cov.save() if len(ret.failures) == 0 and len(ret.errors) == 0: ret = 0 if os.environ.get('CI'): sys.exit(ret)
def reset_perms(context): "Reset permissions for all doctypes" from dataent.permissions import reset_perms for site in context.sites: try: dataent.init(site=site) dataent.connect() for d in dataent.db.sql_list("""select name from `tabDocType` where istable=0 and custom=0"""): dataent.clear_cache(doctype=d) reset_perms(d) finally: dataent.destroy()
def _build_docs_once(site, app, docs_version, target, local, only_content_updated=False): from dataent.utils.setup_docs import setup_docs try: dataent.init(site=site) dataent.connect() make = setup_docs(app, target) if not only_content_updated: make.build(docs_version) #make.make_docs(target, local) finally: dataent.destroy()
def run_setup_wizard_ui_test(context, app=None, profile=False): "Run setup wizard UI test" import dataent.test_runner site = get_site(context) dataent.init(site=site) dataent.connect() ret = dataent.test_runner.run_setup_wizard_ui_test(app=app, verbose=context.verbose, profile=profile) if len(ret.failures) == 0 and len(ret.errors) == 0: ret = 0 if os.environ.get('CI'): sys.exit(ret)
def get_version(): "Show the versions of all the installed apps" from dataent.utils.change_log import get_app_branch dataent.init('') for m in sorted(dataent.get_all_apps()): branch_name = get_app_branch(m) module = dataent.get_module(m) app_hooks = dataent.get_module(m + ".hooks") if hasattr(app_hooks, '{0}_version'.format(branch_name)): print("{0} {1}".format( m, getattr(app_hooks, '{0}_version'.format(branch_name)))) elif hasattr(module, "__version__"): print("{0} {1}".format(m, module.__version__))