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
