def connect_db(url, database, user_name, passwd, flag=True): count = 0 client = "" while count < 5: # Let me try 5 times not more try: _logger.info("Attempt %d %s." % (count, flag)) if flag: client = erppeek.Client(server=str( url)) #Connect without specifying DB for creation of new. else: client = erppeek.Client( server=str(url), db=database, user=user_name, password=passwd ) # connect specifically as new DB has to cloned. Need db's admin credentials break except Exception as e: _logger.info("Could not Connect. Error %s" % str(e)) count += 1 time.sleep(4) if count == 5: _logger.info("Maximum attempt made but couldn't connect") return False # Tried enough times, still couldn't connect. _logger.info("Connection built!! %s" % client) return client
def odoo_setup(): odoo = erppeek.Client(server='http://localhost:8069', ) dbname = u'test' if dbname not in odoo.db.list(): print "Creating database {0}...".format(dbname) odoo.create_database('admin', dbname) print "... Database '{0}' created.".format(dbname) else: print "Database '{0}' already exists.".format(dbname) # Log in database. odoo = erppeek.Client( server='http://localhost:8069', db='test', user='******', password='******', ) modules = [ 'account_accountant', 'web_selenium', ] print "Installing addons..." for module in modules: if module not in odoo.modules()['installed']: assert module in odoo.modules()['uninstalled'], \ '{0} addon is not available. Check extra addons path.' \ .format(module) odoo.install(module) else: print "Addon '{0}' already installed.".format(module) print "... Additional modules installed."
def authenticate(self, username=None, password=None): config = getattr(settings, "ODOO_HOST", False) try: odoo_client = erppeek.Client("%s:%d" % (config['HOST'], config['PORT']), db=config['DB'], user=username, password=password, verbose=False) except: return None caches["odoo_auth"].set('%s_credentials' % username, password, None) try: user = User.objects.get(username=username) odoo_user = user.odoo_user except User.DoesNotExist: # Create a new user. Note that we can set password # to anything, because it won't be checked; the password # from Odoo will. user = User(username=username, password='******') user.is_staff = False user.is_superuser = False user.save() odoo_user = OdooUser(user=user) odoo_user.save() odoo_user.odoo_client = odoo_client return user
def before_all(ctx): if erppeek.__version__ < '1.6': server = erppeek.start_openerp_services(' '.join(OPENERP_ARGS)) else: server = erppeek.start_odoo_services(OPENERP_ARGS) database = server.tools.config['db_name'] def _output_write(text): for stream in ctx.config.outputs: stream.open().write(text) ctx._output_write = _output_write ctx._is_context = True ctx.client = erppeek.Client(server, verbose=ctx.config.verbose) ctx.conf = { 'server': server, 'admin_passwd': server.tools.config['admin_passwd'], 'admin_login_password': server.tools.config.get('admin_login_password', 'admin'), 'db_name': database, 'openerp_config': server.tools.config, }
def getPartnerLang(partner): client = erppeek.Client(**dbconfig.erppeek) partner_obj = client.model('res.partner') partners_ids = partner_obj.search([('ref', '=', partner)]) if not partners_ids: return None return partner_obj.read(partners_ids[0], ['lang'])['lang']
def deploy_test(self): """ Install test modules. """ res = super(ClouderBase, self).deploy_test() if self.application_id.type_id.name == 'odoo': self.log( "client = erppeek.Client('http://" + self.container_id.server_id.ip + ":" + self.odoo_port + "," + "db=" + self.fullname_ + "," + "user="******", password=$$$" + self.admin_password + "$$$)" ) client = erppeek.Client( 'http://' + self.container_id.server_id.ip + ':' + self.odoo_port, db=self.fullname_, user=self.admin_name, password=self.admin_password) if self.application_id.options['test_install_modules']['value']: modules = self.application_id.options[ 'test_install_modules']['value'].split(',') for module in modules: self.log("client.install(" + module + ")") client.install(module) return res
def deploy_build(self): """ Update admin user, install account chart and modules. """ res = super(ClouderBase, self).deploy_build() if self.application_id.type_id.name == 'odoo': self.log( "client = erppeek.Client('http://" + self.container_id.server_id.ip + ":" + self.odoo_port + "," + "db=" + self.fullname_ + "," + "user='******', password=$$$" + self.admin_password + "$$$)") client = erppeek.Client( 'http://' + self.container_id.server_id.ip + ':' + self.odoo_port, db=self.fullname_, user='******', password=self.admin_password) self.log( "admin_id = client.model('ir.model.data')" ".get_object_reference('base', 'user_root')[1]") admin_id = client.model('ir.model.data')\ .get_object_reference('base', 'user_root')[1] self.log("client.model('res.users').write([" + str(admin_id) + "], {'login': "******"})") client.model('res.users').write([admin_id], {'login': self.admin_name}) self.log("extended_group_id = client.model('ir.model.data')" ".get_object_reference('base', 'group_no_one')[1]") extended_group_id = client.model('ir.model.data')\ .get_object_reference('base', 'group_no_one')[1] self.log("client.model('res.users').write([" + str(admin_id) + "], {'groups_id': [(4, " + str(extended_group_id) + ")]})") client.model('res.users').write([1], {'groups_id': [(4, extended_group_id)]}) if self.application_id.options['default_account_chart']['value']\ or self.options['account_chart']['value']: account_chart = self.options['account_chart']['value']\ or self.application_id.options[ 'default_account_chart']['value'] self.log("client.install('account_accountant', " "'account_chart_install', '" + account_chart + "')") client.install('account_accountant', 'account_chart_install', account_chart) self.log("client.execute('account.chart.template', " "'install_chart', '" + account_chart + "', '" + account_chart + "_pcg_chart_template', 1, 1)") client.execute('account.chart.template', 'install_chart', account_chart, account_chart + '_pcg_chart_template', 1, 1) if self.application_id.options['install_modules']['value']: modules = self.application_id.options['install_modules'][ 'value'].split(',') for module in modules: self.log("client.install(" + module + ")") client.install(module) return res
def module_install_upgrade(self, module_name, upgrade=False): print('Module Name: "{0}" (Update: {1})'.format(module_name, upgrade)) client = erppeek.Client(server=self.server, db=self.dbname, user='******', password=self.admin_user_pw) modules = client.modules() if module_name in modules['uninstalled']: print('Installing module "{0}"...'.format(module_name)) client.install(module_name) print('Done.') return True elif upgrade: print('Upgrading module "{0}"...'.format(module_name)) client.upgrade(module_name) print('Done.') return True else: print('Skipping module "{0}"...'.format(module_name)) print('Done.') return False
def install_packages(self, database, install_package): try: client = None module_name = install_package client = erppeek.Client(self.portal_url, database, 'admin', self.defaultpwd) proxy = client.model('ir.module.module') installed_modules = proxy.browse([('state', '=', 'installed')]) for module in installed_modules: logging.info("[INFO] INSTALLED MODULE: " + module.name) for insta_module in module_name: modules = client.modules(insta_module, installed=False) if insta_module in modules['uninstalled']: client.install(insta_module) logging.info( "[SUCCESS] THE MODULE %s HAS BEEN INSTALLED!" % insta_module) except Exception as er: logging.warning( "[WARINING] NEW USER INSTALLED PACKAGE EXCEPTION :: %s" % er) return client
def init_odoo(configuration): odoo = erppeek.Client(configuration.get('url')) odoo.login( configuration.get('login', 'admin'), password=configuration.get('password', 'admin'), database=configuration.get('database')) return odoo
def post_reset(self): """ Disactive mail and cron on a duplicate base. """ res = super(ClouderBase, self).post_reset() if self.application_id.type_id.name == 'odoo': self.log("client = erppeek.Client('http://" + self.container_id.server_id.ip + ":" + self.odoo_port + ", db=" + self.fullname_ + ", user="******", password=$$$" + self.admin_password + "$$$)") client = erppeek.Client('http://' + self.container_id.server_id.ip + ':' + self.odoo_port, db=self.fullname_, user=self.admin_name, password=self.admin_password) self.log("server_id = client.model('ir.model.data')" ".get_object_reference('base', " "'ir_mail_server_localhost0')[1]") server_id = client.model('ir.model.data')\ .get_object_reference('base', 'ir_mail_server_localhost0')[1] self.log("client.model('ir.mail_server').write([" + str(server_id) + "], {'smtp_host': 'mail.disabled.lol'})") client.model('ir.mail_server').write( [server_id], {'smtp_host': 'mail.disabled.lol'}) self.log("cron_ids = client.model('ir.cron')" ".search(['|',('active','=',True),('active','=',False)])") cron_ids = client.model('ir.cron').search( ['|', ('active', '=', True), ('active', '=', False)]) self.log("client.model('ir.cron').write(" + str(cron_ids) + ", {'active': False})") client.model('ir.cron').write(cron_ids, {'active': False}) return res
def odoo_install_modules(url, dbname, user, userpasswd, modules): try: client = erppeek.Client(str(url), db=dbname, user=user, password=userpasswd) client.install(*modules) except: raise return True
def odoo_create_db(server_host, masterpasswd, dbname, lang, adminpasswd): try: client = erppeek.Client(str(server_host)) res = client.create_database(masterpasswd, dbname, lang=lang, user_password=adminpasswd) except: raise return res == 1
def before_all(ctx): conf = None server = None openerp_args = OPENERP_ARGS if hasattr(ctx.config, 'server_config') and ctx.config.server_config: conf = parse_openerp_config(ctx.config.server_config) server = conf['server'] elif OPENERP_IN_PATH: if hasattr(ctx.config, 'server_args') and ctx.config.server_args: openerp_args = ctx.config.server_args.split('|') if erppeek.__version__ < '1.6': server = erppeek.start_openerp_services(' '.join(openerp_args)) else: server = erppeek.start_odoo_services(openerp_args) database = server.tools.config['db_name'] conf = { 'server': server, 'admin_passwd': server.tools.config['admin_passwd'] or 'admin', } conf.update(server.tools.config.options) else: raise ValueError( 'No Odoo/OpenERP configuration file passed ' 'while odoo or openerp is not available in sys path. ' 'Please provide a value for the --server-config option') def _output_write(text): for stream in ctx.config.outputs: stream.open().write(text) assert (conf and server) ctx._output_write = _output_write ctx._is_context = True ctx.client = erppeek.Client(server, verbose=ctx.config.verbose) ctx.conf = conf
def demo_user_setup(self, demo_user_name, demo_user_email, CompanyName, demo_user, demo_user_pw, Demo_User_image): print('Configuring user "Demo"...') client = erppeek.Client(server=self.server, db=self.dbname, user='******', password=self.admin_user_pw) ResUsers = client.model('res.users') args = [ ('name', '=', demo_user_name), ] user = ResUsers.browse(args) if user.id == []: ResPartner = client.model('res.partner') args = [ ('name', '=', CompanyName), ] parent_id = ResPartner.browse(args).id ResCompany = client.model('res.company') args = [ ('name', '=', CompanyName), ] company_id = ResCompany.browse(args).id values = { 'name': demo_user_name, 'customer': False, 'employee': False, 'is_company': False, 'email': demo_user_email, 'website': '', 'parent_id': parent_id[0], 'company_id': company_id[0], 'tz': self.tz, 'lang': self.lang } partner_id = ResPartner.create(values) values = { 'name': demo_user_name, 'partner_id': partner_id, 'company_id': company_id[0], 'login': demo_user, 'password': demo_user_pw, 'image': Demo_User_image, } ResUsers.create(values) print('Done.') else: print('User "{0}" already configured.'.format(demo_user_name)) print('Done.')
def create_newUser_database(self, params=None): try: client = None DATABASE = "TERAFASTNETWORKS" print( "\n [INFO] CREATE DATABASE INPUT PARAMS VALUE :: %s" % params + '\n') client = erppeek.Client(server=self.portal_url) if not DATABASE in client.db.list(): print( "\n [INFO] THE DATABASE DOES NOT EXIST YET CREATING NEW ONE..!!" ) client.create_database(self.dbpwd, DATABASE) print("\n [SUCCESS] NEW DATABASE " + DATABASE + " CREATED IN ODOO SERVER") print("\n [ALERT] YOUR DATABASE " + DATABASE + " CONFIGURATION IN-PROGRESS \n PLEASE WAIT...") time.sleep(10) self.get_newDatabase_admin_id(DATABASE) else: print("\n [WARNING] THE DATABASE " + DATABASE + " ALREADY EXISTS") except Exception as er: print( "\n [WARNING] CREATE NEW-USER DATABASE FUNCTION EXCEPTION :: %s" % er + '\n') return client
def user_groups_setup(self, user_name, group_name_list): print('Executing user_groups_setup...') client = erppeek.Client(server=self.server, db=self.dbname, user='******', password=self.admin_user_pw) ResUsers = client.model('res.users') args = [ ('name', '=', user_name), ] user_id = ResUsers.browse(args).id ResGroups = client.model('res.groups') for group_name in group_name_list: args = [('name', '=', group_name)] group_id = ResGroups.browse(args).id values = { 'groups_id': [(4, group_id[0])], } ResUsers.write(user_id, values) print('Done.')
def test_service_openerp_client(self, server_version=11.0): server = 'http://127.0.0.1:8069/%s' % self.protocol return_values = [str(server_version), ['newdb'], 1] if self.protocol == 'jsonrpc': return_values = [{'result': rv} for rv in return_values] self.service.side_effect = return_values client = erppeek.Client(server, 'newdb', 'usr', 'pss') self.service.return_value = ANY self.assertIsInstance(client.db, erppeek.Service) self.assertIsInstance(client.common, erppeek.Service) self.assertIsInstance(client._object, erppeek.Service) if server_version >= 11.0: self.assertIs(client._report, None) self.assertIs(client._wizard, None) elif server_version >= 7.0: self.assertIsInstance(client._report, erppeek.Service) self.assertIs(client._wizard, None) else: self.assertIsInstance(client._report, erppeek.Service) self.assertIsInstance(client._wizard, erppeek.Service) self.assertIn('/%s|db' % self.protocol, str(client.db.create_database)) self.assertIn('/%s|db' % self.protocol, str(client.db.db_exist)) if server_version >= 8.0: self.assertRaises(AttributeError, getattr, client.db, 'create') self.assertRaises(AttributeError, getattr, client.db, 'get_progress') else: self.assertIn('/%s|db' % self.protocol, str(client.db.create)) self.assertIn('/%s|db' % self.protocol, str(client.db.get_progress)) self.assertCalls(ANY, ANY, ANY) self.assertOutput('')
def create(self): url = 'http://localhost:8069' sock_common = xmlrpclib.ServerProxy('{}/xmlrpc/2/common'.format(url)) print('sock_common.version(): "{0}"'.format(sock_common.version())) client = erppeek.Client(server=self.server) print('Databases found: {0}'.format(client.db.list())) if self.dbname not in client.db.list(): print('Creating database "{0}"...'.format(self.dbname)) client.create_database(passwd=self.super_user_pw, database=self.dbname, demo=self.demo_data, lang=self.lang, user_password=self.admin_user_pw) print('Done.') return True else: print('Database "{0}" already exists.'.format(self.dbname)) print('Done.') return False
def login(username, store): if username: password = getpass('Password for {0}: '.format(username)) if store: config = read_config() config.set("odoo", "username", username) config.set("odoo", "password", password) write_config(config) else: username = os.environ.get("ODOO_LOGIN") password = os.environ.get("ODOO_PASSWORD") if not (username and password): config = read_config() username = config.get("odoo", "username") password = config.get("odoo", "password") if not (username and password): sys.exit("You must provide a Odoo username and password " "in the configuration file or with ODOO_USER and " "ODOO_PASSWORD environment variables.") client = erppeek.Client(ODOO_URL) # workaround to connect on saas: # https://github.com/tinyerp/erppeek/issues/58 client._db = ODOO_DB client.login(username, password) return client
def deploy_create_poweruser(self): """ Create poweruser. """ res = super(ClouderBase, self).deploy_create_poweruser() if self.application_id.type_id.name == 'odoo': if self.poweruser_name and self.poweruser_email \ and self.admin_name != self.poweruser_name: self.log( "client = erppeek.Client('http://" + self.container_id.server_id.ip + ":" + self.odoo_port + "," + "db=" + self.fullname_ + "," + "user="******", password=$$$" + self.admin_password + "$$$)" ) client = erppeek.Client( 'http://' + self.container_id.server_id.name + ':' + self.odoo_port, db=self.fullname_, user=self.admin_name, password=self.admin_password) if self.test: self.log( "demo_id = client.model('ir.model.data')" ".get_object_reference('base', 'user_demo')[1]") demo_id = client.model('ir.model.data')\ .get_object_reference('base', 'user_demo')[1] self.log("client.model('res.users').write([" + str(demo_id) + "], {'login': '******', " "'password': '******'})") client.model('res.users').write([demo_id], {'login': '******', 'password': '******'}) self.log("user_id = client.model('res.users')" ".create({'login':'******', 'name':'" + self.poweruser_name + "', 'email':'" + self.poweruser_email + "', 'password':'******'})") user = client.model('res.users').create( {'login': self.poweruser_email, 'name': self.poweruser_name, 'email': self.poweruser_email, 'password': self.poweruser_password}) if self.application_id.options['poweruser_group']['value']: group = self.application_id.options['poweruser_group'][ 'value'].split('.') self.log("group_id = client.model('ir.model.data')" ".get_object_reference('" + group[0] + "','" + group[1] + "')[1]") group_id = client.model('ir.model.data')\ .get_object_reference(group[0], group[1])[1] self.log("client.model('res.groups').write([" + str(group_id) + "], {'users': [(4, " + str(user.id) + ")]})") client.model('res.groups').write([group_id], {'users': [(4, user.id)]}) return res
def create_db(self,url,db,admin_passwd): _logger.info(type(url)) _logger.info("Connection initiated %s"%url) count = 0 client = "" while count < 10: try: _logger.info("Attempting %d. Eagle should be ready by now"%count) client = erppeek.Client(server=str(url)) break except Exception as e: count += 1 _logger.info("Error %r"%str(e)) time.sleep(4) if count == 10: _logger.info("Connectio Could not be built") return False _logger.info("Connection built %s"%url) try: client.create_database(admin_passwd,db) #using default admin password return True except Exception as e: _logger.info("Error",e) _logger.info("DB Create: %r"%(str(e))) return False
def deploy_database(self): """ Create the database with odoo functions. """ if self.application_id.type_id.name == 'odoo': self.container_id.base_backup_container.execute([ 'mkdir', '-p', '/opt/odoo/data/filestore/' + self.fullname_], username=self.application_id.type_id.system_user) if self.build == 'build': self.log("client = erppeek.Client('http://" + self.container_id.server_id.ip + ":" + self.odoo_port + "')") client = erppeek.Client( 'http://' + self.container_id.server_id.ip + ':' + self.odoo_port) self.log( "client.create_database('$$$" + self.container_id.childs['data'].db_password + "$$$','" + self.fullname_ + "'," + "demo=" + str(self.test) + "," + "lang='" + self.lang + "'," + "user_password='******')") client.create_database( self.container_id.childs['data'].db_password, self.fullname_, demo=self.test, lang=self.lang, user_password=self.admin_password) self.container_id.childs['exec'].start_exec() return True return super(ClouderBase, self).deploy_database()
def test_service_openerp_client(self, server_version='8.0'): server = 'http://127.0.0.1:8069' self.service.side_effect = [server_version, ['newdb'], 1] client = erppeek.Client(server, 'newdb', 'usr', 'pss') self.service.return_value = ANY self.assertIsInstance(client.db, erppeek.Service) self.assertIsInstance(client.common, erppeek.Service) self.assertIsInstance(client._object, erppeek.Service) self.assertIsInstance(client._report, erppeek.Service) if server_version >= '7.0': self.assertNotIsInstance(client._wizard, erppeek.Service) else: self.assertIsInstance(client._wizard, erppeek.Service) self.assertIn('/xmlrpc/db', str(client.db.create_database)) self.assertIn('/xmlrpc/db', str(client.db.db_exist)) if server_version == '8.0': self.assertRaises(AttributeError, getattr, client.db, 'create') self.assertRaises(AttributeError, getattr, client.db, 'get_progress') else: self.assertIn('/xmlrpc/db', str(client.db.create)) self.assertIn('/xmlrpc/db', str(client.db.get_progress)) self.assertCalls(ANY, ANY, ANY) self.assertOutput('')
def odoo_start(): try: erppeek.Client(server='http://localhost:8069') except: cmd = 'docker-compose up -d' subprocess.call(cmd, shell=True) else: print "Odoo server is running." return # Wait for Odoo to be loaded. print "Waiting for Odoo server to be available..." time.sleep(3) limit = time.time() + 30 proofs_of_service = [ 'openerp.service.server: HTTP service (werkzeug) ' # ... 'running on 0.0.0.0:8069', 'openerp.addons.bus.bus: Bus.loop listen imbus on db postgres', ] while time.time() < limit: cmd = 'docker logs {docker_instance}'.format( docker_instance='odooselenium_odoo_1') output = subprocess.check_output(cmd, shell=True) if all([proof in output for proof in proofs_of_service]): break else: time.sleep(1) print "... Odoo server up and running!"
def create_additional_users(self, params=None): try: resp = None DATABASE = params.get("client_name").upper() username = params.get("client_username") client = erppeek.Client(server = self.portal_url) if DATABASE in client.db.list(): self.connection = postgreLib.postgreLib(self.dbIp, self.dbPort, self.dbusername, self.dbpwd, DATABASE) self.connect = self.connection.connect_postgreSQL() result = self.connection.getRecords(self.connect, DATABASE, "res_users") if result is not None: for rows in result: if rows[0] == username: resp = {'auth-result': 'Complete'} break else: resp = {'auth-result': 'Invalid User'} else: logging.warning("[WARNING] USER RESULT NOT FOUND IN ODOO") else: resp = {'auth-result':'Invalid User'} except Exception as er: logging.warning("[WARNING] CREATE ADDTIONAL USERS EXCEPTION :: %s"%er) return resp
def get_product_linked_database(self, cr, uid, ids, default_code, context=None): """ Connect with linked database to get extra info """ connector = self.browse(cr, uid, ids, context=context)[0] # --------------------------------------------------------------------- # Connect to ODOO: # --------------------------------------------------------------------- if not connector.linked_server: return False odoo = erppeek.Client( 'http://%s:%s' % (connector.linked_server, connector.linked_port), db=connector.linked_dbname, user=connector.linked_user, password=connector.linked_pwd, ) product_pool = odoo.model('product.product') product_ids = product_pool.search([ ('default_code', '=', default_code), ]) if not product_ids: _logger.error('No product with %s code' % default_code) return False return product_pool.browse(product_ids)[0]
def create_newUser_database(self, params): try: client = None resp = None DATABASE = params.get("databaseName").upper() logging.info("CREATE DATABASE INPUT PARAMS VALUE :: %s"%params+'\n') client = erppeek.Client(server = self.portal_url) #url = client.split("xmlrpc") if not DATABASE in client.db.list(): logging.info("THE DATABASE DOES NOT EXIST YET CREATING NEW ONE..!!") self.status = "New database creation in-progress" print "***********************", self.dbpwd client.create_database(self.dbpwd, DATABASE, lang='pt_BR') logging.info("[SUCCESS] NEW DATABASE " + DATABASE +" CREATED IN ODOO SERVER") time.sleep(5) self.status = "Your database created successfull" logging.critical("[ALERT] YOUR DATABASE " + DATABASE + " CONFIGURATION IN-PROGRESS \n PLEASE WAIT...") self.status = "Database configuration in-progress" time.sleep(10) self.get_newDatabase_admin_id(DATABASE, params) self.create_db_sub_users(DATABASE, params) self.load_base_language(DATABASE) resp = {"result" : "Created"} else: logging.warning("THE DATABASE " + DATABASE + " ALREADY EXISTS") resp = {"result":"database name already exists"} except Exception as er: logging.warning("CREATE NEW-USER DATABASE FUNCTION EXCEPTION :: %s"%er+'\n') return resp
def drop_db(server, password, name): connection = erppeek.Client(server) echo = "fail" try: connection.db.drop(password, name) except: return echo
def setup(self): """ Setup Odoo Project Space """ username = self._odoo_username password = self._odoo_password odoo_url = self._odoo_server_url database = self._odoo_database_name pm_id = self._odoo_pm odoo_client = erppeek.Client(odoo_url, database, username, password) data = { 'name': self._project_name, 'project_code': self._project_key, 'active': True, 'type': "contract", 'label_tasks': "Tasks", 'state': "open", 'user_id': pm_id, 'alias_model': "project.task", 'privacy_visibility': "employees", 'called_through_ingen_write': True } project_id = odoo_client.create('project.project', data) return project_id