def import_zipfile(self, module_file, force=False):
if not module_file:
raise Exception(_("No file sent."))
if not zipfile.is_zipfile(module_file):
raise UserError(_('File is not a zip file!'))
success = []
errors = dict()
module_names = []
with zipfile.ZipFile(module_file, "r") as z:
for zf in z.filelist:
if zf.file_size > MAX_FILE_SIZE:
raise UserError(_("File '%s' exceed maximum allowed file size") % zf.filename)
with tempdir() as module_dir:
z.extractall(module_dir)
dirs = [d for d in os.listdir(module_dir) if os.path.isdir(opj(module_dir, d))]
for mod_name in dirs:
module_names.append(mod_name)
try:
# assert mod_name.startswith('theme_')
path = opj(module_dir, mod_name)
self.import_module(mod_name, path, force=force)
success.append(mod_name)
except Exception, e:
_logger.exception('Error while importing module')
errors[mod_name] = exception_to_unicode(e)
def dump_db(db_name, stream, backup_format="zip"):
if backup_format == "zip":
res = dump_db.super(db_name, False, backup_format)
with osutil.tempdir() as dump_dir:
with zipfile.ZipFile(res, "r") as zip:
zip.extractall(dump_dir)
files = file.get_store_path(db_name)
if os.path.exists(files):
shutil.copytree(files, os.path.join(dump_dir, "files"))
if stream:
osutil.zip_dir(
dump_dir,
stream,
include_dir=False,
fnct_sort=lambda file_name: file_name != "dump.sql",
)
else:
t = tempfile.TemporaryFile()
osutil.zip_dir(
dump_dir,
t,
include_dir=False,
fnct_sort=lambda file_name: file_name != "dump.sql",
)
t.seek(0)
return t
else:
return dump_db.super(db_name, stream, backup_format)
def import_zipfile(self, module_file, force=False):
if not module_file:
raise Exception(_("No file sent."))
if not zipfile.is_zipfile(module_file):
raise UserError(_('File is not a zip file!'))
success = []
errors = dict()
module_names = []
with zipfile.ZipFile(module_file, "r") as z:
for zf in z.filelist:
if zf.file_size > MAX_FILE_SIZE:
raise UserError(
_("File '%s' exceed maximum allowed file size") %
zf.filename)
with tempdir() as module_dir:
z.extractall(module_dir)
dirs = [
d for d in os.listdir(module_dir)
if os.path.isdir(opj(module_dir, d))
]
for mod_name in dirs:
module_names.append(mod_name)
try:
# assert mod_name.startswith('theme_')
path = opj(module_dir, mod_name)
self.import_module(mod_name, path, force=force)
success.append(mod_name)
except Exception, e:
_logger.exception('Error while importing module')
errors[mod_name] = exception_to_unicode(e)
def restore_db(db, dump_file, copy=False):
res = restore_db.super(db, dump_file, copy)
with osutil.tempdir() as dump_dir:
if zipfile.is_zipfile(dump_file):
with zipfile.ZipFile(dump_file, "r") as zip:
files = [m for m in zip.namelist() if m.startswith("files/")]
if files:
z.extractall(dump_dir, files)
files_path = os.path.join(dump_dir, "files")
shutil.move(files_path, file.get_store_path(db_name))
return res
def create_zip_report(self, docids, data):
context = dict(self.env.context)
model = self._context.get("active_model", False)
with tempdir() as dump_dir:
for action in self._context.get('active_report_ids'):
#_logger.info("REPORT %s::%s::%s" % (action, action.report_id, action.sub_model))
report_id = action.report_id
sub_model = action.sub_model
if sub_model:
report = getattr(
self.with_context(dict(
context, active_model=model))._get_objs_for_report(
docids, data), sub_model)
data_report = report_id.with_context(
context,
active_model=report._name).report_action(report)
data_file_to_save, ext = report_id.render(
data_report['context'].get('active_ids'),
data=data_report['data'])
else:
report = self.with_context(
dict(context,
active_model=model))._get_objs_for_report(
docids, data)
data_report = report_id.with_context(
context, active_model=model).report_action(report)
data_file_to_save, ext = report_id.render(
data_report['context'].get('active_ids'),
data=data_report['data'] is not None or {})
#_logger.info("REPORTS %s::%s::%s" % (report, self._get_report_charset_from_name(report_id.print_report_name), data_file))
report_name = safe_eval(report_id.print_report_name, {
'objects': report,
'time': time,
'multi': True
})
if len(data_file_to_save) > 0:
if not isinstance(data_file_to_save, (bytes, bytearray)):
data_file_to_save = data_file_to_save.encode(
self._get_report_charset_from_name(
report_id.print_report_name))
with open(
os.path.join(dump_dir, report_name) + "." + ext,
'wb') as fh:
fh.write(data_file_to_save)
zip_file = tempfile.TemporaryFile()
zip_dir(dump_dir, zip_file, include_dir=False)
zip_file.seek(0)
return zip_file.read(), 'zip'
def import_master_bank_statement(self):
ResPartnerBank = self.env['res.partner.bank']
stage = self.env['helpdesk.stage'].search([('name', '=', 'Solved')],
limit=1)
for ticket in self:
attachments = self.env['ir.attachment'].search([
('res_id', '=', ticket.id),
('res_model', '=', 'helpdesk.ticket')
])
if not attachments:
continue
acc_number = ticket.name.split("[")[1][:-1]
bank_account_id = ResPartnerBank.search(
[('acc_number', 'in', (acc_number, '00000' + acc_number))],
limit=1).id
journal_id = self.env['account.journal'].search(
[('bank_account_id', '=', bank_account_id)], limit=1).id
for attachment in attachments:
fp = BytesIO()
fp.write(base64.b64decode(attachment.datas))
if not zipfile.is_zipfile(fp):
continue
if zipfile.is_zipfile(fp):
with zipfile.ZipFile(fp, "r") as z:
with tempdir() as module_dir:
import odoo.modules.module as module
try:
module.ad_paths.append(module_dir)
z.extractall(module_dir)
for d in os.listdir(module_dir):
extract_file = z.open(d)
new_rec = self.env[
'master.account.bank.statement.import'].with_context(
journal_id=journal_id).create({
'data_file':
base64.b64encode(
extract_file.read()),
'filename':
'test'
})
new_rec.with_context(
ticket=ticket).import_file()
ticket.write({'stage_id': stage.id})
except Exception as e:
ticket.message_post(body=str(e))
finally:
module.ad_paths.remove(module_dir)
def dump_db(db_name, stream, backup_format='zip'):
if backup_format == 'zip':
filestore_paths = []
connection = sql_db.db_connect(db_name)
with closing(connection.cursor()) as cr:
env = api.Environment(cr, SUPERUSER_ID, {})
settings = env['muk_dms.settings'].search([('save_type', '=',
'file')])
for setting in settings:
filestore_paths.append({
'complete_base_path': setting.complete_base_path,
'base_path': setting.base_path,
'db_name': db_name
})
res = dump_db.super(db_name, False, backup_format)
with osutil.tempdir() as dump_dir:
with zipfile.ZipFile(res, 'r') as zip:
zip.extractall(dump_dir)
with open(os.path.join(dump_dir, 'dms_system_files.json'),
'w') as fh:
dms_system_files = []
for path in filestore_paths:
filestore_id = uuid.uuid4().hex
dms_system_files.append({'id': filestore_id, 'data': path})
if os.path.exists(path['complete_base_path']):
shutil.copytree(
path['complete_base_path'],
os.path.join(dump_dir, 'dms_system_files',
filestore_id))
json.dump(dms_system_files, fh, indent=4)
if stream:
osutil.zip_dir(
dump_dir,
stream,
include_dir=False,
fnct_sort=lambda file_name: file_name != 'dump.sql')
else:
t = tempfile.TemporaryFile()
osutil.zip_dir(
dump_dir,
t,
include_dir=False,
fnct_sort=lambda file_name: file_name != 'dump.sql')
t.seek(0)
return t
else:
return dump_db.super(db_name, stream, backup_format)
def import_zipfile(self, module_file, force=False):
if not module_file:
raise Exception(_("No file sent."))
if not zipfile.is_zipfile(module_file):
raise UserError(_('Only zip files are supported.'))
success = []
errors = dict()
module_names = []
with zipfile.ZipFile(module_file, "r") as z:
for zf in z.filelist:
if zf.file_size > MAX_FILE_SIZE:
raise UserError(
_("File '%s' exceed maximum allowed file size") %
zf.filename)
with tempdir() as module_dir:
import odoo.modules.module as module
try:
module.ad_paths.append(module_dir)
z.extractall(module_dir)
dirs = [
d for d in os.listdir(module_dir)
if os.path.isdir(opj(module_dir, d))
]
for mod_name in dirs:
module_names.append(mod_name)
try:
# assert mod_name.startswith('theme_')
path = opj(module_dir, mod_name)
if self._import_module(mod_name, path,
force=force):
success.append(mod_name)
except Exception as e:
_logger.exception('Error while importing module')
errors[mod_name] = exception_to_unicode(e)
finally:
module.ad_paths.remove(module_dir)
r = ["Successfully imported module '%s'" % mod for mod in success]
for mod, error in errors.items():
r.append(
"Error while importing module '%s'.\n\n %s \n Make sure those modules are installed and try again."
% (mod, error))
return '\n'.join(r), module_names
def restore_db(db, dump_file, copy=False):
res = restore_db.super(db, dump_file, copy)
with osutil.tempdir() as dump_dir:
if zipfile.is_zipfile(dump_file):
with zipfile.ZipFile(dump_file, 'r') as zip:
dms_system_files = [
m for m in zip.namelist()
if m.startswith('dms_system_files/')
]
zip.extractall(dump_dir,
['dms_system_files.json'] + dms_system_files)
if dms_system_files:
system_file_path = os.path.join(dump_dir,
'dms_system_files')
with open(os.path.join(dump_dir,
'dms_system_files.json')) as file:
data = json.load(file)
for info in data:
shutil.move(
os.path.join(system_file_path, info['id']),
os.path.join(info['data']['base_path'], db))
return res
def cashfront_import_wizard(self):
if not self.fdata:
raise UserError(_("Select zip file to import"))
journal_file_list = []
sale_file_list = []
with tempdir() as dump_dir:
archive = zipfile.ZipFile(io.BytesIO(base64.b64decode(self.fdata)))
files = archive.namelist()
archive.extractall(dump_dir, files)
for file in files:
if '/Jornal/' in file:
if '.txt' in file:
journal_file_list.append(os.path.join(dump_dir, file))
if '/Sales/' in file:
if '.txt' in file:
sale_file_list.append(os.path.join(dump_dir, file))
fdata_sale = sorted(sale_file_list, key=lambda x: self.sort_by_date(x))
name_sale_path = fdata_sale[0].split('/')
path = '/'.join(name_sale_path[:len(name_sale_path) - 1])
fdata_journal = sorted([x for x in journal_file_list if path + '/' + x.split('/')[len(name_sale_path) - 1] in fdata_sale],
key=lambda x: self.sort_by_date(x))
for fdata_sale, fdata_journal in zip(fdata_sale, fdata_journal):
_logger.info('{} | {}'.format(fdata_sale, fdata_journal))
start_at = str(datetime.strptime(self.get_date(fdata_sale), '%d.%m.%Y'))
active_id = self.env.context.get('active_id')
posconfig = self.env['pos.config'].browse(active_id)
session = self.env['pos.session'].create({
'config_id': posconfig.id,
'start_at': start_at,
})
fdata_sale = open(fdata_sale, encoding='cp1251').readlines()
fdata_journal = open(fdata_journal, encoding='cp1251').readlines()
self.cashfront_import(fdata_sale, fdata_journal, session)
def import_zipfile(self, module_file, force=False):
if not module_file:
raise Exception(_("No file sent."))
if not zipfile.is_zipfile(module_file):
raise UserError(_('File is not a zip file!'))
success = []
errors = dict()
module_names = []
with zipfile.ZipFile(module_file, "r") as z:
for zf in z.filelist:
if zf.file_size > MAX_FILE_SIZE:
raise UserError(_("File '%s' exceed maximum allowed file size") % zf.filename)
with tempdir() as module_dir:
import odoo.modules as addons
try:
addons.module.ad_paths.append(module_dir)
z.extractall(module_dir)
dirs = [d for d in os.listdir(module_dir) if os.path.isdir(opj(module_dir, d))]
for mod_name in dirs:
module_names.append(mod_name)
try:
# assert mod_name.startswith('theme_')
path = opj(module_dir, mod_name)
self._import_module(mod_name, path, force=force)
success.append(mod_name)
except Exception as e:
_logger.exception('Error while importing module')
errors[mod_name] = exception_to_unicode(e)
finally:
addons.module.ad_paths.remove(module_dir)
r = ["Successfully imported module '%s'" % mod for mod in success]
for mod, error in pycompat.items(errors):
r.append("Error while importing module '%s': %r" % (mod, error))
return '\n'.join(r), module_names
def create_merged_report(self, docids, data):
context = dict(self.env.context)
model = self._context.get("active_model", False)
type = 'qweb-html'
ext = set([])
filenames = {}
with tempdir() as dump_dir:
for action in self._context.get('active_report_ids').sorted(
lambda r: r.sequence):
#_logger.info("REPORT %s::%s::%s::%s::%s::%s" % (action, self.with_context(dict(context, active_model=model))._get_objs_for_report(docids, data), docids, data, action.report_id and action.report_id.name or action.report_id, action.sub_model))
report_id = action.report_id
sub_model = action.sub_model
if sub_model:
report = getattr(
self.with_context(dict(
context, active_model=model))._get_objs_for_report(
docids, data), sub_model)
data_report = report_id.with_context(
context,
active_model=report._name).report_action(report)
data_file = report_id.render(
data_report['context'].get('active_ids'),
data=data_report['data'])
else:
report = self.with_context(
dict(context,
active_model=model))._get_objs_for_report(
docids, data)
data_report = action.with_context(
context, active_model=model).report_action(report)
data_file = report_id.render(
data_report['context'].get('active_ids'),
data=data_report['data'] is not None or {})
if len(data_file[0]) == 0:
return '', type
#_logger.info("REPORTS %s::%s::%s::%s" % (report, data_file, self._get_report_charset_from_name(report_id.print_report_name), data_report))
ext.update([data_file[1]])
report_name = safe_eval(report_id.print_report_name, {
'objects': report,
'time': time,
'multi': True
})
with open(
os.path.join(dump_dir, report_name) + "." +
data_file[1], 'wb') as fh:
filenames[action.sequence] = os.path.join(
dump_dir, report_name) + "." + data_file[1]
if data_file[1] in ('csv', 'txt'):
fh.write(data_file[0].encode(
self._get_report_charset_from_name(
report_id.print_report_name)))
else:
fh.write(data_file[0])
report_name_pdf = False
merged_file = tempfile.NamedTemporaryFile(delete=False)
filenames = dict(sorted(filenames.items(),
key=lambda kv: kv[0])).values()
#_logger.info("MERGED %s" % list(filenames))
if filenames and any([x for x in ext if x == "pdf"]):
# start for pdf merging
type = "qweb-pdf"
merger = PdfFileMerger()
for report_name in filenames:
if not report_name.lower().endswith(".pdf"):
old_file = report_name
report_name_pdf = tempfile.NamedTemporaryFile()
pdfkit.from_file(
old_file,
report_name_pdf.name,
options={
'encoding':
self._get_report_charset_from_name(
report_id.print_report_name)
})
merger.append(open(report_name, 'rb'))
with merged_file as outfile:
merger.write(outfile)
outfile.seek(0)
data = outfile.read()
elif filenames and len([x for x in ext if x in ('csv', 'txt')
]) == len(ext):
type = list(ext)[0]
with merged_file as outfile:
for filename in filenames:
if filename == merged_file.name:
# don't want to copy the output into the output
continue
with open(filename, 'rb') as report_name:
#_logger.info("FILES %s:%s" % (filename, filenames))
shutil.copyfileobj(report_name, outfile)
outfile.seek(0)
data = outfile.read()
os.unlink(merged_file.name)
if report_name_pdf and os.path.isfile(report_name_pdf.name):
os.unlink(report_name_pdf.name)
return data, type
