Newer
Older
#!/usr/bin/env python3
"""Imports CSV files into an Odoo server.
Dependencies as indicated in setup.py:
- odoorpc==0.7.0
- requests_toolbelt==0.8.0
"""
# Version 2.22
import argparse
import hashlib
import hmac
import logging
import os
import sys
from datetime import datetime
from typing import List, Tuple
import odoorpc
from requests_toolbelt import MultipartEncoder
_logger = logging.getLogger(__name__)
__version__ = '1.0.3'
__date__ = '2019-07-29'
__updated__ = '2019-09-09'
def import_csv(
login: str, password: str,
database: str,
protocol: str, host: str, port: int,
timeout: int,
model_filenames: List[Tuple[str, str, str]],
update_parameter: bool = True,
) -> int:
o, session_id = odoo_login(
database, host, login, password, port, protocol, timeout)
import_obj = o.env["base_import.import"]
param_obj = o.env["ir.config_parameter"]
_logger.info("Getting a CSRF token")
# Reproduce what odoo.http::csrf_token does to build a CSRF token.
max_ts = ''
db_secret = param_obj.get_param('database.secret')
csrf_token = (
'%so%s' % (
hmac.new(
db_secret.encode(),
msg=('%s%s' % (session_id, max_ts)).encode(),
digestmod=hashlib.sha1,
).hexdigest(),
max_ts
)
)
_logger.debug(f"CSRF token: {csrf_token}")
_logger.info("Importing CSV files")
import_options = {
"encoding": "utf-8",
"quoting": '"',
"separator": ",",
"headers": True,
}
_logger.info(f"{len(model_filenames)} files to import")
for model, csv_file, lang in model_filenames:
_logger.info(
'Importing - %s in model %s (lang %s)', csv_file, model, lang)
context = {
'lang': lang,
# TODO add tz maybe
}
import_dlg_id = import_obj.create(
{'res_model': model},
context=context,
)
with open(csv_file, 'rb') as f:
m = MultipartEncoder(
fields={
'csrf_token': csrf_token,
'import_id': str(import_dlg_id),
'file': ('filename', f, 'text/csv'),
}
)
data = m.to_string()
response = o.http(
'base_import/set_file',
data=data,
headers={'Content-Type': m.content_type}
)
# in Odoo, context contains user lang, but that is ok so far
_logger.debug('response: %s', response)
# This returns a lot of stuff we don't need, except for the field list.
fields = import_obj.parse_preview(
import_dlg_id, import_options,
)["headers"]
# Got fields; now run the import.
# this is where setting the context is necessary
results = import_obj.do(
import_dlg_id, fields, import_options, context=context
)
for result in results:
if result['type'] == 'error':
errors.append(result['message'])
if errors:
_logger.fatal(
'Error while importing - %s in model %s:', csv_file, model)
for error in errors:
_logger.warning(' - %s', error)
return 1
else:
_logger.info('Imported - %s in model %s', csv_file, model)
if update_parameter:
_logger.debug("Setting import_csv parameter")
param_obj.set_param('import_csv.write_date', str(datetime.now()))
_logger.info("Done.")
return 0
def odoo_login(database, host, login, password, port, protocol, timeout):
_logger.info(
f"Connecting to Odoo on <{protocol}://{host}:{port}> ({database} DB)"
)
o = odoorpc.ODOO(host, port=port, protocol=protocol, timeout=timeout)
_logger.info("Connected")
# Do "o.login(ODOO_DB, 'admin', ODOO_ADMIN_PASS)" by hand here so we can
# grab the session ID (odoorpc does not store it anywhere).
data = o.json(
"/web/session/authenticate",
{"db": database, "login": login, "password": password},
)
session_id = data["result"]["session_id"]
uid = data["result"]["uid"]
if uid:
context = data["result"]["user_context"]
o._env = odoorpc.env.Environment(o, database, uid, context=context)
o._login = login
o._password = password
else:
raise odoorpc.error.RPCError("Wrong login ID or password")
return o, session_id
def main(argv=None): # IGNORE:C0111
"""Parse arguments and launch conversion
"""
program_version = __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (
program_version, program_build_date)
program_shortdesc = __doc__.split(".")[0]
program_license = '''%s
Created by Vincent Hatakeyama on %s.
Copyright 2019 XCG Consulting. All rights reserved.
Licensed under the MIT License
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
# Argument parsing
parser = odoo_connect_parser(program_license, program_version_message)
# TODO indicate that either a file or a directory is required
parser.add_argument(
'-f',
'--file',
help="CSV to import",
action='append',
)
parser.add_argument(
'--directory',
help="Directory of CSV files to import",
action='append',
)
nmspc = parser.parse_args(argv)
logging_from_verbose(nmspc)
model_filenames = list()
# files need to be named according to the following regexp
pattern = re.compile(
r'(?P<path>.*/)'
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
r'(?P<model>[\w.]+?)'
r'(?:@(?P<lang>\w{2,3}(?:@latin|_\w{2})))?'
r'(?:.csv)?'
)
file_list = list()
if nmspc.file:
file_list.extend(nmspc.file)
if nmspc.directory:
for directory in nmspc.directory:
for root, subdirs, files in os.walk(directory):
file_list.extend(os.path.join(root, f) for f in sorted(files))
for filename in file_list:
_logger.debug(f"{filename} to import")
result = pattern.fullmatch(filename)
if result:
model = result.group('model')
lang = result.group('lang')
model_filenames.append((model, filename, lang))
else:
_logger.warning('Unrecognized file name "%s", ignored', filename)
return import_csv(
login=nmspc.login,
password=nmspc.password,
port=nmspc.port,
host=nmspc.host,
protocol=nmspc.protocol,
timeout=nmspc.timeout,
database=nmspc.database,
model_filenames=model_filenames,
)
def logging_from_verbose(namespace: argparse.Namespace):
verbose = namespace.verbose
if not verbose:
level = logging.WARN
elif verbose == 1:
level = logging.INFO
else:
level = logging.DEBUG
logging.basicConfig(
level=level,
format='%(asctime)s %(levelname)8s [%(lineno)3d]: %(message)s',
)
def odoo_connect_parser(description, version) -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description=description,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'-V', '--version', action='version',
version=version)
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
parser.add_argument(
'-v', '--verbose', dest='verbose', action='count',
help="set verbosity level [default: %(default)s]")
parser.add_argument(
'--login',
help="Odoo user [default: %(default)s]",
default='admin',
)
parser.add_argument(
'--password',
help="Odoo user password",
required=True,
)
parser.add_argument(
'-p',
'--port',
help="Odoo port [default: %(default)s]",
default=8069,
)
parser.add_argument(
'--host',
help="Odoo host [default: %(default)s]",
default='localhost',
)
parser.add_argument(
'--protocol',
help="Odoo protocol [default: %(default)s]",
default='jsonrpc',
# TODO point to odoorpc values
choices=['jsonrpc', 'jsonrpc+ssl'],
)
parser.add_argument(
'--timeout',
help="Odoo timeout [default: %(default)s]",
default=36000,
)
parser.add_argument(
'-d',
'--database',
help="Odoo database",
required=True,
)
return parser
if __name__ == "__main__":
return_code = main(sys.argv[1:])
if return_code:
exit(return_code)