def switch_module(dt, dn, to, frm=None, export=None):
"""
Change the module of the given doctype, if export is true, then also export txt and copy
code files from src
"""
webnotes.conn.sql("update `tab"+dt+"` set module=%s where name=%s", (to, dn))
if export:
export_doc(dt, dn)
# copy code files
if dt in ('DocType', 'Page', 'Report'):
from_path = os.path.join(get_module_path(frm), scrub(dt), scrub(dn), scrub(dn))
to_path = os.path.join(get_module_path(to), scrub(dt), scrub(dn), scrub(dn))
# make dire if exists
os.system('mkdir -p %s' % os.path.join(get_module_path(to), scrub(dt), scrub(dn)))
for ext in ('py','js','html','css'):
os.system('cp %s %s')
def switch_module(dt, dn, to, frm=None, export=None):
"""
Change the module of the given doctype, if export is true, then also export txt and copy
code files from src
"""
webnotes.conn.sql("update `tab" + dt + "` set module=%s where name=%s",
(to, dn))
if export:
export_doc(dt, dn)
# copy code files
if dt in ('DocType', 'Page', 'Report'):
from_path = os.path.join(get_module_path(frm), scrub(dt),
scrub(dn), scrub(dn))
to_path = os.path.join(get_module_path(to), scrub(dt), scrub(dn),
scrub(dn))
# make dire if exists
os.system('mkdir -p %s' %
os.path.join(get_module_path(to), scrub(dt), scrub(dn)))
for ext in ('py', 'js', 'html', 'css'):
os.system('cp %s %s')
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes.utils import bundlejs
if options.no_cms:
cms_make = False
else:
cms_make = True
bundlejs.bundle(False, cms_make)
return
elif options.watch:
from webnotes.utils import bundlejs
bundlejs.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.',
options.replace[0],
options.replace[1],
options.replace[2],
force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull, options.install_fresh]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir('lib')
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir('../app')
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
os.chdir('lib')
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('../app')
os.system('git push %s %s' % (options.push[0], options.push[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0],
source_path=options.install[1],
verbose=1)
elif options.install_fresh:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install_fresh,
source_path="lib/conf/Framework.sql",
verbose=1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' +
options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
webnotes.reload_doc(options.sync[0], "doctype", options.sync[1])
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain',
options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import webnotes.webutils
webnotes.webutils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup(ignore_files=True)
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
if options.test is not None:
module_name = options.test
import unittest
del sys.argv[1:]
# is there a better way?
exec('from %s import *' % module_name) in globals()
unittest.main()
elif options.build_message_files:
import webnotes.translate
webnotes.translate.build_message_files()
elif options.export_messages:
import webnotes.translate
webnotes.translate.export_messages(*options.export_messages)
elif options.import_messages:
import webnotes.translate
webnotes.translate.import_messages(*options.import_messages)
elif options.google_translate:
from webnotes.translate import google_translate
google_translate(*options.google_translate)
elif options.translate:
from webnotes.translate import build_message_files, \
export_messages, google_translate, import_messages
languages = [options.translate]
if options.translate == "all":
from startup import lang_list
languages = lang_list
print "Extracting messages..."
build_message_files()
for lang in languages:
if lang != "en":
filename = 'app/translations/' + lang + '.csv'
print "For " + lang + ":"
print "Compiling messages in one file..."
export_messages(lang, '_lang_tmp.csv')
print "Translating via Google Translate..."
google_translate(lang, '_lang_tmp.csv', filename)
print "Updating language files..."
import_messages(lang, filename)
print "Deleting temp files..."
os.remove('_lang_tmp.csv')
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes.utils import bundlejs
if options.no_cms:
cms_make = False
else:
cms_make = True
bundlejs.bundle(options.no_compress, cms_make)
return
elif options.watch:
from webnotes.utils import bundlejs
bundlejs.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.', options.replace[0], options.replace[1], options.replace[2], force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir('lib')
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir('../app')
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
os.chdir('lib')
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('../app')
os.system('git push %s %s' % (options.push[0], options.push[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0], source_path=options.install[1], \
password='******', verbose = 1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' + options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
import webnotes.model.sync
webnotes.model.sync.sync(options.sync[0], options.sync[1], options.force or 0)
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain', options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import website.utils
website.utils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup()
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
if options.test is not None:
module_name = options.test
import unittest
del sys.argv[1:]
# is there a better way?
exec ('from %s import *' % module_name) in globals()
unittest.main()
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes.utils import bundlejs
if options.no_cms:
cms_make = False
else:
cms_make = True
bundlejs.bundle(False, cms_make)
return
elif options.watch:
from webnotes.utils import bundlejs
bundlejs.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.', options.replace[0], options.replace[1], options.replace[2], force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull, options.install_fresh]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir('lib')
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir('../app')
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
os.chdir('lib')
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('../app')
os.system('git push %s %s' % (options.push[0], options.push[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0], source_path=options.install[1],
verbose = 1)
elif options.install_fresh:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install_fresh, source_path="lib/conf/Framework.sql",
verbose = 1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' + options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
import webnotes.model.sync
webnotes.model.sync.sync(options.sync[0], options.sync[1], options.force or 0)
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain', options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import website.utils
website.utils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup()
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
if options.test is not None:
module_name = options.test
import unittest
del sys.argv[1:]
# is there a better way?
exec ('from %s import *' % module_name) in globals()
unittest.main()
elif options.build_message_files:
import webnotes.translate
webnotes.translate.build_message_files()
elif options.export_messages:
import webnotes.translate
webnotes.translate.export_messages(*options.export_messages)
elif options.import_messages:
import webnotes.translate
webnotes.translate.import_messages(*options.import_messages)
elif options.google_translate:
from webnotes.translate import google_translate
google_translate(*options.google_translate)
elif options.translate:
from webnotes.translate import build_message_files, \
export_messages, google_translate, import_messages
languages = [options.translate]
if options.translate=="all":
from startup import lang_list
languages = lang_list
print "Extracting messages..."
build_message_files()
for lang in languages:
if lang != "en":
filename = 'app/translations/'+lang+'.csv'
print "For " + lang + ":"
print "Compiling messages in one file..."
export_messages(lang, '_lang_tmp.csv')
print "Translating via Google Translate..."
google_translate(lang, '_lang_tmp.csv', filename)
print "Updating language files..."
import_messages(lang, filename)
print "Deleting temp files..."
os.remove('_lang_tmp.csv')
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root', options.root_password)
inst.import_from_db(options.install[0], source_path=options.install[1],
verbose = 1)
elif options.install_fresh:
from webnotes.install_lib.install import Installer
inst = Installer('root', options.root_password)
inst.import_from_db(options.install_fresh, verbose = 1)
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes import build
if options.no_cms:
cms_make = False
else:
cms_make = True
build.bundle(False, cms_make)
return
elif options.watch:
from webnotes import build
build.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.', options.replace[0], options.replace[1], options.replace[2], force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
webnotes.print_messages = True
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull, options.install_fresh]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir('lib')
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir('../app')
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
if not args:
args = ["origin", conf.branch]
os.chdir('lib')
os.system('git push %s %s' % (args[0], args[1]))
os.chdir('../app')
os.system('git push %s %s' % (args[0], args[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0], source_path=options.install[1],
verbose = 1)
elif options.install_fresh:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install_fresh, verbose = 1)
elif options.make_demo:
import utilities.make_demo
utilities.make_demo.make()
elif options.make_demo_fresh:
import utilities.make_demo
utilities.make_demo.make(True)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' + options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
webnotes.reload_doc(options.sync[0], "doctype", options.sync[1])
elif options.update:
if not args:
args = ["origin", conf.branch]
update_erpnext(args[0], args[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain', options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import webnotes.webutils
webnotes.webutils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.clear_defaults:
import webnotes.defaults
webnotes.defaults.clear_cache()
webnotes.clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup(ignore_files = True)
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
elif options.build_message_files:
import webnotes.translate
webnotes.translate.build_message_files()
elif options.export_messages:
import webnotes.translate
webnotes.translate.export_messages(*options.export_messages)
elif options.import_messages:
import webnotes.translate
webnotes.translate.import_messages(*options.import_messages)
elif options.google_translate:
from webnotes.translate import google_translate
google_translate(*options.google_translate)
elif options.translate:
from webnotes.translate import translate
translate(options.translate)
elif options.docs:
from core.doctype.documentation_tool.documentation_tool import write_static
write_static()
elif options.reset_perms:
for d in webnotes.conn.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
try:
webnotes.clear_cache(doctype=d)
webnotes.reset_perms(d)
except:
pass
def run():
sys.path.append(".")
sys.path.append("lib")
sys.path.append("app")
(options, args) = setup_options()
# build
if options.build:
from webnotes.utils import bundlejs
if options.no_cms:
cms_make = False
else:
cms_make = True
bundlejs.bundle(False, cms_make)
return
elif options.watch:
from webnotes.utils import bundlejs
bundlejs.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code(".", options.replace[0], options.replace[1], options.replace[2], force=options.force)
return
# git
elif options.status:
os.chdir("lib")
os.system("git status")
os.chdir("../app")
os.system("git status")
return
elif options.git:
os.chdir("lib")
os.system("git %s" % options.git)
os.chdir("../app")
os.system("git %s" % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir("lib")
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir("../app")
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
os.chdir("lib")
os.system("git push %s %s" % (options.push[0], options.push[1]))
os.chdir("../app")
os.system("git push %s %s" % (options.push[0], options.push[1]))
elif options.checkout:
os.chdir("lib")
os.system("git checkout %s" % options.checkout)
os.chdir("../app")
os.system("git checkout %s" % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(patchmodule=patch, force=options.force)
print "\n".join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(
{"module": options.reload_doc[0], "dt": options.reload_doc[1], "dn": options.reload_doc[2]}
)
print "\n".join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer("root")
inst.import_from_db(options.install[0], source_path=options.install[1], password="******", verbose=1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger("execute_" + options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
import webnotes.model.sync
webnotes.model.sync.sync(options.sync[0], options.sync[1], options.force or 0)
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value("Website Settings", None, "subdomain", options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import website.utils
website.utils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup()
# print messages
if webnotes.message_log:
print "\n".join(webnotes.message_log)
if options.test is not None:
module_name = options.test
import unittest
del sys.argv[1:]
# is there a better way?
exec ("from %s import *" % module_name) in globals()
unittest.main()
elif options.build_message_files:
import webnotes.translate
webnotes.translate.build_message_files()
elif options.export_messages:
import webnotes.translate
webnotes.translate.export_messages(*options.export_messages)
elif options.import_messages:
import webnotes.translate
webnotes.translate.import_messages(*options.import_messages)
elif options.google_translate:
from webnotes.translate import google_translate
google_translate(*options.google_translate)
elif options.translate:
from webnotes.translate import build_message_files, export_messages, google_translate, import_messages
print "Extracting messages..."
build_message_files()
print "Compiling messages in one file..."
export_messages(options.translate, "_lang_tmp.csv")
print "Translating via Google Translate..."
google_translate(options.translate, "_lang_tmp.csv", "_lang_tmp1.csv")
print "Updating language files..."
import_messages(options.translate, "_lang_tmp1.csv")
print "Deleting temp files..."
os.remove("_lang_tmp.csv")
os.remove("_lang_tmp1.csv")
def run():
sys.path.append('lib')
sys.path.append('lib/py')
import webnotes
import webnotes.defs
sys.path.append(webnotes.defs.modules_path)
(options, args) = setup_options()
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
webnotes.connect(options.db_name)
# build
if options.build:
import build.project
build.project.build()
elif options.clear:
from build.project import increment_version
print "Version:" + str(increment_version())
# code replace
elif options.replace:
replace_code('.', options.replace[0], options.replace[1],
options.replace[2])
# git
elif options.status:
os.system('git status')
os.chdir('lib')
os.system('git status')
elif options.pull:
os.system('git pull %s %s' % (options.pull[0], options.pull[1]))
os.chdir('lib')
os.system('git pull %s %s' % (options.pull[0], options.pull[1]))
elif options.push:
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('lib')
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
webnotes.modules.patch_handler.run_all()
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root', options.install[0])
inst.import_from_db(options.install[1], source_path=options.install[2], \
password='******', verbose = 1)
elif options.sync_with_gateway:
if int(options.sync_with_gateway[0]) in [0, 1]:
webnotes.conn.begin()
webnotes.conn.sql(
"""\
UPDATE `tabSingles` SET value=%s
WHERE field='sync_with_gateway' AND doctype='Control Panel'""",
int(options.sync_with_gateway[0]))
webnotes.conn.commit()
webnotes.message_log.append("sync_with_gateway set to %s" %
options.sync_with_gateway[0])
else:
webnotes.message_log.append(
"ERROR: sync_with_gateway can be either 0 or 1")
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' +
options.run_scheduler_event)
elif options.cci is not None:
if options.cci == 'all':
webnotes.conn.sql("DELETE FROM __CacheItem")
else:
from webnotes.utils.cache import CacheItem
CacheItem(options.cci).clear()
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes.utils import bundlejs
if options.no_cms:
cms_make = False
else:
cms_make = True
bundlejs.bundle(options.no_compress, cms_make)
return
elif options.watch:
from webnotes.utils import bundlejs
bundlejs.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.',
options.replace[0],
options.replace[1],
options.replace[2],
force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.push:
os.chdir('lib')
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('../app')
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0], source_path=options.install[1], \
password='******', verbose = 1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' +
options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
import webnotes.model.sync
webnotes.model.sync.sync(options.sync[0], options.sync[1],
options.force or 0)
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain',
options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.build_web_cache:
# build wn-web.js and wn-web.css
import webnotes.cms.make
webnotes.cms.make.make()
import website.web_cache
website.web_cache.refresh_cache(['Blog'])
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup()
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
if options.test is not None:
module_name = options.test
import unittest
del sys.argv[1:]
# is there a better way?
exec('from %s import *' % module_name) in globals()
unittest.main()
def run():
sys.path.append('.')
sys.path.append('lib/py')
import webnotes
import conf
sys.path.append(conf.modules_path)
(options, args) = setup_options()
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull]):
webnotes.connect(conf.db_name)
# build
if options.build:
import build.project
build.project.build()
# code replace
elif options.replace:
print options.replace
replace_code('.', options.replace[0], options.replace[1], options.replace[2])
# git
elif options.status:
os.system('git status')
os.chdir('lib')
os.system('git status')
elif options.pull:
pull(options.pull[0], options.pull[1])
elif options.push:
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('lib')
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
elif options.checkout:
os.system('git checkout %s' % options.checkout)
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0], source_path=options.install[1], \
password='******', verbose = 1)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' + options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
import webnotes.model.sync
webnotes.model.sync.sync(options.sync[0], options.sync[1], options.force or 0)
elif options.update:
update_erpnext(options.update[0], options.update[1])
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain', options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.build_web_cache:
import website.web_cache
website.web_cache.refresh_cache(True)
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
def run():
sys.path.append('lib')
sys.path.append('lib/py')
import webnotes
import webnotes.defs
sys.path.append(webnotes.defs.modules_path)
(options, args) = setup_options()
from webnotes.db import Database
import webnotes.modules.patch_handler
# connect
if options.db_name is not None:
webnotes.connect(options.db_name)
# build
if options.build:
import build.project
build.project.build()
elif options.clear:
from build.project import increment_version
print "Version:" + str(increment_version())
# code replace
elif options.replace:
replace_code('.', options.replace[0], options.replace[1], options.replace[2])
# git
elif options.status:
os.system('git status')
os.chdir('lib')
os.system('git status')
elif options.pull:
os.system('git pull %s %s' % (options.pull[0], options.pull[1]))
os.chdir('lib')
os.system('git pull %s %s' % (options.pull[0], options.pull[1]))
elif options.push:
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
os.chdir('lib')
os.system('git commit -a -m "%s"' % options.push[2])
os.system('git push %s %s' % (options.push[0], options.push[1]))
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
webnotes.modules.patch_handler.run_all()
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root', options.install[0])
inst.import_from_db(options.install[1], source_path=options.install[2], \
password='******', verbose = 1)
elif options.sync_with_gateway:
if int(options.sync_with_gateway[0]) in [0, 1]:
webnotes.conn.begin()
webnotes.conn.sql("""\
UPDATE `tabSingles` SET value=%s
WHERE field='sync_with_gateway' AND doctype='Control Panel'""", int(options.sync_with_gateway[0]))
webnotes.conn.commit()
webnotes.message_log.append("sync_with_gateway set to %s" % options.sync_with_gateway[0])
else:
webnotes.message_log.append("ERROR: sync_with_gateway can be either 0 or 1")
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' + options.run_scheduler_event)
elif options.cci is not None:
if options.cci=='all':
webnotes.conn.sql("DELETE FROM __CacheItem")
else:
from webnotes.utils.cache import CacheItem
CacheItem(options.cci).clear()
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
def run():
sys.path.append('.')
sys.path.append('lib')
sys.path.append('app')
(options, args) = setup_options()
# build
if options.build:
from webnotes import build
if options.no_cms:
cms_make = False
else:
cms_make = True
build.bundle(False, cms_make)
return
elif options.watch:
from webnotes import build
build.watch(True)
return
# code replace
elif options.replace:
print options.replace
replace_code('.',
options.replace[0],
options.replace[1],
options.replace[2],
force=options.force)
return
# git
elif options.status:
os.chdir('lib')
os.system('git status')
os.chdir('../app')
os.system('git status')
return
elif options.git:
os.chdir('lib')
os.system('git %s' % options.git)
os.chdir('../app')
os.system('git %s' % options.git)
return
import webnotes
import conf
from webnotes.db import Database
import webnotes.modules.patch_handler
webnotes.print_messages = True
# connect
if options.db_name is not None:
if options.password:
webnotes.connect(options.db_name, options.password)
else:
webnotes.connect(options.db_name)
elif not any([options.install, options.pull, options.install_fresh]):
webnotes.connect(conf.db_name)
if options.pull:
pull(options.pull[0], options.pull[1], build=True)
elif options.commit:
os.chdir('lib')
os.system('git commit -a -m "%s"' % (options.commit))
os.chdir('../app')
os.system('git commit -a -m "%s"' % (options.commit))
elif options.push:
if not args:
args = ["origin", conf.branch]
os.chdir('lib')
os.system('git push %s %s' % (args[0], args[1]))
os.chdir('../app')
os.system('git push %s %s' % (args[0], args[1]))
elif options.checkout:
os.chdir('lib')
os.system('git checkout %s' % options.checkout)
os.chdir('../app')
os.system('git checkout %s' % options.checkout)
# patch
elif options.patch_list:
# clear log
webnotes.modules.patch_handler.log_list = []
# run individual patches
for patch in options.patch_list:
webnotes.modules.patch_handler.run_single(\
patchmodule = patch, force = options.force)
print '\n'.join(webnotes.modules.patch_handler.log_list)
# reload
elif options.reload_doc:
webnotes.modules.patch_handler.reload_doc(\
{"module":options.reload_doc[0], "dt":options.reload_doc[1], "dn":options.reload_doc[2]})
print '\n'.join(webnotes.modules.patch_handler.log_list)
elif options.export_doc:
from webnotes.modules import export_doc
export_doc(options.export_doc[0], options.export_doc[1])
# run all pending
elif options.run_latest:
apply_latest_patches()
elif options.install:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install[0],
source_path=options.install[1],
verbose=1)
elif options.install_fresh:
from webnotes.install_lib.install import Installer
inst = Installer('root')
inst.import_from_db(options.install_fresh, verbose=1)
elif options.make_demo:
import utilities.make_demo
utilities.make_demo.make()
elif options.make_demo_fresh:
import utilities.make_demo
utilities.make_demo.make(True)
elif options.diff_ref_file is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_file()
elif options.diff_ref_db is not None:
import webnotes.modules.diff
webnotes.modules.diff.diff_ref_db()
elif options.run_scheduler:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.execute()
elif options.run_scheduler_event is not None:
import webnotes.utils.scheduler
print webnotes.utils.scheduler.trigger('execute_' +
options.run_scheduler_event)
elif options.sync_all is not None:
sync_all(options.force or 0)
elif options.sync is not None:
webnotes.reload_doc(options.sync[0], "doctype", options.sync[1])
elif options.update:
if not args:
args = ["origin", conf.branch]
update_erpnext(args[0], args[1])
elif options.patch_sync_build:
patch_sync_build()
elif options.patch_sync:
patch_sync()
elif options.cleanup_data:
from utilities import cleanup_data
cleanup_data.run()
elif options.domain:
webnotes.conn.set_value('Website Settings', None, 'subdomain',
options.domain)
webnotes.conn.commit()
print "Domain set to", options.domain
elif options.clear_web:
# build wn-web.js and wn-web.css
from website.helpers.make_web_include_files import make
make()
import webnotes.webutils
webnotes.webutils.clear_cache()
elif options.clear_cache:
clear_cache()
elif options.clear_defaults:
import webnotes.defaults
webnotes.defaults.clear_cache()
webnotes.clear_cache()
elif options.append_future_import:
append_future_import()
elif options.backup:
from webnotes.utils.backups import scheduled_backup
scheduled_backup(ignore_files=True)
# print messages
if webnotes.message_log:
print '\n'.join(webnotes.message_log)
elif options.build_message_files:
import webnotes.translate
webnotes.translate.build_message_files()
elif options.export_messages:
import webnotes.translate
webnotes.translate.export_messages(*options.export_messages)
elif options.import_messages:
import webnotes.translate
webnotes.translate.import_messages(*options.import_messages)
elif options.google_translate:
from webnotes.translate import google_translate
google_translate(*options.google_translate)
elif options.translate:
from webnotes.translate import translate
translate(options.translate)
elif options.docs:
from core.doctype.documentation_tool.documentation_tool import write_static
write_static()
elif options.reset_perms:
for d in webnotes.conn.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
try:
webnotes.clear_cache(doctype=d)
webnotes.reset_perms(d)
except:
pass
