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__))
