def latest(rebuild_website_config=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.website import rebuild_config from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.website import statics verbose = not quiet frappe.connect() try: # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) sync_fixtures() statics.sync().start() # build website config if any changes in templates etc. if rebuild_website_config: rebuild_config() frappe.translate.clear_cache() finally: frappe.destroy()
def scheduler_task(site, event, handler, now=False): from frappe.utils.scheduler import log traceback = "" task_logger.info('running {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event)) try: frappe.init(site=site) if not create_lock(handler): return if not now: frappe.connect(site=site) frappe.get_attr(handler)() except Exception: frappe.db.rollback() traceback = log(handler, "Method: {event}, Handler: {handler}".format(event=event, handler=handler)) task_logger.warn(traceback) raise else: frappe.db.commit() finally: delete_lock(handler) if not now: frappe.destroy() task_logger.info('ran {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
def execute(context, method, args=None, kwargs=None): "execute a function" for site in context.sites: try: frappe.init(site=site) frappe.connect() if args: args = eval(args) else: args = () if kwargs: kwargs = eval(args) else: kwargs = {} ret = frappe.get_attr(method)(*args, **kwargs) if frappe.db: frappe.db.commit() finally: frappe.destroy() if ret: print json.dumps(ret)
def list_apps(context): "List apps in site" site = get_site(context) frappe.init(site=site) frappe.connect() print("\n".join(frappe.get_installed_apps())) frappe.destroy()
def backup( context, with_files=False, backup_path_db=None, backup_path_files=None, backup_path_private_files=None, quiet=False ): "Backup" from frappe.utils.backups import scheduled_backup verbose = context.verbose for site in context.sites: frappe.init(site=site) frappe.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 frappe.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() frappe.destroy()
def sendmail(site, communication_name, print_html=None, print_format=None, attachments=None, recipients=None, cc=None): try: frappe.connect(site=site) # upto 3 retries for i in xrange(3): try: communication = frappe.get_doc("Communication", communication_name) communication._notify(print_html=print_html, print_format=print_format, attachments=attachments, recipients=recipients, cc=cc) except MySQLdb.OperationalError, e: # deadlock, try again if e.args[0]==1213: frappe.db.rollback() time.sleep(1) continue else: raise else: break except: frappe.db.rollback() else: frappe.db.commit() finally: frappe.destroy()
def build_website(verbose=False): from frappe.website import render, statics frappe.connect() render.clear_cache() statics.sync(verbose=verbose).start(True) frappe.db.commit() frappe.destroy()
def enqueue_events_for_site(site, queued_jobs): try: frappe.init(site=site) if frappe.local.conf.maintenance_mode: return if frappe.local.conf.pause_scheduler: return frappe.connect() if is_scheduler_disabled(): return enqueue_events(site=site, queued_jobs=queued_jobs) # TODO this print call is a tempfix till logging is fixed! print 'Queued events for site {0}'.format(site) frappe.logger(__name__).debug('Queued events for site {0}'.format(site)) except: frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site)) raise finally: frappe.destroy()
def request(context, args=None, path=None): "Run a request as an admin" import frappe.handler import frappe.api for site in context.sites: try: frappe.init(site=site) frappe.connect() if args: if "?" in args: frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")]) else: frappe.local.form_dict = frappe._dict() if args.startswith("/api/method"): frappe.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()) frappe.local.form_dict = frappe._dict(args) frappe.handler.execute_cmd(frappe.form_dict.cmd) print(frappe.response) finally: frappe.destroy()
def send_newsletter(site, newsletter, event): # hack! pass event="bulk_long" to queue in longjob queue try: frappe.connect(site=site) doc = frappe.get_doc("Newsletter", newsletter) doc.send_bulk() except: frappe.db.rollback() task_logger.error(site) task_logger.error(frappe.get_traceback()) # wasn't able to send emails :( doc.db_set("email_sent", 0) frappe.db.commit() log("send_newsletter") raise else: frappe.db.commit() finally: frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False, no_email=True): "Import CSV using data import tool" from frappe.core.page.data_import_tool import importer from frappe.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()) frappe.init(site=site) frappe.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) frappe.db.commit() except Exception: print(frappe.get_traceback()) frappe.destroy()
def reset_perms(): frappe.connect() for d in frappe.db.sql_list("""select name from `tabDocType` where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""): frappe.clear_cache(doctype=d) frappe.reset_perms(d) frappe.destroy()
def _new_site(db_name, site, mariadb_root_username=None, mariadb_root_password=None, admin_password=None, verbose=False, install_apps=None, source_sql=None,force=False, reinstall=False): "Install a new Frappe site" from frappe.installer import install_db, make_site_dirs from frappe.installer import install_app as _install_app import frappe.utils.scheduler frappe.init(site=site) try: # enable scheduler post install? enable_scheduler = _is_scheduler_enabled() except: enable_scheduler = False install_db(root_login=mariadb_root_username, root_password=mariadb_root_password, db_name=db_name, admin_password=admin_password, verbose=verbose, source_sql=source_sql,force=force, reinstall=reinstall) make_site_dirs() _install_app("frappe", verbose=verbose, set_as_patched=not source_sql) if frappe.conf.get("install_apps"): for app in frappe.conf.install_apps: _install_app(app, verbose=verbose, set_as_patched=not source_sql) if install_apps: for app in install_apps: _install_app(app, verbose=verbose, set_as_patched=not source_sql) frappe.utils.scheduler.toggle_scheduler(enable_scheduler) scheduler_status = "disabled" if frappe.utils.scheduler.is_scheduler_disabled() else "enabled" print "*** Scheduler is", scheduler_status, "***" frappe.destroy()
def disable_scheduler(): import frappe.utils.scheduler frappe.connect() frappe.utils.scheduler.disable_scheduler() frappe.db.commit() print "Disabled" frappe.destroy()
def scheduler(context, state, site=None): from frappe.installer import update_site_config import frappe.utils.scheduler if not site: site = get_site(context) try: frappe.init(site=site) if state == "pause": update_site_config("pause_scheduler", 1) elif state == "resume": update_site_config("pause_scheduler", 0) elif state == "disable": frappe.connect() frappe.utils.scheduler.disable_scheduler() frappe.db.commit() elif state == "enable": frappe.connect() frappe.utils.scheduler.enable_scheduler() frappe.db.commit() print "Scheduler {0}d for site {1}".format(state, site) finally: frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False): "Import CSV using data import tool" from frappe.core.page.data_import_tool import importer from frappe.utils.csvutils import read_csv_content site = get_site(context) with open(path, "r") as csvfile: content = read_csv_content(csvfile.read()) frappe.init(site=site) frappe.connect() try: importer.upload( content, submit_after_import=submit_after_import, ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert, via_console=True, ) frappe.db.commit() except Exception: print frappe.get_traceback() frappe.destroy()
def list_apps(context): "Reinstall site ie. wipe all data and start over" site = get_single_site(context) frappe.init(site=site) frappe.connect() print "\n".join(frappe.get_installed_apps()) frappe.destroy()
def execute(method): frappe.connect() ret = frappe.get_attr(method)() frappe.db.commit() frappe.destroy() if ret: print ret
def clear_cache(): import frappe.sessions from frappe.core.doctype.notification_count.notification_count import clear_notifications frappe.connect() frappe.clear_cache() clear_notifications() frappe.destroy()
def set_config(context, key, value): "Insert/Update a value in site_config.json" from frappe.installer import update_site_config for site in context.sites: frappe.init(site=site) update_site_config(key, value) frappe.destroy()
def patch(patch_module, force=False): import frappe.modules.patch_handler frappe.connect() frappe.local.patch_log_list = [] frappe.modules.patch_handler.run_single(patch_module, force=force) print "\n".join(frappe.local.patch_log_list) frappe.destroy()
def set_admin_password(admin_password): import frappe frappe.connect() frappe.db.sql("""update __Auth set `password`=password(%s) where user='******'""", (admin_password,)) frappe.db.commit() frappe.destroy()
def migrate(context, rebuild_website=False): "Run patches, sync schema and rebuild files/translations" import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.desk.notifications import clear_notifications for site in context.sites: print 'Migrating', site frappe.init(site=site) frappe.connect() try: prepare_for_update() # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=context.verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() finally: frappe.destroy() if rebuild_website: call_command(build_website, context) else: call_command(sync_www, context)
def scheduler(context, state, site=None): from frappe.installer import update_site_config import frappe.utils.scheduler if not site: site = get_site(context) try: frappe.init(site=site) if state == 'pause': update_site_config('pause_scheduler', 1) elif state == 'resume': update_site_config('pause_scheduler', 0) elif state == 'disable': frappe.connect() frappe.utils.scheduler.disable_scheduler() frappe.db.commit() elif state == 'enable': frappe.connect() frappe.utils.scheduler.enable_scheduler() frappe.db.commit() print('Scheduler {0}d for site {1}'.format(state, site)) finally: frappe.destroy()
def latest(rebuild_website=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.core.doctype.notification_count.notification_count import clear_notifications verbose = not quiet frappe.connect() try: # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() if rebuild_website: build_website() finally: frappe.destroy()
def add_to_installed_apps(*apps): from frappe.installer import add_to_installed_apps frappe.connect() all_apps = frappe.get_all_apps(with_frappe=True) for each in apps: if each in all_apps: add_to_installed_apps(each, rebuild_website=False) frappe.destroy()
def domain(host_url=None): frappe.connect() if host_url: frappe.db.set_value("Website Settings", None, "subdomain", host_url) frappe.db.commit() else: print frappe.db.get_value("Website Settings", None, "subdomain") frappe.destroy()
def pull_from_email_account(site, email_account): try: frappe.init(site=site) frappe.connect(site=site) email_account = frappe.get_doc("Email Account", email_account) email_account.receive() frappe.db.commit() finally: frappe.destroy()
def make(domain='Manufacturing'): frappe.flags.domain = domain frappe.flags.mute_emails = True setup_data() site = frappe.local.site frappe.destroy() frappe.init(site) frappe.connect() simulate()
def validate(site): frappe.init(site=site, sites_path=sites_path) make_site_dirs() backup() frappe.init(site=site, sites_path=sites_path) frappe.connect() if not executed(last_3_patch): raise Exception, "site not ready to migrate to version 4" frappe.destroy()
def execute(**kwargs): """ Use this to install apps; it checks for apps that are already installed. bench --site [site_name] execute [module_name].install_apps.execute --kwargs "{'apps': ['rebrandly_integration', 'printnode_integration']}" """ apps_installed = frappe.db.sql( """SELECT DISTINCT app_name FROM `tabModule Def`""", as_dict=True) apps_installed = [v.app_name for v in apps_installed] for app in kwargs['apps']: if app not in apps_installed: print 'Installing app {0}'.format(app) frappe.init(site=kwargs['site']) frappe.connect() try: _install_app(app, verbose=False) finally: frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False): "Import CSV using data import tool" from frappe.core.page.data_import_tool import importer from frappe.utils.csvutils import read_csv_content site = get_single_site(context) with open(path, 'r') as csvfile: content = read_csv_content(csvfile.read()) frappe.init(site=site) frappe.connect() try: importer.upload(content, submit_after_import=submit_after_import, ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert, via_console=True) frappe.db.commit() except Exception: print frappe.get_traceback() frappe.destroy()
def migrate(context, rebuild_website=False, skip_failing=False): "Run patches, sync schema and rebuild files/translations" from frappe.migrate import migrate for site in context.sites: print('Migrating', site) frappe.init(site=site) frappe.connect() try: migrate(context.verbose, rebuild_website=rebuild_website, skip_failing=skip_failing) finally: frappe.destroy() if not context.sites: raise SiteNotSpecifiedError print("Compiling Python Files...") compileall.compile_dir('../apps', quiet=1, rx=re.compile('.*node_modules.*'))
def extract_tar_files(site_name, file_path, folder_name): # Need to do frappe.init to maintain the site locals frappe.init(site=site_name) abs_site_path = os.path.abspath(frappe.get_site_path()) # Copy the files to the parent directory and extract shutil.copy2(os.path.abspath(file_path), abs_site_path) # Get the file name splitting the file path on tar_name = os.path.split(file_path)[1] tar_path = os.path.join(abs_site_path, tar_name) try: subprocess.check_output(['tar', 'xvf', tar_path, '--strip', '2'], cwd=abs_site_path) except: raise finally: frappe.destroy() return tar_path
def request(context, args): "Run a request as an admin" import frappe.handler import frappe.api for site in context.sites: try: frappe.init(site=site) frappe.connect() if "?" in args: frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")]) else: frappe.local.form_dict = frappe._dict() if args.startswith("/api/method"): frappe.local.form_dict.cmd = args.split("?")[0].split("/")[-1] frappe.handler.execute_cmd(frappe.form_dict.cmd) print frappe.response finally: frappe.destroy()
def migrate_sites(maintenance_mode=False): installed_sites = ":".join(get_sites()) sites = os.environ.get("SITES", installed_sites).split(":") if not maintenance_mode: maintenance_mode = cint(os.environ.get("MAINTENANCE_MODE")) if maintenance_mode: set_maintenance_mode(True) for site in sites: print('Migrating', site) frappe.init(site=site) frappe.connect() try: from frappe.migrate import migrate migrate() finally: frappe.destroy() # Disable maintenance mode after migration set_maintenance_mode(False)
def move(dest_dir=None, site=None): import os if not dest_dir: raise Exception, "--dest_dir is required for --move" if not os.path.isdir(dest_dir): raise Exception, "destination is not a directory or does not exist" old_path = frappe.utils.get_site() new_path = os.path.join(dest_dir, site) # check if site dump of same name already exists site_dump_exists = True count = 0 while site_dump_exists: final_new_path = new_path + (count and str(count) or "") site_dump_exists = os.path.exists(final_new_path) count = int(count or 0) + 1 os.rename(old_path, final_new_path) frappe.destroy() return os.path.basename(final_new_path)
def trigger_scheduler_event(context, event): import frappe.utils.scheduler exit_code = 0 for site in context.sites: try: frappe.init(site=site) frappe.connect() try: frappe.get_doc("Scheduled Job Type", {"method": event}).execute() except frappe.DoesNotExistError: click.secho(f"Event {event} does not exist!", fg="red") exit_code = 1 finally: frappe.destroy() if not context.sites: raise SiteNotSpecifiedError sys.exit(exit_code)
def _build_docs_once(site, app, docs_version, target, local, only_content_updated=False): from frappe.utils.setup_docs import setup_docs try: frappe.init(site=site) frappe.connect() make = setup_docs(app) if not only_content_updated: make.build(docs_version) make.make_docs(target, local) finally: frappe.destroy()
def migrate_sites(maintenance_mode=False): installed_sites = ":".join(get_sites()) sites = os.environ.get("SITES", installed_sites).split(":") if not maintenance_mode: maintenance_mode = True if os.environ.get( "MAINTENANCE_MODE") else False if maintenance_mode: set_maintenance_mode(True) for site in sites: print('Migrating', site) frappe.init(site=site) frappe.connect() try: migrate() finally: frappe.destroy() if maintenance_mode: set_maintenance_mode(False)
def set_admin_password(context, admin_password, logout_all_sessions=False): "Set Administrator password for a site" import getpass from frappe.utils.password import update_password for site in context.sites: try: frappe.init(site=site) while not admin_password: admin_password = getpass.getpass( "Administrator's password for {0}: ".format(site)) frappe.connect() update_password(user='******', pwd=admin_password, logout_all_sessions=logout_all_sessions) frappe.db.commit() admin_password = None finally: frappe.destroy()
def execute_job(site, method, event, job_name, kwargs): '''Executes job in a worker, performs commit/rollback and logs if there is any error''' from frappe.utils.scheduler import log frappe.connect(site) if isinstance(method, basestring): method_name = method method = frappe.get_attr(method) else: method_name = cstr(method) try: method(**kwargs) except: frappe.db.rollback() log(method_name) raise else: frappe.db.commit() finally: frappe.destroy()
def sendmail(site, communication_name, print_html=None, print_format=None, attachments=None, recipients=None, cc=None): try: frappe.connect(site=site) # upto 3 retries for i in xrange(3): try: communication = frappe.get_doc("Communication", communication_name) communication._notify(print_html=print_html, print_format=print_format, attachments=attachments, recipients=recipients, cc=cc) except MySQLdb.OperationalError, e: # deadlock, try again if e.args[0] == 1213: frappe.db.rollback() time.sleep(1) continue else: raise else: break except: frappe.db.rollback() raise else: frappe.db.commit() finally: frappe.destroy()
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 frappe.core.doctype.data_import_legacy import importer from frappe.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()) frappe.init(site=site) frappe.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, ) frappe.db.commit() except Exception: print(frappe.get_traceback()) frappe.destroy()
def auto_deploy(context, app, migrate=False, restart=False, remote='upstream'): '''Pull and migrate sites that have new version''' from frappe.utils.gitutils import get_app_branch from frappe.utils import get_sites branch = get_app_branch(app) app_path = frappe.get_app_path(app) # fetch subprocess.check_output(['git', 'fetch', remote, branch], cwd=app_path) # get diff if subprocess.check_output( ['git', 'diff', '{0}..upstream/{0}'.format(branch)], cwd=app_path): print('Updates found for {0}'.format(app)) if app == 'frappe': # run bench update subprocess.check_output(['bench', 'update', '--no-backup'], cwd='..') else: updated = False subprocess.check_output( ['git', 'pull', '--rebase', 'upstream', branch], cwd=app_path) # find all sites with that app for site in get_sites(): frappe.init(site) if app in frappe.get_installed_apps(): print('Updating {0}'.format(site)) updated = True subprocess.check_output( ['bench', '--site', site, 'clear-cache'], cwd='..') if migrate: subprocess.check_output( ['bench', '--site', site, 'migrate'], cwd='..') frappe.destroy() if updated and restart: subprocess.check_output(['bench', 'restart'], cwd='..') else: print('No Updates')
def set_user_password(site, user, password, logout_all_sessions=False): import getpass from frappe.utils.password import update_password try: frappe.init(site=site) while not password: password = getpass.getpass(f"{user}'s password for {site}: ") frappe.connect() if not frappe.db.exists("User", user): print(f"User {user} does not exist") sys.exit(1) update_password(user=user, pwd=password, logout_all_sessions=logout_all_sessions) frappe.db.commit() password = None finally: frappe.destroy()
def send_newsletter(site, newsletter, event): # hack! pass event="bulk_long" to queue in longjob queue try: frappe.connect(site=site) doc = frappe.get_doc("Newsletter", newsletter) doc.send_bulk() except: frappe.db.rollback() task_logger.warn(frappe.get_traceback()) # wasn't able to send emails :( doc.db_set("email_sent", 0) frappe.db.commit() raise else: frappe.db.commit() finally: frappe.destroy()
def _reinstall(site, admin_password=None, mariadb_root_username=None, mariadb_root_password=None, yes=False, verbose=False): from frappe.installer import _new_site if not yes: click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True) try: frappe.init(site=site) frappe.connect() frappe.clear_cache() installed = frappe.get_installed_apps() frappe.clear_cache() except Exception: installed = [] finally: if frappe.db: frappe.db.close() frappe.destroy() frappe.init(site=site) _new_site(frappe.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 backup(context, with_files=False, backup_path_db=None, backup_path_files=None, quiet=False): "Backup" from frappe.utils.backups import scheduled_backup verbose = context.verbose for site in context.sites: frappe.init(site=site) frappe.connect() odb = scheduled_backup(ignore_files=not with_files, backup_path_db=backup_path_db, backup_path_files=backup_path_files, force=True) if verbose: from frappe.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( ) frappe.destroy()
def execute(context, method, args=None, kwargs=None, profile=False): "Execute a function" for site in context.sites: try: frappe.init(site=site) frappe.connect() if args: try: args = eval(args) except NameError: args = [args] else: args = () if kwargs: kwargs = eval(kwargs) else: kwargs = {} if profile: pr = cProfile.Profile() pr.enable() ret = frappe.get_attr(method)(*args, **kwargs) if profile: pr.disable() s = StringIO() pstats.Stats(pr, stream=s).sort_stats('cumulative').print_stats(.5) print(s.getvalue()) if frappe.db: frappe.db.commit() finally: frappe.destroy() if ret: print(json.dumps(ret, default=json_handler))
def set_config(context, key, value, global_=False, as_dict=False): "Insert/Update a value in site_config.json" from frappe.installer import update_site_config import ast if as_dict: value = ast.literal_eval(value) if global_: sites_path = os.getcwd() # big assumption. common_site_config_path = os.path.join(sites_path, 'common_site_config.json') update_site_config(key, value, validate=False, site_config_path=common_site_config_path) else: for site in context.sites: frappe.init(site=site) update_site_config(key, value, validate=False) frappe.destroy() else: raise SiteNotSpecifiedError
def ready_for_migration(context, site=None): from frappe.utils.doctor import get_pending_jobs if not site: site = get_site(context) try: frappe.init(site=site) pending_jobs = get_pending_jobs(site=site) if pending_jobs: print 'NOT READY for migration: site {0} has pending background jobs'.format( site) sys.exit(1) else: print 'READY for migration: site {0} does not have any background jobs'.format( site) return 0 finally: frappe.destroy()
def get_site_status(verbose=False): import frappe import frappe.utils from frappe.profile import get_system_managers from frappe.core.doctype.profile.profile import get_total_users, get_active_users, \ get_website_users, get_active_website_users import json frappe.connect() ret = { 'last_backup_on': frappe.local.conf.last_backup_on, 'active_users': get_active_users(), 'total_users': get_total_users(), 'active_website_users': get_active_website_users(), 'website_users': get_website_users(), 'system_managers': "\n".join(get_system_managers()), 'default_company': frappe.db.get_default("company"), 'disk_usage': frappe.utils.get_disk_usage(), 'working_directory': frappe.local.site_path } # country, timezone, industry control_panel_details = frappe.db.get_value("Control Panel", "Control Panel", ["country", "time_zone", "industry"], as_dict=True) if control_panel_details: ret.update(control_panel_details) # basic usage/progress analytics for doctype in ("Company", "Customer", "Item", "Quotation", "Sales Invoice", "Journal Voucher", "Stock Ledger Entry"): key = doctype.lower().replace(" ", "_") + "_exists" ret[key] = 1 if frappe.db.count(doctype) else 0 frappe.destroy() if verbose: print json.dumps(ret, indent=1, sort_keys=True) return ret
def reinstall(context, admin_password=None, yes=False): "Reinstall site ie. wipe all data and start over" if not yes: click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True) site = get_site(context) try: frappe.init(site=site) frappe.connect() frappe.clear_cache() installed = frappe.get_installed_apps() frappe.clear_cache() except Exception: installed = [] finally: if frappe.db: frappe.db.close() frappe.destroy() frappe.init(site=site) _new_site(frappe.conf.db_name, site, verbose=context.verbose, force=True, reinstall=True, install_apps=installed, admin_password=admin_password)
def reinstall(context): "Reinstall site ie. wipe all data and start over" site = get_single_site(context) try: frappe.init(site=site) frappe.connect() frappe.clear_cache() installed = frappe.get_installed_apps() frappe.clear_cache() except Exception: installed = [] finally: if frappe.db: frappe.db.close() frappe.destroy() frappe.init(site=site) _new_site(frappe.conf.db_name, site, verbose=context.verbose, force=True, reinstall=True, install_apps=installed)
def publish_realtime(context, event, message, room, user, doctype, docname, after_commit): "Publish realtime event from bench" from frappe import publish_realtime for site in context.sites: try: frappe.init(site=site) frappe.connect() publish_realtime( event, message=message, room=room, user=user, doctype=doctype, docname=docname, after_commit=after_commit, ) frappe.db.commit() finally: frappe.destroy() if not context.sites: raise SiteNotSpecifiedError
def _migrate(site, verbose=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.desk.notifications import clear_notifications frappe.init(site=site) frappe.connect() try: prepare_for_update() # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() finally: frappe.publish_realtime("version-update") frappe.destroy()
def scheduler_task(site, event, handler, now=False): from frappe.utils.scheduler import log traceback = "" task_logger.info('running {handler} for {site} for event: {event}'.format( handler=handler, site=site, event=event)) try: if site not in ['tailorpad.com', 'testfirst']: exec_cmd("../env/bin/frappe --use %s" % (site), cwd="/home/erpnext/admin_site/frappe-bench/sites") frappe.init(site=site) if not create_lock(handler): return if not now: frappe.connect(site=site) frappe.get_attr(handler)() except Exception: frappe.db.rollback() traceback = log( handler, "Method: {event}, Handler: {handler}".format(event=event, handler=handler)) task_logger.warn(traceback) raise else: frappe.db.commit() finally: delete_lock(handler) if not now: frappe.destroy() task_logger.info('ran {handler} for {site} for event: {event}'.format( handler=handler, site=site, event=event))
def latest(rebuild_website_config=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.website import rebuild_config from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.website import statics verbose = not quiet frappe.connect() try: # run patches frappe.local.patch_log_list = [] frappe.modules.patch_handler.run_all() if verbose: print "\n".join(frappe.local.patch_log_list) # sync frappe.model.sync.sync_all(verbose=verbose) sync_fixtures() statics.sync().start() # build website config if any changes in templates etc. if rebuild_website_config: rebuild_config() frappe.translate.clear_cache() except frappe.modules.patch_handler.PatchError: print "\n".join(frappe.local.patch_log_list) raise finally: frappe.destroy()
def enqueue_events_for_site(site, queued_jobs): try: frappe.init(site=site) if frappe.local.conf.maintenance_mode: return if frappe.local.conf.pause_scheduler: return frappe.connect() if is_scheduler_disabled(): return enqueue_events(site=site, queued_jobs=queued_jobs) frappe.logger(__name__).debug('Queued events for site {0}'.format(site)) except: frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site) + '\n' + frappe.get_traceback()) raise finally: frappe.destroy()