def synchronize_helpdesk_solicitation(self):
env_inter = self.env['crm.helpdesk.trustcode.interaction']
url = self.env.user.company_id.url_trustcode
if url:
cnpj = self.env.user.company_id.cnpj_cpf
odoo = odoorpc.ODOO(url, port=80)
result = odoo.json('/helpdesk/list', {'cnpj': cnpj})
if result['result']['sucesso']:
for item in result['result']['solicitations']:
help_sol = self.search([('trustcode_id', '=',
item['trustcode_id'])])
if help_sol:
help_sol.state = item['state']
help_sol.responsible = item['responsible']
help_sol.priority = item['priority']
for interact in item['interactions']:
inter = env_inter.search([
('trustcode_id', '=', interact['trustcode_id'])
])
if inter:
inter.state = interact['state']
inter.name = interact['name']
inter.responsible = interact['responsible']
inter.interacao_trustcode = interact[
'interacao_trustcode']
inter.time_since_last_interaction = interact[
'time_since_last_interaction']
else:
interact['crm_help_id'] = help_sol.id
int_env = self.env[
'crm.helpdesk.trustcode.interaction']
int_env.create(interact)
def connectL8(ctx):
"""Open connection to Odoo service"""
try:
if ctx['svc_protocol'] == 'jsonrpc':
odoo = odoorpc.ODOO(ctx['db_host'], ctx['svc_protocol'],
ctx['xmlrpc_port'])
else:
odoo = oerplib.OERP(server=ctx['db_host'],
protocol=ctx['svc_protocol'],
port=ctx['xmlrpc_port'],
version=ctx['oe_version'])
except BaseException: # pragma: no cover
return u"!Odoo server %s is not running!" % ctx['oe_version']
if ctx['svc_protocol'] == 'jsonrpc':
ctx['server_version'] = odoo.version
else:
try:
ctx['server_version'] = odoo.db.server_version()
except BaseException:
ctx['server_version'] = odoo.version
x = re.match(r'[0-9]+\.[0-9]+', ctx['server_version'])
if ctx['server_version'][0:x.end()] != ctx['oe_version']:
return u"!Invalid Odoo Server version: expected %s, found %s!" % \
(ctx['oe_version'], ctx['server_version'])
ctx['majver'] = int(ctx['server_version'].split('.')[0])
ctx['odoo_session'] = odoo
return True
def setup_rpc_session(self):
try:
logger.info('Connecting to Odoo at %s://%s:%s', self.protocol,
self.host, self.port)
odoo = odoorpc.ODOO(self.host,
port=self.port,
protocol=self.protocol)
odoo.login(self.db, self.user, self.password)
logger.info('Connected to Odoo as %s', self.user)
self.odoo = odoo
self.container.spawn_managed_thread(self.update_token)
self.container.spawn_managed_thread(self.ping_on_start)
if not self.connected.ready():
self.connected.send()
return True
except odoorpc.error.RPCError as e:
if 'res.users()' in str(e):
logger.error('Odoo login %s not found or bad password %s.',
self.user, self.password)
elif 'FATAL' in repr(e):
logger.error('Odoo fatal error: %s', e)
else:
logger.exception('RPC error:')
except URLError as e:
logger.error(e)
except Exception as e:
if 'Connection refused' in repr(e):
logger.error('Odoo refusing connection.')
else:
logger.exception(e)
def connect_odoo(section):
# 获取实例连接参数
url = config.get(section, 'url')
port = config.getint(section, 'port')
db = config.get(section, 'db')
login = config.get(section, 'login')
password = config.get(section, 'password')
# 跟进ssl参数，使用相应协议进行连接
ssl._create_default_https_context = ssl._create_unverified_context
protocol = 'jsonrpc+ssl' if config.getboolean(section,
'ssl') else 'jsonrpc'
# 连接数据库
odoo = odoorpc.ODOO(url,
port=port,
protocol=protocol,
version='9.0',
timeout=10000)
# 登录远程系统:数据库/用户名/密码
odoo.login(db, login, password)
user = odoo.env.user
print 'Welcome login %s: %s' % (section, user.name)
return odoo
def send_to_trustcode(self, vals):
url = self.env.user.company_id.url_trustcode
cnpj = self.env.user.company_id.cnpj_cpf
odoo = odoorpc.ODOO(url, port=80)
vals['cnpj'] = cnpj
r = odoo.json('/helpdesk/new', vals)
vals['trustcode_id'] = r['result']['trustcode_id']
def prepare_connection(url, port):
"""
Build the OdooRPC connection object
:param url: Odoo URL
:param port: Port number
"""
port = int(port)
_protocol = 'jsonrpc+ssl'
if url.startswith('https'):
url = url.replace('https:', '')
if port <= 0:
port = 443
elif url.startswith('http:'):
url = url.replace('http:', '')
_protocol = 'jsonrpc'
while url and url.startswith('/'):
url = url[1:]
while url and url.endswith('/'):
url = url[:-1]
while url and url.endswith('\\'):
url = url[:-1]
connection = odoorpc.ODOO(url, port=port, protocol=_protocol)
return connection
def api(self):
if self._api is None:
pwd_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
pwd_mgr.add_password(None, 'https://' + self._location.hostname,
self._location.login, self._location.password)
auth_handler = urllib2.HTTPBasicAuthHandler(pwd_mgr)
opener = urllib2.build_opener(auth_handler)
api = odoorpc.ODOO(host=self._location.hostname,
port=self._location.port,
protocol=self._location.protocol,
opener=opener)
try:
api.login(db=self._location.database,
login=self._location.login,
password=self._location.password)
except odoorpc.error.RPCError as e:
_logger.exception(e)
raise UserError(e)
self._api = api
_logger.debug("Associated lang %s to location" %
self._location.lang_id)
if self._location.lang_id:
self._api.env.context['lang'] = self._location.lang_id
_logger.info(
'Created a new Odoo API instance and logged In with context %s'
% self._api.env.context)
return self._api
def _backup(self):
""" Performs the conversion from doc to docx
"""
new_path = os.path.join(self._file_path, self._file_name)
try:
# print 'server_host ' + self._server_host
# print 'server_port ' + self._server_port
# print 'db_name ' + self._db_name
# print 'admin_pwd ' + self._admin_pwd
# print 'file_path ' + self._file_path
# print 'new_path ' + new_path
odoo = odoorpc.ODOO(self._server_host, port=self._server_port)
timeout_backup = odoo.config['timeout']
odoo.config['timeout'] = 600
dump = odoo.db.dump(self._admin_pwd, self._db_name)
odoo.config['timeout'] = timeout_backup
with open(new_path, 'wb') as dump_zip:
dump_zip.write(dump.read())
except Exception as ex:
print ex
else:
print u'New file %s has been written.' % new_path
def test_logout(self):
odoo = odoorpc.ODOO(
self.env['host'], protocol=self.env['protocol'],
port=self.env['port'], version=self.env['version'])
odoo.login(self.env['db'], self.env['user'], self.env['pwd'])
success = odoo.logout()
self.assertTrue(success)
def odoo_connect(self):
"""
Prepare the connection to the server
:return:
"""
if self.odoo_address.startswith('https'):
ssl = True
self.odoo_address = self.odoo_address.replace('https:', '')
protocol = 'jsonrpc+ssl'
if self.odoo_port <= 0:
self.odoo_port = 443
elif self.odoo_address.startswith('http:'):
self.odoo_address = self.odoo_address.replace('http:', '')
while self.odoo_address and self.odoo_address.startswith('/'):
self.odoo_address = self.odoo_address[1:]
while self.odoo_address and self.odoo_address.endswith('/'):
self.odoo_address = self.odoo_address[:-1]
while self.odoo_address and self.odoo_address.endswith('\\'):
self.odoo_address = self.odoo_address[:-1]
odoo_con = odoorpc.ODOO(self.odoo_address, port=self.odoo_port, protocol=self.protocol)
odoo_con.login(self.db, self.user, self.pw)
odoo_con.config['auto_commit'] = True # No need for manual commits
odoo_con.env.context['active_test'] = False # Show inactive articles
return odoo_con
def setUp(self):
try:
port = int(os.environ.get('ORPC_TEST_PORT', 8069))
except (ValueError, TypeError):
raise ValueError("The port must be an integer")
self.env = {
'protocol': os.environ.get('ORPC_TEST_PROTOCOL', 'jsonrpc'),
'host': os.environ.get('ORPC_TEST_HOST', 'localhost'),
'port': port,
'db': os.environ.get('ORPC_TEST_DB', 'odoorpc_test'),
'user': os.environ.get('ORPC_TEST_USER', 'admin'),
'pwd': os.environ.get('ORPC_TEST_PWD', 'admin'),
'version': os.environ.get('ORPC_TEST_VERSION', None),
'super_pwd': os.environ.get('ORPC_TEST_SUPER_PWD', 'admin'),
}
self.odoo = odoorpc.ODOO(
self.env['host'],
protocol=self.env['protocol'],
port=self.env['port'],
version=self.env['version'],
)
# Create the database
default_timeout = self.odoo.config['timeout']
self.odoo.config['timeout'] = 600
if self.env['db'] not in self.odoo.db.list():
self.odoo.db.create(self.env['super_pwd'], self.env['db'], True)
self.odoo.config['timeout'] = default_timeout
def __init__(self, config):
odoo_conf = config.get('odoorpc', {})
self._odoorpc = odoorpc.ODOO(
odoo_conf.get('hostname'),
protocol=odoo_conf.get('protocol'),
port=int(odoo_conf.get('port')),
version=odoo_conf.get('version'))
self._odoorpc.login(
odoo_conf.get('database'),
odoo_conf.get('user'),
odoo_conf.get('password'))
# TODO(adriant): Rename tenant to project once renamed in odoo:
self._Project = self._odoorpc.env['cloud.tenant']
self._Partner = self._odoorpc.env['res.partner']
self._Credit = self._odoorpc.env['cloud.credit']
self._PartnerRelationship = self._odoorpc.env['cloud.tenant_partner']
self._Country = self._odoorpc.env['res.country']
self._MailMessage = self._odoorpc.env['mail.message']
# Now setup the managers:
self.projects = CloudProjectManager(self)
self.credits = CloudCreditManager(self)
self.partners = PartnerManager(self)
self.project_relationships = ProjectRelationshipManager(self)
self.countries = CountryManager(self)
def connect_odoo_loop(self):
while True:
try:
host = self.settings.get('OdooHost')
port = self.settings.get('OdooPort')
logging.info('Connecting to Odoo at {}:{}'.format(host, port))
odoo = odoorpc.ODOO(host, port=port)
odoo.login(
self.settings.get('OdooDb'),
self.settings.get('OdooUser'),
self.settings.get('OdooPassword'),
)
logging.info('Connected to Odoo.')
self.odoo = odoo
self.odoo_disconnected.clear()
self.odoo_connected.set()
self.odoo_disconnected.wait() # Wait forever for disconnect
except Exception as e:
if 'Connection refused' in repr(e):
logging.error('Odoo refusing connection.')
else:
logging.exception(e)
gevent.sleep(self.settings.get('OdooReconnectTimeout'))
def conn(self):
rpc_conn = odoorpc.ODOO(self.credentials_id.url,
port=self.credentials_id.port,
protocol=self.credentials_id.protocol)
rpc_conn.login(self.credentials_id.database, self.credentials_id.user,
self.credentials_id.password)
return rpc_conn
def main(args):
if args.log_level:
log_level = args.log_level.lower()
log_map = {
"debug": logging.DEBUG,
"info": logging.INFO,
"warn": logging.WARN,
"error": logging.ERROR,
}
if log_level in log_map:
logger.setLevel(log_map[log_level])
else:
logger.error(
"Wrong value for log level (%s). Possible values: "
"debug, info, warn, error.",
log_level,
)
sys.exit(1)
pwd = args.password
first_login = True
while not pwd:
# prompt for password
pwd = getpass.getpass()
if first_login:
logger.error(
"Cannot connect with an empty password. Re-enter a password.")
first_login = False
if not args:
logger.error("Missing directory argument. You should pass to the "
"script at least one directory as argument.")
sys.exit(1)
proto = args.no_ssl and "jsonrpc" or "jsonrpc+ssl"
logger.info(
"Connecting to Odoo %s:%s in %s database %s username %s",
args.server,
args.port,
proto,
args.database,
args.username,
)
try:
odoo = odoorpc.ODOO(args.server, proto, args.port)
odoo.login(args.database, args.username, pwd)
logger.info("Successfully connected to Odoo")
except Exception as e:
logger.error("Failed to connect to Odoo. Error: %s", e)
sys.exit(1)
for directory in args.dir_list:
browse_directory(odoo, directory)
logger.info(
"RESULT: %d invoice%s created in Odoo, %d invoice import failure%s.",
len(invoice_ids),
len(invoice_ids) > 1 and "s" or "",
len(fail_files),
len(fail_files) > 1 and "s" or "",
)
logger.debug("IDs of created invoices: %s", invoice_ids)
logger.debug("Fail invoice imports: %s", fail_files)
def api(self):
if self._api is None:
api = odoorpc.ODOO(
host=self._location.location,
port=self._location.port,
)
self._api = api
return self._api
def get_environment(self, binding_model_name, api=None):
self.ensure_one()
if not api:
api = odoorpc.ODOO(self.hostname, 'jsonrpc', self.port)
api.login(self.database, self.username, self.password)
_logger.info('Created a new Odoo API instance')
env = APIConnectorEnvironment(self, binding_model_name, api=api)
return env
def test_login_no_password(self):
# login no password => Error
odoo = odoorpc.ODOO(
self.env['host'], protocol=self.env['protocol'],
port=self.env['port'], version=self.env['version'])
self.assertRaises(
odoorpc.error.Error,
odoo.login, self.env['db'], self.env['user'], False)
def verify_password(self):
server = config.get('odoo_server')
database = config.get('odoo_db')
self.odoo = odoorpc.ODOO(server, port=8069)
self.odoo.login(database, self.username, self.password)
if self.odoo:
return True
return False
def _authenticate(self):
try:
rpc = odoorpc.ODOO(self._host, port=self._port)
except:
raise Exception("odoo server not available!")
if not self._db_name:
self._db_name = rpc.db.list()[0]
rpc.login(self._db_name, self._username, self._password)
return rpc
def do_connect(self):
try:
self.odoo = odoorpc.ODOO(self.host,
port=self.port,
timeout=self.timeout)
except Exception as e:
_logger.error("Bruteforce::do_connect")
_logger.exception(e)
sys.exit(1)
def test_logout_without_login(self):
odoo = odoorpc.ODOO(
self.env['host'],
protocol=self.env['protocol'],
port=self.env['port'],
version=self.env['version'],
)
success = odoo.logout()
self.assertFalse(success)
def test_login(self):
odoo = odoorpc.ODOO(
self.env['host'], protocol=self.env['protocol'],
port=self.env['port'], version=self.env['version'])
odoo.login(self.env['db'], self.env['user'], self.env['pwd'])
self.assertIsNotNone(odoo.env)
self.assertIsInstance(odoo.env.user, Model)
self.assertIn('res.users', odoo.env.registry)
self.assertEqual(odoo.env.db, self.env['db'])
def test_init1(self):
# Host + Protocol + Port
odoo = odoorpc.ODOO(self.env['host'], self.env['protocol'],
self.env['port'])
self.assertIsInstance(odoo, odoorpc.ODOO)
self.assertIsNotNone(odoo)
self.assertEqual(odoo.host, self.env['host'])
self.assertEqual(odoo.protocol, self.env['protocol'])
self.assertEqual(odoo.port, self.env['port'])
def test_insert_client(self):
inserting_client.insert_client()
odoo = odoorpc.ODOO('chocotech.trustcode.com.br', port=80)
db_list = odoo.db.list()
odoo.login(db_list[5], 'demo', 'demo')
partner = odoo.env['res.partner']
assert partner.browse(1).name == 'Jose Pedro de Santana Neto', "Problem with name"
assert partner.browse(1).email == '*****@*****.**', "Problem with email"
assert partner.browse(1).phone == '61985909581', "Problem with phone"
def check_odoo_alive():
odoo_host = os.getenv("HOST")
odoo_port = os.getenv("PORT")
try:
return odoorpc.ODOO(odoo_host, port=int(odoo_port))
except Exception as e:
print('ERROR Checking alive:', e)
return ['Bad Gateway - 502', 502]
def setUp(self):
self.fake = Factory.create('pt_BR')
# Prepare the connection to the server
self.odoo = odoorpc.ODOO('chocotech.trustcode.com.br', port=80)
# Check available databases
print(self.odoo.db.list())
self.odoo.login('chocotech', 'demo', 'demo')
def mark_as_read(self):
url = self.env.user.company_id.url_trustcode
for item in self:
if item.interacao_trustcode:
item.write({'state': 'read'})
odoo = odoorpc.ODOO(url, port=80)
odoo.json('/helpdesk/interaction/update', {
'trustcode_id': item.trustcode_id,
'user': self.env.user.name
})
def __init__(self):
self.opts = opts
odoo = odoorpc.ODOO(opts.host, port=opts.port)
odoo.login(opts.dbname, opts.rpcuser, opts.rpcpw)
self.odoo = odoo
self.required_opts = {
"--parent-page": self.opts.parent_page,
"--input-dir": self.opts.inputdir or self.opts.outputdir,
}
def send_to_trustcode(self, vals, interaction):
url = self.env.user.company_id.url_trustcode
cnpj = self.env.user.company_id.cnpj_cpf
odoo = odoorpc.ODOO(url, port=80)
vals['help_trustcode_id'] = interaction.crm_help_id.trustcode_id
vals['cnpj'] = cnpj
vals['responsible'] = interaction.responsible_id.name
r = odoo.json('/helpdesk/interaction/new', vals)
interaction.trustcode_id = r['result']['trustcode_id']
interaction.responsible = vals['responsible']
