def create_order_form_view(self, **kw):
try:
packaging_list = request.env['famotain.product'].sudo().search(
[('product_type', '=', 'package'), ('active', '=', True),
('show_on_web', '=', True)],
order="price")
label = request.env['famotain.product'].sudo().search(
[('product_type', '=', 'label'), ('active', '=', True)],
limit=1)
data = {
'label': label,
'packaging_list': packaging_list,
'action': "/order/action/create"
}
return request.render('web_famotain.order_form_layout', data)
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def order_form_info_view(self, code=None, info=''):
try:
order = decrypt(code)
sales_order = request.env['sales__order.sales__order'].sudo(
).search([('name', '=', order)], limit=1)
if not sales_order:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
data = {'sales_order': sales_order, 'info': info}
return request.render('web_famotain.order_info_layout', data)
except Exception as e:
se = _serialize_exception(e)
if se['name'] == "cryptography.fernet.InvalidToken":
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
else:
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def wrap(*args, **kwargs):
try:
return f(*args, **kwargs)
except Exception, e:
se = _serialize_exception(e)
error = {'code': 200, 'message': "Odoo Server Error", 'data': se}
return werkzeug.exceptions.InternalServerError(json.dumps(error))
def report_print(self, data, context=None):
print_data = self._check_direct_print(data)
if not print_data['can_print']:
return json.dumps({
'title':
_('Printing not allowed!'),
'message':
_('Please check your DirectPrint settings or close and open app again'
),
'success':
False,
'notify':
True,
})
rp = print_data['report_policy']
printer_bin = print_data['printer_bin']
printer_id = print_data['printer_id']
# Finally if we reached this place - we can send report to printer.
standard_response = self.report_download(data, 'fake-token', context)
# If we do not have Content-Disposition headed, than no file-name
# was generated (maybe error)
content_disposition = standard_response.headers.get(
'Content-Disposition')
if not content_disposition:
return standard_response
report_name = content_disposition.split(
"attachment; filename*=UTF-8''")[1]
report_name = url_unquote(report_name)
ascii_data = base64.b64encode(standard_response.data).decode('ascii')
try:
params = {
'title': report_name,
'type': print_data['report_type'],
'size': rp and rp.report_paper_id,
'options': {
'bin': printer_bin.name
} if printer_bin else {},
}
printer_id.printnode_print_b64(ascii_data, params)
except Exception as e:
_logger.exception(e)
se = _serialize_exception(e)
error = {'code': 200, 'message': "Odoo Server Error", 'data': se}
return request.make_response(html_escape(json.dumps(error)))
title = _('Report was sent to printer')
message = _('Document "%s" was sent to printer %s') % (report_name,
printer_id.name)
return json.dumps({
'title': title,
'message': message,
'success': True,
'notify': request.env.company.im_a_teapot
})
def api_download_report(self, data, code_order, token):
try:
order = request.env['sgu.order'].sudo().search([
('name', '=', code_order),
('token', '=', token)
])
if len(order) == 1:
requestcontent = json.loads(data)
url, type = requestcontent[0], requestcontent[1]
try:
if type in ['qweb-pdf', 'qweb-text']:
converter = 'pdf' if type == 'qweb-pdf' else 'text'
extension = 'pdf' if type == 'qweb-pdf' else 'txt'
pattern = '/report/pdf/' if type == 'qweb-pdf' else '/report/text/'
reportname = url.split(pattern)[1].split('?')[0]
docids = None
if '/' in reportname:
reportname, docids = reportname.split('/')
if docids:
# Generic report:
response = self.report_routes(reportname, docids=docids, converter=converter)
else:
# Particular report:
data = url_decode(url.split('?')[1]).items() # decoding the args represented in JSON
response = self.report_routes(reportname, converter=converter, **dict(data))
report = request.env['ir.actions.report'].sudo()._get_report_from_name(reportname)
filename = "%s.%s" % (report.name, extension)
if docids:
ids = [int(x) for x in docids.split(",")]
obj = request.env[report.model].sudo().browse(ids)
if report.print_report_name and not len(obj) > 1:
report_name = safe_eval(report.print_report_name, {'object': obj})
filename = "%s.%s" % (report_name, extension)
response.headers.add('Content-Disposition', content_disposition(filename))
return response
else:
return
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'message': "Odoo Server Error",
'data': se
}
return request.make_response(html_escape(json.dumps(error)))
except Exception as ex:
return http.Response(
json.dumps({
"status": 'error',
"message": ex
}),
status=400,
mimetype='application/json'
)
def wrap(*args, **kwargs):
try:
return f(*args, **kwargs)
except Exception, e:
_logger.exception("An exception occured during an http request")
se = _serialize_exception(e)
error = {'code': 200, 'message': "Odoo Server Error", 'data': se}
return werkzeug.exceptions.InternalServerError(json.dumps(error))
def report_download(self, data, token, context=None):
requestcontent = json.loads(data)
url, type = requestcontent[0], requestcontent[1]
try:
if type == 'qweb-docx_to_x':
converter = 'docx_to_x'
default_output_file = 'docx'
pattern = '/report/docx_to_x/'
reportname = url.split(pattern)[1].split('?')[0]
docids = None
if '/' in reportname:
reportname, docids = reportname.split('/')
if docids:
# Generic report:
response = self.report_routes(reportname,
docids=docids,
converter=converter,
context=context)
else:
# Particular report:
data = url_decode(
url.split('?')
[1]).items() # decoding the args represented in JSON
response = self.report_routes(reportname,
converter=converter,
context=context,
**dict(data))
report = request.env[
'ir.actions.report']._get_report_from_name(reportname)
extension = report.output_file or default_output_file
filename = "%s.%s" % (report.name, extension)
if docids:
ids = [int(x) for x in docids.split(",")]
obj = request.env[report.model].browse(ids)
if report.print_report_name and not len(obj) > 1:
report_name = safe_eval(report.print_report_name, {
'object': obj,
'time': time
})
filename = "%s.%s" % (report_name, extension)
response.headers.add('Content-Disposition',
content_disposition(filename))
response.set_cookie('fileToken', token)
return response
except Exception as e:
se = _serialize_exception(e)
error = {'code': 200, 'message': "Odoo Server Error", 'data': se}
return request.make_response(html_escape(json.dumps(error)))
return super(ReportControllerExtend,
self).report_download(data, token, context)
def edit_order_form_view(self, code=None):
try:
order = decrypt(code)
sales_order = request.env['sales__order.sales__order'].sudo(
).search([('name', '=', order)], limit=1)
if not sales_order:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
if sales_order.state != 'draft' and sales_order.state != 'confirm':
error = {
'name': "Your order can't be edited",
'message': 'Contact our admin to edit this order.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
packaging_list = request.env['famotain.product'].sudo().search([
('product_type', '=', 'package'), ('active', '=', True)
])
label = request.env['famotain.product'].sudo().search(
[('product_type', '=', 'label'), ('active', '=', True)],
limit=1)
data = {
'edit': True,
'label': label,
'sales_order': sales_order,
'packaging_list': packaging_list,
'action': '/order/action/edit/%s' % code
}
return request.render('web_famotain.order_form_layout', data)
except Exception as e:
se = _serialize_exception(e)
if se['name'] == "cryptography.fernet.InvalidToken":
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
else:
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def view_order_form(self, code=None):
try:
order = decrypt(code)
sales_order = request.env['sales__order.sales__order'].sudo(
).search([('name', '=', order)], limit=1)
if not sales_order:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
design = False
design_2 = False
design_3 = False
for product_order in sales_order.product_order_ids:
if product_order.design_image:
design = True
if product_order.design_image_2:
design_2 = True
if product_order.design_image_3:
design_3 = True
if design and design_2 and design_3:
break
data = {
'sales_order': sales_order,
'design': design,
'design_2': design_2,
'design_3': design_3,
}
return request.render('web_famotain.order_layout', data)
except Exception as e:
se = _serialize_exception(e)
if se['name'] == "cryptography.fernet.InvalidToken":
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
else:
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def report_download(self, data, token):
requestcontent = json.loads(data)
url, type = requestcontent[0], requestcontent[1]
if type not in ['aeroo', 'qweb-aeroo']:
return super(ReportController, self).report_download(data, token)
try:
reportname = url.split('/report/aeroo/')[1].split('?')[0]
reportname, docids = reportname.split('/')
return self.report_routes(reportname=reportname,
docids=docids,
converter=type)
except Exception as e:
se = _serialize_exception(e)
error = {'code': 200, 'message': 'Odoo Server Error', 'data': se}
return request.make_response(html_escape(json.dumps(error)))
def report_download(self, data, token):
"""This function is used by 'qwebactionmanager.js' in order to trigger the download of
a pdf/controller report.
:param data: a javascript array JSON.stringified containg report internal url ([0]) and
type [1]
:returns: Response with a filetoken cookie and an attachment header
"""
requestcontent = json.loads(data)
url, type = requestcontent[0], requestcontent[1]
try:
if type == 'qweb-pdf':
reportname = url.split('/report/pdf/')[1].split('?')[0]
docids = None
if '/' in reportname:
reportname, docids = reportname.split('/')
if docids:
# Generic report:
response = self.report_routes(reportname, docids=docids, converter='pdf')
else:
# Particular report:
data = url_decode(url.split('?')[1]).items() # decoding the args represented in JSON
response = self.report_routes(reportname, converter='pdf', **dict(data))
report = request.env['report']._get_report_from_name(reportname)
filename = "%s.%s" % (report.name, "pdf")
if docids:
ids = [int(x) for x in docids.split(",")]
obj = request.env[report.model].browse(ids)
if report.print_report_name and not len(obj) > 1:
report_name = safe_eval(report.print_report_name, {'object': obj, 'time': time})
filename = "%s.%s" % (report_name, "pdf")
response.headers.add('Content-Disposition', content_disposition(filename))
response.set_cookie('fileToken', token)
return response
else:
return
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'message': "Odoo Server Error",
'data': se
}
return request.make_response(html_escape(json.dumps(error)))
def links_view(self, **kw):
try:
catalog_link = request.env['famotain.settings'].sudo().search(
[('key_name', '=', 'catalog_link'), ('active', '=', True)],
limit=1)
data = {
'catalog_link': catalog_link,
}
return request.render('web_famotain.links_layout', data)
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def get_report_xlsx(self, model, options, output_format, token,
report_name, **kw):
uid = request.session.uid
report_obj = request.env[model].sudo(uid)
options = json.loads(options)
try:
if output_format == 'xlsx':
response = request.make_response(
None,
headers=[('Content-Type', 'application/vnd.ms-excel'),
('Content-Disposition',
content_disposition(report_name + '.xlsx'))])
report_obj.get_xlsx_report(options, response)
response.set_cookie('fileToken', token)
return response
except Exception as e:
se = _serialize_exception(e)
error = {'code': 200, 'message': 'Odoo Server Error', 'data': se}
return request.make_response(html_escape(json.dumps(error)))
def print_invoice(self, code=None):
try:
invoice = request.env['sales__order.invoice'].sudo().search(
[('name', '=', decrypt(code))], limit=1)
if not invoice:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
report = request.env['ir.actions.report'].sudo(
)._get_report_from_name('sales__order.report_sales__order_invoice')
pdf = report.render_qweb_pdf([invoice.id])[0]
filename = """{} - {}.pdf""".format(invoice.source_document,
invoice.name)
pdfhttpheaders = [('Content-Type', 'application/pdf'),
('Content-Length', len(pdf)),
('Content-Disposition',
content_disposition(filename))]
return request.make_response(pdf, headers=pdfhttpheaders)
except Exception as e:
se = _serialize_exception(e)
if se['name'] == "cryptography.fernet.InvalidToken":
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
else:
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def report_excel(self,
id=None,
model='ir.attachment',
output_format='xlsx',
report_name=None,
token=None,
report_id=None,
filename=None,
download=None,
**kw):
uid = request.session.uid
domain = [('id', '=', id), ('create_uid', '=', uid)]
context_id = request.env[model].sudo().search(domain, limit=1)
attach_fpath = ''
attach_fname = ''
if context_id:
attach_fname = context_id['datas_fname']
store_fname = context_id['store_fname']
attach_fpath = context_id._full_path(store_fname)
filename = attach_fname if not filename else filename
filename_attachment = 'attachment; filename=' + filename + ';'
filename_attachment = filename_attachment.encode('utf-8')
try:
with open(attach_fpath, "rb") as f:
content = f.read()
f.close()
if ".".join(filename.split('.')[1:]) in SUPPORTED_FORMATS:
response = request.make_response(
content,
headers=[('Content-Type', 'application/vnd.ms-excel'),
('Content-Disposition', filename_attachment),
('Content-Length', len(content))])
return response
except Exception as e:
se = _serialize_exception(e)
error = {'code': 200, 'message': 'Odoo Server Error', 'data': se}
return request.make_response(html_escape(json.dumps(error)))
else:
return request.not_found()
def report_download(self, data, token, context=None):
""" print reports on report_download
"""
user = request.env.user
if not user.has_group(SECURITY_GROUP) \
or not user.company_id.printnode_enabled or not user.printnode_enabled:
return super(ReportControllerProxy, self).report_download(data, token, context)
requestcontent = json.loads(data)
if requestcontent[1] not in PDF + RAW:
return super(ReportControllerProxy, self).report_download(data, token, context)
ext = requestcontent[1].split('-')[1]
report_name, object_ids = requestcontent[0].\
split('/report/{}/'.format(ext))[1].split('?')[0].split('/')
report_id = request.env['ir.actions.report']._get_report_from_name(report_name)
printer_id = user._get_report_printer(report_id.id)
if not printer_id:
return super(ReportControllerProxy, self).report_download(data, token, context)
try:
ids = [int(x) for x in object_ids.split(',')]
obj = request.env[report_id.model].browse(ids)
super(ReportControllerProxy, self).printnode_print(printer_id, report_id, obj)
except Exception as e:
return request.make_response(html_escape(json.dumps({
'code': 200,
'message': 'Odoo Server Error',
'data': _serialize_exception(e),
})))
index = user.company_id.im_a_teapot
raise PrintNodeSuccess(['', _('Sent to PrintNode')][index])
def confirm_order_form(self, code=None, **kw):
try:
order = decrypt(code)
sales_order = request.env['sales__order.sales__order'].sudo(
).search([('name', '=', order)], limit=1)
if not sales_order:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
# check if sales order editable (draft)
if sales_order.state != 'confirm':
error = {
'name': "Your order can't be confirmed",
'message': 'Contact our admin to confirm this order.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
sales_order.action_approve()
return werkzeug.utils.redirect('/order/form/confirmed/%s' %
sales_order.encryption)
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def edit_order_form(self, code=None, **kw):
try:
order = decrypt(code)
sales_order = request.env['sales__order.sales__order'].sudo(
).search([('name', '=', order)], limit=1)
if not sales_order:
error = {
'name':
"Your order can't be found",
'message':
'Please check the requested url or contact our admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
# check if sales order editable (draft)
if sales_order.state != 'draft' and sales_order.state != 'confirm':
error = {
'name': "Your order can't be edited",
'message': 'Contact our admin to edit this order.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
# edit customer
data_customer = request.env['sales__order.customer'].sudo(
).prepare_vals(name=kw.get('input-name'),
phone=kw.get('input-hp'),
email=kw.get('input-email'),
address=kw.get('input-address'),
city=kw.get('input-city'),
zip_code=kw.get('input-zipcode'),
contact_by=kw.get('input-orderby'))
customer = request.env['sales__order.customer'].sudo().browse(
sales_order.customer_id.id)
customer.sudo().write(data_customer)
if kw.get('input-packaging') in "-":
kw['input-packing'] = "-"
kw['input-packaging'] = ""
packaging_id = None
if kw['input-packaging']:
packaging = request.env['famotain.product'].sudo().search(
[('code', '=', kw['input-packaging']),
('product_type', '=', 'package')],
limit=1)
packaging_id = packaging.id
# edit sales order
data_order = request.env['sales__order.sales__order'].sudo(
).prepare_vals_list(
customer_id=customer.id,
qty_total=kw.get('input-qty'),
deadline=kw.get('input-deadline'),
event_date=kw.get('input-eventdate'),
product=kw.get('input-product'),
theme=kw.get('input-theme'),
packaging_id=packaging_id,
packing=kw.get('input-packing'),
label=kw.get('input-label'),
custom_name=kw.get('input-customname'),
additional_text=kw.get('input-additionalwriting'),
thanks_card_writing=kw.get('input-thankcardwriting'),
custom_request=kw.get('input-customrequest'),
notes=kw.get('input-note'),
add_ons=kw.get('input-addons'))
sales_order.write_from_web(data_order)
return werkzeug.utils.redirect('/order/form/edited/%s' %
sales_order.encryption)
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def create_order_form(self, **kw):
try:
if kw.get('input-packaging') in "-":
kw['input-packing'] = "-"
kw['input-packaging'] = ""
packaging_id = None
if kw['input-packaging']:
packaging = request.env['famotain.product'].sudo().search(
[('code', '=', kw['input-packaging']),
('product_type', '=', 'package')],
limit=1)
packaging_id = packaging.id
# search if order exist
# sales_order = request.env['sales__order.sales__order'].sudo().search(
# [('phone', '=', kw.get('input-hp')), ('address', '=', kw.get('input-address')),
# ('city', '=', kw.get('input-city')), ('qty_total', '=', kw.get('input-qty')),
# ('deadline', '=', kw.get('input-deadline')), ('event_date', '=', kw.get('input-eventdate')),
# ('product', '=', kw.get('input-product')), ('theme', '=', kw.get('input-theme')),
# ('packaging_id', '=', packaging_id), ('packing', '=', kw.get('input-packing')),
# ('label', '=', kw.get('input-label')), ('custom_name', '=', kw.get('input-customname')),
# ('additional_text', '=', kw.get('input-additionalwriting')),
# ('thanks_card_writing', '=', kw.get('input-thankcardwriting')),
# ('custom_request', '=', kw.get('input-customrequest')), ('customer_notes', '=', kw.get('input-note')),
# ('add_ons', '=', kw.get('input-addons'))], limit=1)
# if sales_order:
# return werkzeug.utils.redirect('/order/form/created/%s' % sales_order.encryption)
# create customer
data_customer = request.env['sales__order.customer'].sudo(
).prepare_vals(name=kw.get('input-name'),
phone=kw.get('input-hp'),
email=kw.get('input-email'),
address=kw.get('input-address'),
city=kw.get('input-city'),
zip_code=kw.get('input-zipcode'),
contact_by=kw.get('input-orderby'))
# search if customer is exist
customer = request.env['sales__order.customer'].sudo().search(
[
('phone', '=ilike', data_customer.get('phone')),
], limit=1)
if customer:
customer.sudo().write(data_customer)
else:
customer = request.env['sales__order.customer'].sudo().create(
data_customer)
# create sales order
data_order = request.env['sales__order.sales__order'].sudo(
).prepare_vals_list(
customer_id=customer.id,
qty_total=kw.get('input-qty'),
deadline=kw.get('input-deadline'),
event_date=kw.get('input-eventdate'),
product=kw.get('input-product'),
theme=kw.get('input-theme'),
packaging_id=packaging_id,
packing=kw.get('input-packing'),
label=kw.get('input-label'),
custom_name=kw.get('input-customname'),
additional_text=kw.get('input-additionalwriting'),
thanks_card_writing=kw.get('input-thankcardwriting'),
custom_request=kw.get('input-customrequest'),
notes=kw.get('input-note'),
add_ons=kw.get('input-addons'))
sales_order = request.env['sales__order.sales__order'].sudo(
).create(data_order)
return werkzeug.utils.redirect('/order/form/created/%s' %
sales_order.encryption)
except Exception as e:
se = _serialize_exception(e)
error = {
'code': 200,
'name': "Server Error",
'data': se,
'message': 'Contact admin for more info.'
}
_logger.error(json.dumps(error))
return request.render('web_famotain.error_layout', error)
def report_download(self, data, token):
"""This function is used by 'qwebactionmanager.js' in order to trigger the download of
a pdf/controller report.
:param data: a javascript array JSON.stringified containg report internal url ([0]) and
type [1]
:returns: Response with a filetoken cookie and an attachment header
"""
requestcontent = json.loads(data)
url, type = requestcontent[0], requestcontent[1]
try:
if type == "qweb-pdf":
reportname = url.split("/report/pdf/")[1].split("?")[0]
docids = None
active_model = ""
NewReportName = ""
if "/" in reportname:
reportname, docids = reportname.split("/")
if docids:
# Generic report:
response = self.report_routes(reportname,
docids=docids,
converter="pdf")
else:
# Particular report:
data = url_decode(
url.split("?")
[1]).items() # decoding the args represented in JSON
dictData = dict(data)
active_model = json.loads(
dictData.get("context")).get("active_model")
NewReportName = (json.loads(
dictData.get("options")).get("form").get("name"))
response = self.report_routes(reportname,
converter="pdf",
**dictData)
report = request.env[
"ir.actions.report"]._get_report_from_name(reportname)
filename = "%s.%s" % (report.name, "pdf")
if active_model == "payroll.register":
filename = "%s.%s" % (NewReportName, "pdf")
if docids:
ids = [int(x) for x in docids.split(",")]
obj = request.env[report.model].browse(ids)
if report.print_report_name and not len(obj) > 1:
report_name = safe_eval(
report.print_report_name,
{
"object": obj,
"time": time
},
)
filename = "%s.%s" % (report_name, "pdf")
if report.model == "payroll.register":
filename = "%s.%s" % (obj.name, "pdf")
response.headers.add("Content-Disposition",
content_disposition(filename))
response.set_cookie("fileToken", token)
return response
else:
return
except Exception as e:
se = _serialize_exception(e)
error = {"code": 200, "message": "Odoo Server Error", "data": se}
return request.make_response(html_escape(json.dumps(error)))
def http_serialize_exception(e):
tmp = _serialize_exception(e)
tmp['debug'] = tmp['name']
return tmp
