Example #1
0
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
	try:
		import conf
	except ImportError, e:
		conf = webnotes._dict({})
Example #2
0
def rebuild():
	# build js / css
	from webnotes import build
	build.bundle(False)		
Example #3
0
	def install(self, db_name, source_sql=None, admin_password = '******', verbose=0,
		force=0):
		
		if force or (db_name not in self.dbman.get_database_list()):
			# delete user (if exists)
			self.dbman.delete_user(db_name)
		else:
			raise Exception("Database %s already exists" % (db_name,))

		# create user and db
		self.dbman.create_user(db_name, webnotes.conf.db_password)
			
		if verbose: print "Created user %s" % db_name
	
		# create a database
		self.dbman.create_database(db_name)
		if verbose: print "Created database %s" % db_name
		
		# grant privileges to user
		self.dbman.grant_all_privileges(db_name, db_name)
		if verbose: print "Granted privileges to user %s and database %s" % (db_name, db_name)

		# flush user privileges
		self.dbman.flush_privileges()
		
		# close root connection
		self.conn.close()

		webnotes.connect(db_name=db_name, site=self.site)
		self.dbman = DbManager(webnotes.conn)
		
		# import in db_name
		if verbose: print "Starting database import..."

		# get the path of the sql file to import
		if not source_sql:
			source_sql = os.path.join(os.path.dirname(webnotes.__file__), "..", 
				'conf', 'Framework.sql')

		self.dbman.restore_database(db_name, source_sql, db_name, webnotes.conf.db_password)
		if verbose: print "Imported from database %s" % source_sql
		
		self.create_auth_table()

		# fresh app
		if 'Framework.sql' in source_sql:
			if verbose: print "Installing app..."
			self.install_app(verbose=verbose)

		# update admin password
		self.update_admin_password(admin_password)
		
		# create public folder
		from webnotes.install_lib import setup_public_folder
		setup_public_folder.make(site=self.site)
		
		if not self.site:
			from webnotes.build import bundle
			bundle(False)
		
		return db_name
Example #4
0
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
Example #5
0
    def install(self,
                db_name,
                source_sql=None,
                admin_password='******',
                verbose=0,
                force=0):

        if force or (db_name not in self.dbman.get_database_list()):
            # delete user (if exists)
            self.dbman.delete_user(db_name)
        else:
            raise Exception("Database %s already exists" % (db_name, ))

        # create user and db
        self.dbman.create_user(db_name, webnotes.conf.db_password)

        if verbose: print "Created user %s" % db_name

        # create a database
        self.dbman.create_database(db_name)
        if verbose: print "Created database %s" % db_name

        # grant privileges to user
        self.dbman.grant_all_privileges(db_name, db_name)
        if verbose:
            print "Granted privileges to user %s and database %s" % (db_name,
                                                                     db_name)

        # flush user privileges
        self.dbman.flush_privileges()

        # close root connection
        self.conn.close()

        webnotes.connect(db_name=db_name, site=self.site)
        self.dbman = DbManager(webnotes.conn)

        # import in db_name
        if verbose: print "Starting database import..."

        # get the path of the sql file to import
        if not source_sql:
            source_sql = os.path.join(os.path.dirname(webnotes.__file__), "..",
                                      'conf', 'Framework.sql')

        self.dbman.restore_database(db_name, source_sql, db_name,
                                    webnotes.conf.db_password)
        if verbose: print "Imported from database %s" % source_sql

        self.create_auth_table()

        # fresh app
        if 'Framework.sql' in source_sql:
            if verbose: print "Installing app..."
            self.install_app(verbose=verbose)

        # update admin password
        self.update_admin_password(admin_password)

        # create public folder
        from webnotes.install_lib import setup_public_folder
        setup_public_folder.make(site=self.site)

        if not self.site:
            from webnotes.build import bundle
            bundle(False)

        return db_name
Example #6
0
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