Esempio n. 1
0
    def test_03_web_content_filename(self):
        """This test makes sure the Content-Disposition header matches the given filename"""

        att = self.env['ir.attachment'].create({
            'datas': b'R0lGODdhAQABAIAAAP///////ywAAAAAAQABAAACAkQBADs=',
            'name': 'testFilename.gif',
            'public': True,
            'mimetype': 'image/gif'
        })

        # CASE: no filename given
        res = self.url_open('/web/image/%s/0x0/?download=true' % att.id)
        self.assertEqual(res.headers['Content-Disposition'],
                         content_disposition('testFilename.gif'))

        # CASE: given filename without extension
        res = self.url_open('/web/image/%s/0x0/custom?download=true' % att.id)
        self.assertEqual(res.headers['Content-Disposition'],
                         content_disposition('custom.gif'))

        # CASE: given filename and extention
        res = self.url_open('/web/image/%s/0x0/custom.png?download=true' %
                            att.id)
        self.assertEqual(res.headers['Content-Disposition'],
                         content_disposition('custom.png'))
Esempio n. 2
0
 def get_report(self,
                model,
                options,
                output_format,
                token,
                report_id=None,
                **kw):
     uid = request.session.uid
     report_obj = request.env[model].sudo(uid)
     options = json.loads(options)
     if report_id:
         report_obj = report_obj.browse(int(report_id))
     report_name = report_obj.get_report_filename(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(options, response)
         if output_format == 'pdf':
             response = request.make_response(
                 report_obj.get_pdf(options),
                 headers=[('Content-Type', 'application/pdf'),
                          ('Content-Disposition',
                           content_disposition(report_name + '.pdf'))])
         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)))
Esempio n. 3
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        if converter not in ['xlsx', 'txt', 'zip']:
            return super(ReportController, self).report_routes(
                reportname, docids, converter, **data
            )
        report = request.env['ir.actions.report']._get_report_from_name(reportname)
        context = dict(request.env.context)
        if docids:
            docids = [int(i) for i in docids.split(',')]
        if data.get('options'):
            data.update(json.loads(data.pop('options')))
        if data.get('context'):
            data['context'] = json.loads(data['context'])
            if data['context'].get('lang'):
                del data['context']['lang']
            context.update(data['context'])

        if converter == 'xlsx':
            body = report.with_context(context).render_xlsx(
                docids, data=data
            )[0]
            bodyhttpheaders = [
                ('Content-Type', 'application/vnd.openxmlformats-'
                                 'officedocument.spreadsheetml.sheet'),
                ('Content-Length', len(body)),
                (
                    'Content-Disposition',
                    content_disposition(report.report_file + '.xlsx')
                )
            ]
        elif converter == 'txt':
            report_name = report.render_txt_name(docids, data=data) or '%s.txt'%( report.report_file )
            body = report.with_context(context).render_txt(
                docids, data=data
            )[0]
            bodyhttpheaders = [
                ('Content-Type', 'text/plain'),
                ('Content-Length', len(body)),
                (
                    'Content-Disposition',
                    content_disposition( report_name )
                )
            ]
        elif converter == 'zip':
            body = report.with_context(context).render_zip(
                docids, data=data
            )[0]
            bodyhttpheaders = [
                ('Content-Type', 'application/octet-stream'),
                ('Content-Length', len(body)),
                (
                    'Content-Disposition',
                    content_disposition(report.report_file + '.zip')
                )
            ]
        return request.make_response(body, headers=bodyhttpheaders)

        """
Esempio n. 4
0
    def _generate_report(self, user_input, download=True):
        report = request.env.ref('survey.certification_report').sudo().render_qweb_pdf([user_input.id], data={'report_type': 'pdf'})[0]

        report_content_disposition = content_disposition('Certification.pdf')
        if not download:
            content_split = report_content_disposition.split(';')
            content_split[0] = 'inline'
            report_content_disposition = ';'.join(content_split)

        return request.make_response(report, headers=[
            ('Content-Type', 'application/pdf'),
            ('Content-Length', len(report)),
<<<<<<< HEAD
        ]
        reporthttpheaders.append(('Content-Disposition', content_disposition('Certification.pdf')))
        return request.make_response(report, headers=reporthttpheaders)

    def _prepare_result_dict(self, survey, current_filters=None):
        """Returns dictionary having values for rendering template"""
        current_filters = current_filters if current_filters else []
        result = {'page_ids': []}
        
        # First append questions without page
        questions_without_page = [self._prepare_question_values(question,current_filters) for question in survey.question_ids if not question.page_id]
        if questions_without_page:
            result['page_ids'].append({'page': request.env['survey.question'], 'question_ids': questions_without_page})

        # Then, questions in sections
        for page in survey.page_ids:
            page_dict = {'page': page, 'question_ids': [self._prepare_question_values(question,current_filters) for question in page.question_ids]}
            result['page_ids'].append(page_dict)

        if survey.scoring_type in ['scoring_with_answers', 'scoring_without_answers']:
            scoring_data = self._get_scoring_data(survey)
            result['success_rate'] = scoring_data['success_rate']
            result['scoring_graph_data'] = json.dumps(scoring_data['graph_data'])

        return result

    def _prepare_question_values(self, question, current_filters):
        Survey = request.env['survey.survey']
        return {
            'question': question,
            'input_summary': Survey.get_input_summary(question, current_filters),
            'prepare_result': Survey.prepare_result(question, current_filters),
            'graph_data': self._get_graph_data(question, current_filters),
        }

    def _get_filter_data(self, post):
        """Returns data used for filtering the result"""
        filters = []
        for ids in post:
            #if user add some random data in query URI, ignore it
=======
            ('Content-Disposition', report_content_disposition),
        ])
    def base(self, data, token):
        params = json.loads(data)
        header, chart_data = operator.itemgetter('header',
                                                 'chart_data')(params)

        chart_data = json.loads(chart_data)

        # Model = request.env[model].with_context(import_compat=import_compat, **params.get('context', {}))
        # records = Model.browse(ids) or Model.search(domain, offset=0, limit=False, order=False)
        #
        # if not Model._is_an_ordinary_table():
        #     fields = [field for field in fields if field['name'] != 'id']

        # field_names = [f['name'] for f in fields]
        # import_data = records.export_data(field_names, self.raw_data).get('datas',[])

        # if import_compat:
        #     columns_headers = field_names
        # else:
        #     columns_headers = [val['label'].strip() for val in fields]

        # columns_headers = [header]
        chart_data['labels'].insert(0, 'Measure')
        columns_headers = chart_data['labels']

        import_data = []
        for dataset in chart_data['datasets']:
            dataset['data'].insert(0, dataset['label'])
            import_data.append(dataset['data'])
        return request.make_response(
            self.from_data(columns_headers, import_data),
            headers=[('Content-Disposition',
                      content_disposition(self.filename(header))),
                     ('Content-Type', self.content_type)],
            cookies={'fileToken': token})
Esempio n. 6
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        if converter not in ['aeroo', 'qweb-aeroo']:
            return super(ReportController,
                         self).report_routes(reportname, docids, converter,
                                             **data)

        context = dict(request.env.context)

        report = request.env['ir.actions.report']._get_report_from_name(
            reportname)
        context.update({'preview': 'ABC'})

        if docids:
            docids = [int(i) for i in docids.split(',')]
        if data.get('options'):
            data.update(json.loads(data.pop('options')))
        if data.get('context'):
            data['context'] = json.loads(data['context'])
            if data['context'].get('lang'):
                del data['context']['lang']
            context.update(data['context'])

        file_data, out_code, filename = report.with_context(
            context).render_aeroo(docids, data=data)
        httpheaders = [('Content-Type',
                        self.MIMETYPES.get(out_code,
                                           'application/octet-stream')),
                       ('Content-Length', len(file_data)),
                       ('Content-Disposition', content_disposition(filename))]
        return request.make_response(file_data, headers=httpheaders)
Esempio n. 7
0
 def report_routes(self, reportname, docids=None, converter=None, **data):
     if converter == "xlsx":
         report = request.env["ir.actions.report"]._get_report_from_name(reportname)
         context = dict(request.env.context)
         if docids:
             docids = [int(i) for i in docids.split(",")]
         if data.get("options"):
             data.update(json.loads(data.pop("options")))
         if data.get("context"):
             data["context"] = json.loads(data["context"])
             if data["context"].get("lang"):
                 del data["context"]["lang"]
             context.update(data["context"])
         xlsx = report.with_context(context)._render_xlsx(docids, data=data)[0]
         report_name = report.report_file
         if report.print_report_name and not len(docids) > 1:
             obj = request.env[report.model].browse(docids[0])
             report_name = safe_eval(
                 report.print_report_name, {"object": obj}
             )
         xlsxhttpheaders = [
             (
                 "Content-Type",
                 "application/vnd.openxmlformats-"
                 "officedocument.spreadsheetml.sheet",
             ),
             ("Content-Length", len(xlsx)),
             ("Content-Disposition", content_disposition(report_name + ".xlsx")),
         ]
         return request.make_response(xlsx, headers=xlsxhttpheaders)
     return super(ReportController, self).report_routes(
         reportname, docids, converter, **data
     )
Esempio n. 8
0
 def _get_binary_content(self, invoice):
     """
     Generate the invoice report....
     :param invoice:
       :returns: (headers, content)
     """
     # ensure the report is generated
     invoice_report_def = invoice.invoice_print()
     report_name = invoice_report_def["report_name"]
     report_type = invoice_report_def["report_type"]
     report = self._get_report(report_name, report_type)
     content, extension = report.render(
         invoice.ids, data={"report_type": report_type}
     )
     filename = self._get_binary_content_filename(
         invoice, report, extension
     )
     mimetype = mimetypes.guess_type(filename)
     if mimetype:
         mimetype = mimetype[0]
     headers = [
         ("Content-Type", mimetype),
         ("X-Content-Type-Options", "nosniff"),
         ("Content-Disposition", content_disposition(filename)),
         ("Content-Length", len(content)),
     ]
     return headers, content
Esempio n. 9
0
    def _show_report(self, model, report_type, report_ref, download=False):
        """ Modificamos el metodo generico para intentar obtener report con "get_report" antes de usar el report_ref
        Ademas agregamos compatibilidad con aeroo (por ahora solo descarga archivo, deberia previsualizarlo)
        """
        if report_type not in ('html', 'pdf', 'text'):
            raise UserError("Invalid report type: %s" % report_type)

        # por ahora, comoo no podemos previsualizar reportes de aeroo, si se pide reporte html/text devolvemos reportes
        # nativos de odoo. Una vez implementado lo de abajo se puede usar siempre el get_report
        # report_sudo = model.sudo().get_report()
        report_sudo = report_type == 'pdf' and hasattr(
            model.sudo(), 'get_report') and model.sudo().get_report() or False

        # if we found a new report use it, if not use default report_ref
        report_ref = report_sudo and report_sudo.get_external_id()[
            report_sudo.id] or report_ref

        # now we fix aerro rendering
        report_sudo = request.env.ref(report_ref).sudo()
        if report_sudo.report_type != 'aeroo':
            return super()._show_report(model,
                                        report_type,
                                        report_ref,
                                        download=False)

        # TODO incorporarar que se pueda previsualizar el reporte sin descargar
        rset = report_sudo.render_aeroo([model.id], data={})
        mimetype = ReportController.MIMETYPES.get(rset[1],
                                                  'application/octet-stream')
        httpheaders = [('Content-Disposition', content_disposition(rset[2])),
                       ('Content-Type', mimetype),
                       ('Content-Length', len(rset[0]))]
        return request.make_response(rset[0], headers=httpheaders)
Esempio n. 10
0
    def portal_my_invoice_report(self, invoice_id, access_token=None, **kw):
        try:
            invoice_sudo = self._document_check_access('account.invoice',
                                                       invoice_id,
                                                       access_token)
        except (AccessError, MissingError):
            return request.redirect('/my')

        # print report as sudo, since it require access to taxes, payment term, ... and portal
        # does not have those access rights.
        accountInvoiceReport = request.env.ref(
            'account.account_invoices').sudo()
        report_type = kw.get('report_type', 'pdf')
        method_name = 'render_qweb_%s' % (report_type)
        if hasattr(accountInvoiceReport, method_name):
            invoice_report = getattr(accountInvoiceReport,
                                     method_name)([invoice_sudo.id],
                                                  data={
                                                      'report_type':
                                                      report_type
                                                  })[0]
            reporthttpheaders = [
                ('Content-Type',
                 'application/pdf' if report_type == 'pdf' else 'text/html'),
                ('Content-Length', len(invoice_report)),
            ]
            if report_type == 'pdf' and not kw.get('print'):
                filename = "%s.pdf" % (re.sub(
                    '\W+', '-', invoice_sudo._get_printed_report_name()))
                reporthttpheaders.append(('Content-Disposition',
                                          http.content_disposition(filename)))
            return request.make_response(invoice_report,
                                         headers=reporthttpheaders)
        raise NotFound()
Esempio n. 11
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        report = request.env['ir.actions.report']._get_report_from_name(
            reportname)
        if converter == 'xlsx' and not report:

            context = dict(request.env.context)
            if docids:
                docids = [int(i) for i in docids.split(',')]
            if data.get('options'):
                data.update(json.loads(data.pop('options')))
            if data.get('context'):
                # Ignore 'lang' here, because the context in data is the one
                # from the webclient *but* if the user explicitely wants to
                # change the lang, this mechanism overwrites it.
                data['context'] = json.loads(data['context'])
                if data['context'].get('lang'):
                    del data['context']['lang']
                context.update(data['context'])
            context['report_name'] = reportname

            xlsx = report.with_context(context).render_xlsx(docids,
                                                            data=data)[0]
            report_file = context.get('report_file')
            if not report_file:
                active_model = context.get('active_model', 'export')
                report_file = active_model.replace('.', '_')
            xlsxhttpheaders = [('Content-Type',
                                'application/vnd.openxmlformats-'
                                'officedocument.spreadsheetml.sheet'),
                               ('Content-Length', len(xlsx)),
                               ('Content-Disposition',
                                content_disposition(report_file + '.xlsx'))]
            return request.make_response(xlsx, headers=xlsxhttpheaders)
        return super(ReportController,
                     self).report_routes(reportname, docids, converter, **data)
Esempio n. 12
0
    def _make_zip(self, name, documents):
        """returns zip files for the Document Inspector and the portal.

        :param name: the name to give to the zip file.
        :param documents: files (documents.document) to be zipped.
        :return: a http response to download a zip file.
        """
        stream = io.BytesIO()
        try:
            with zipfile.ZipFile(stream, 'w') as doc_zip:
                for document in documents:
                    if document.type != 'binary':
                        continue
                    status, content, filename, mimetype, filehash = request.env[
                        'ir.http']._binary_record_content(
                            document,
                            field='datas',
                            filename=None,
                            filename_field='name',
                            default_mimetype='application/octet-stream')
                    doc_zip.writestr(filename,
                                     base64.b64decode(content),
                                     compress_type=zipfile.ZIP_DEFLATED)
        except zipfile.BadZipfile:
            logger.exception("BadZipfile exception")

        content = stream.getvalue()
        headers = [('Content-Type', 'zip'),
                   ('X-Content-Type-Options', 'nosniff'),
                   ('Content-Length', len(content)),
                   ('Content-Disposition', content_disposition(name))]
        return request.make_response(content, headers)
Esempio n. 13
0
    def download_report(self, data, token):

        result = json.loads(data)
        pdf = result[0]
        output_type = result[1]
        reportname = result[2]

        en = base64.b64encode(pdf.encode('latin1', 'replace'))
        res = base64.b64decode(en)

        pdfhttpheaders = [('Content-Length', len(res)),
                          ('Content-Type', 'application/download')]

        response = request.make_response(res,
                                         pdfhttpheaders,
                                         cookies={'fileToken': token})

        report = request.env['ir.actions.report']._get_report_from_name(
            reportname)
        print('name =', report.name)
        filename = "%s.%s" % (report.name, output_type)
        response.headers.add('Content-Disposition',
                             content_disposition(filename))

        return response
Esempio n. 14
0
 def report_routes(self, reportname, docids=None, converter=None, **data):
     if converter == 'xlsx':
         report = request.env['ir.actions.report']._get_report_from_name(
             reportname)
         context = dict(request.env.context)
         if docids:
             docids = [int(i) for i in docids.split(',')]
         if data.get('options'):
             data.update(json.loads(data.pop('options')))
         if data.get('context'):
             data['context'] = json.loads(data['context'])
             if data['context'].get('lang'):
                 del data['context']['lang']
             context.update(data['context'])
         xlsx = report.with_context(context).render_xlsx(
             docids, data=data
         )[0]
         xlsxhttpheaders = [
             ('Content-Type', 'application/vnd.openxmlformats-'
                              'officedocument.spreadsheetml.sheet'),
             ('Content-Length', len(xlsx)),
             (
                 'Content-Disposition',
                 content_disposition(report.report_file + '.xlsx')
             )
         ]
         return request.make_response(xlsx, headers=xlsxhttpheaders)
     return super(ReportController, self).report_routes(
         reportname, docids, converter, **data
     )
Esempio n. 15
0
    def _binary_set_headers(self,
                            status,
                            content,
                            filename,
                            mimetype,
                            unique,
                            filehash=None,
                            download=False):
        headers = [('Content-Type', mimetype),
                   ('X-Content-Type-Options', 'nosniff')]
        # cache
        etag = bool(request) and request.httprequest.headers.get(
            'If-None-Match')
        status = status or 200
        if filehash:
            headers.append(('ETag', filehash))
            if etag == filehash and status == 200:
                status = 304
        headers.append(
            ('Cache-Control',
             'max-age=%s' % (http.STATIC_CACHE_LONG if unique else 0)))
        # content-disposition default name
        if download:
            headers.append(
                ('Content-Disposition', content_disposition(filename)))

        return (status, headers, content)
Esempio n. 16
0
    def get_report_xlsx(self, model, output_format, report_name, **kw):

        uid = request.session.uid

        report_obj = request.env[model].sudo(uid)
        data = {
            'start_date': time.strftime('%Y-%m-01'),
            'end_date': datetime.datetime.now()
        }

        options = json.loads(json.dumps(data, default=date_utils.json_default))

        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)

            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)))
Esempio n. 17
0
    def OAS_json_spec_download(self, namespace_name, **kwargs):
        ensure_db()
        namespace = (http.request.env["openapi.namespace"].sudo().search([
            ("name", "=", namespace_name)
        ]))
        if not namespace:
            raise werkzeug.exceptions.NotFound()
        if namespace.token != kwargs.get("token"):
            raise werkzeug.exceptions.Forbidden()

        response_params = {"headers": [("Content-Type", "application/json")]}
        if "download" in kwargs:
            response_params = {
                "headers": [
                    ("Content-Type",
                     "application/octet-stream; charset=binary"),
                    ("Content-Disposition",
                     http.content_disposition("swagger.json")),
                ],
                "direct_passthrough":
                True,
            }

        return werkzeug.wrappers.Response(json.dumps(
            namespace.get_OAS(), default=date_utils.json_default),
                                          status=200,
                                          **response_params)
Esempio n. 18
0
 def report_routes(self, reportname, docids=None, converter=None, **data):
     if converter == 'fillpdf':
         report = request.env['ir.actions.report']._get_report_from_name(
             reportname)
         context = dict(request.env.context)
         if docids:
             docids = [int(i) for i in docids.split(',')]
         if data.get('options'):
             data.update(json.loads(data.pop('options')))
         if data.get('context'):
             # Ignore 'lang' here, because the context in data is the one
             # from the webclient *but* if the user explicitely wants to
             # change the lang, this mechanism overwrites it.
             data['context'] = json.loads(data['context'])
             if data['context'].get('lang'):
                 del data['context']['lang']
             context.update(data['context'])
         pdf = report.with_context(context).render_fillpdf(docids,
                                                           data=data)[0]
         pdfhttpheaders = [
             ('Content-Type', 'application/pdf'),
             ('Content-Length', len(pdf)),
             ('Content-Disposition',
              content_disposition(report.report_file + '.pdf'))
         ]
         return request.make_response(pdf, headers=pdfhttpheaders)
     return super(ReportController,
                  self).report_routes(reportname, docids, converter, **data)
Esempio n. 19
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        report = request.env["ir.actions.report"]._get_report_from_name(
            reportname)
        if converter == "xlsx" and not report:

            context = dict(request.env.context)
            if docids:
                docids = [int(i) for i in docids.split(",")]
            if data.get("options"):
                data.update(json.loads(data.pop("options")))
            if data.get("context"):
                data["context"] = json.loads(data["context"])
                context.update(data["context"])
            context["report_name"] = reportname

            xlsx = report.with_context(context)._render_xlsx(docids,
                                                             data=data)[0]
            report_file = context.get("report_file")
            if not report_file:
                active_model = context.get("active_model", "export")
                report_file = active_model.replace(".", "_")
            xlsxhttpheaders = [
                (
                    "Content-Type",
                    "application/vnd.openxmlformats-"
                    "officedocument.spreadsheetml.sheet",
                ),
                ("Content-Length", len(xlsx)),
                ("Content-Disposition",
                 content_disposition(report_file + ".xlsx")),
            ]
            return request.make_response(xlsx, headers=xlsxhttpheaders)
        return super().report_routes(reportname, docids, converter, **data)
Esempio n. 20
0
 def _get_binary_content(self, target, params=None):
     """
     Generate the report for the given target
     :param target:
     :param params: dict
     :returns: (headers, content)
     """
     # Ensure the report is generated
     target_report_def = self._get_report_action(target, params=params)
     report_name = target_report_def.get("report_name")
     report_type = target_report_def.get("report_type")
     report = self._get_report(report_name, report_type)
     content, extension = report.render(target.ids,
                                        data={"report_type": report_type})
     filename = self._get_binary_content_filename(target,
                                                  report,
                                                  extension,
                                                  params=params)
     mimetype = mimetypes.guess_type(filename)
     if mimetype:
         mimetype = mimetype[0]
     headers = [
         ("Content-Type", mimetype),
         ("X-Content-Type-Options", "nosniff"),
         ("Content-Disposition", content_disposition(filename)),
         ("Content-Length", len(content)),
     ]
     return headers, content
Esempio n. 21
0
 def report_routes(self, reportname, docids=None, converter=None, **data):
     if converter == 'xlsx':
         report = request.env['ir.actions.report']._get_report_from_name(
             reportname)
         context = dict(request.env.context)
         if docids:
             docids = [int(i) for i in docids.split(',')]
         if data.get('options'):
             data.update(json.loads(data.pop('options')))
         if data.get('context'):
             # Ignore 'lang' here, because the context in data is the one
             # from the webclient *but* if the user explicitely wants to
             # change the lang, this mechanism overwrites it.
             data['context'] = json.loads(data['context'])
             if data['context'].get('lang'):
                 del data['context']['lang']
             context.update(data['context'])
         xlsx = report.with_context(context).render_xlsx(docids,
                                                         data=data)[0]
         report_name = report.report_file
         if report.print_report_name and not len(docids) > 1:
             obj = request.env[report.model].browse(docids[0])
             report_name = safe_eval(report.print_report_name, {
                 'object': obj,
                 'time': time
             })
         xlsxhttpheaders = [('Content-Type',
                             'application/vnd.openxmlformats-'
                             'officedocument.spreadsheetml.sheet'),
                            ('Content-Length', len(xlsx)),
                            ('Content-Disposition',
                             content_disposition(report_name + '.xlsx'))]
         return request.make_response(xlsx, headers=xlsxhttpheaders)
     return super(ReportController,
                  self).report_routes(reportname, docids, converter, **data)
 def report_download(self, data, token):
     response = super(OpenedunavDownloadController,
                      self).report_download(data, token)
     # if we got another content disposition before, ditch the one added
     # by super()
     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 not docids:
                 cr, uid = request.cr, request.uid
                 report = request.registry['report']._get_report_from_name(
                     cr, uid, reportname)
                 data = dict(url_decode(url.split('?')[1]).items())
                 data = json.loads(data.pop('options'))
                 response.headers[
                     'Content-Disposition'] = content_disposition(
                         data['download_name'])
                 return response
     except Exception as e:
         exc_info = sys.exc_info()
         se = traceback.format_exception(*exc_info)
         error = {'code': 200, 'message': "Odoo Server Error", 'data': se}
         return request.make_response(html_escape(json.dumps(error)))
     return response
Esempio n. 23
0
 def report_routes(self, reportname, docids=None, converter=None, **data):
     if converter == "jasperserver":
         report = request.env["ir.actions.report"]._get_report_from_name(
             reportname)
         context = dict(request.env.context)
         if docids:
             docids = [int(i) for i in docids.split(",")]
         if data.get('options'):
             data.update(json.loads(data.pop("options")))
         if data.get("context"):
             # Ignore 'lang' here, because the context in data is the one
             # from the webclient *but* if the user explicitely wants to
             # change the lang, this mechanism overwrites it.
             data["context"] = json.loads(data["context"])
             if data["context"].get("lang"):
                 del data["context"]["lang"]
             context.update(data["context"])
         pdf = report.with_context(context).render_jasperserver_pdf(
             docids, data=data)[0]
         filename = "{}.{}".format(report.name, "pdf")
         if report.print_report_name and not len(docids) > 1:
             obj = request.env[report.model].browse(docids)
             report_name = safe_eval(report.print_report_name, {
                 "object": obj,
                 "time": time
             })
             filename = "{}.{}".format(report_name, "pdf")
         pdfhttpheaders = [
             ("Content-Type", "application/pdf"),
             ("Content-Length", len(pdf)),
             ("Content-Disposition", content_disposition(filename)),
         ]
         return request.make_response(pdf, headers=pdfhttpheaders)
     return super(ReportController,
                  self).report_routes(reportname, docids, converter, **data)
Esempio n. 24
0
 def download_document(self, model, id, **kwargs):
     summ = request.env[model].browse(int(id))
     file = base64.b64decode(summ.datas)
     file_name = summ.datas_fname
     return request.make_response(
         file, [('Content-Type', 'text/plain'),
                ('Content-Disposition', content_disposition(file_name))])
Esempio n. 25
0
 def portal_my_summary(self, **kw):
     partner = request.env.user.partner_id
     to_date = fields.Datetime.to_string(datetime.now())
     from_date = fields.Datetime.to_string(datetime.now() +
                                           timedelta(days=-30))
     report_data = {
         'secondary_currency': False,
         'financial_amounts': False,
         'result_selection': 'all',
         'company_type': 'group_by_company',
         'company_id': False,
         'from_date': from_date,
         'to_date': to_date,
         'historical_full': True,
         'show_invoice_detail': False,
         'lang': partner.lang,
     }
     xls = request.env.ref('account_debt_management.account_debt_report'
                           ).sudo().with_context(report_data).render(
                               [partner.id], data=report_data)[0]
     xlshttpheaders = [('Content-Type', 'application/vnd.ms-excel'),
                       ('Content-Length', len(xls)),
                       ('Content-Disposition',
                        content_disposition('Resumen de Cuenta' + '.xls'))]
     return request.make_response(xls, headers=xlshttpheaders)
Esempio n. 26
0
    def survey_get_certification(self, survey_id, **kwargs):
        """ The certification document can be downloaded as long as the user has succeeded the certification """
        survey = request.env['survey.survey'].sudo().search([
            ('id', '=', survey_id),
            ('certificate', '=', True)
        ])

        if not survey:
            # no certification found
            return werkzeug.utils.redirect("/")

        succeeded_attempt = request.env['survey.user_input'].sudo().search([
            ('partner_id', '=', request.env.user.partner_id.id),
            ('survey_id', '=', survey_id),
            ('quizz_passed', '=', True)
        ], limit=1)

        if not succeeded_attempt:
            raise UserError(_("The user has not succeeded the certification"))

        report_sudo = request.env.ref('survey.certification_report').sudo()

        report = report_sudo.render_qweb_pdf([succeeded_attempt.id], data={'report_type': 'pdf'})[0]
        reporthttpheaders = [
            ('Content-Type', 'application/pdf'),
            ('Content-Length', len(report)),
        ]
        reporthttpheaders.append(('Content-Disposition', content_disposition('Certification.pdf')))
        return request.make_response(report, headers=reporthttpheaders)
Esempio n. 27
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        # if it's not Aeroo Reports fall back to original reporting engine
        if converter != 'aeroo':
            return super(ReportController,
                         self).report_routes(reportname, docids, converter,
                                             **data)

        # Aeroo Reports starts here
        report_obj = request.env['ir.actions.report']
        report = report_obj._get_report_from_name(reportname)
        context = dict(request.env.context)
        # report_data = {}
        if docids:
            docids = [int(i) for i in docids.split(',')]
        if data.get('options'):
            data.update(json.loads(data.pop('options')))
        if data.get('context'):
            data['context'] = json.loads(data['context'])
            if data['context'].get('lang'):
                del data['context']['lang']
            context.update(data['context'])

        rset = report.with_context(context).render_aeroo(docids, data=data)
        mimetype = self.MIMETYPES.get(rset[1], 'application/octet-stream')
        httpheaders = [('Content-Disposition', content_disposition(rset[2])),
                       ('Content-Type', mimetype),
                       ('Content-Length', len(rset[0]))]

        return request.make_response(rset[0], headers=httpheaders)
Esempio n. 28
0
    def report_routes(self, reportname, docids=None, converter=None, **data):
        # Trick the main reporter to think we want an HTML report
        new_converter = converter if converter != "xml" else "html"
        response = super(ReportController,
                         self).report_routes(reportname, docids, new_converter,
                                             **data)

        # If it was an XML report, just download the generated response
        if converter == "xml":
            # XML header must be before any spaces, and it is a common error,
            # so let's fix that here and make developers happier
            response.data = response.data.strip()
            response.headers.set("Content-Type", "text/xml")
            response.headers.set('Content-length', len(response.data))
            # set filename
            action_report_obj = request.env['ir.actions.report']
            report = action_report_obj._get_report_from_name(reportname)
            filename = report.name
            if docids:
                ids = [int(x) for x in docids.split(",")]
                records = request.env[report.model].browse(ids)
                if report.print_report_name and not len(records) > 1:
                    filename = safe_eval(report.print_report_name, {
                        'object': records,
                        'time': time
                    })
            response.headers.set('Content-Disposition',
                                 content_disposition(filename + ".xml"))
        return response
Esempio n. 29
0
    def OAS_json_spec_download(self, namespace_name, **kwargs):
        ensure_db()
        namespace = http.request.env['openapi.namespace'].sudo().search([
            ('name', '=', namespace_name)
        ])
        if not namespace:
            raise werkzeug.exceptions.NotFound()
        if namespace.token != kwargs.get('token'):
            raise werkzeug.exceptions.Forbidden()

        response_params = {'headers': [('Content-Type', 'application/json')]}
        if 'download' in kwargs:
            response_params = {
                'headers': [
                    ('Content-Type',
                     'application/octet-stream; charset=binary'),
                    ('Content-Disposition',
                     http.content_disposition('swagger.json')),
                ],
                'direct_passthrough':
                True
            }

        return werkzeug.wrappers.Response(json.dumps(namespace.get_OAS()),
                                          status=200,
                                          **response_params)
Esempio n. 30
0
    def _show_report(self, model, report_type, report_ref, download=False):
        if report_type not in ('html', 'pdf', 'text'):
            raise UserError(_("Invalid report type: %s", report_type))

        report_sudo = request.env.ref(report_ref).with_user(SUPERUSER_ID)

        if not isinstance(report_sudo, type(request.env['ir.actions.report'])):
            raise UserError(
                _("%s is not the reference of a report", report_ref))

        if hasattr(model, 'company_id'):
            report_sudo = report_sudo.with_company(model.company_id)

        method_name = '_render_qweb_%s' % (report_type)
        report = getattr(report_sudo, method_name)([model.id],
                                                   data={
                                                       'report_type':
                                                       report_type
                                                   })[0]
        reporthttpheaders = [
            ('Content-Type',
             'application/pdf' if report_type == 'pdf' else 'text/html'),
            ('Content-Length', len(report)),
        ]
        if report_type == 'pdf' and download:
            filename = "%s.pdf" % (re.sub('\W+', '-',
                                          model._get_report_base_filename()))
            reporthttpheaders.append(
                ('Content-Disposition', content_disposition(filename)))
        return request.make_response(report, headers=reporthttpheaders)
Esempio n. 31
0
    def survey_get_certification(self, survey_id, **kwargs):
        """ The certification document can be downloaded as long as the user has succeeded the certification """
        survey = request.env['survey.survey'].sudo().search([
            ('id', '=', survey_id), ('certificate', '=', True)
        ])

        if not survey:
            # no certification found
            return werkzeug.utils.redirect("/")

        succeeded_attempt = request.env['survey.user_input'].sudo().search(
            [('partner_id', '=', request.env.user.partner_id.id),
             ('survey_id', '=', survey_id), ('quizz_passed', '=', True)],
            limit=1)

        if not succeeded_attempt:
            raise UserError(_("The user has not succeeded the certification"))

        report_sudo = request.env.ref('survey.certification_report').sudo()

        report = report_sudo.render_qweb_pdf([succeeded_attempt.id],
                                             data={'report_type': 'pdf'})[0]
        reporthttpheaders = [
            ('Content-Type', 'application/pdf'),
            ('Content-Length', len(report)),
        ]
        reporthttpheaders.append(
            ('Content-Disposition', content_disposition('Certification.pdf')))
        return request.make_response(report, headers=reporthttpheaders)
Esempio n. 32
0
 def make_event_ics_file(self, event, **kwargs):
     if not event or not event.registration_ids:
         return request.not_found()
     files = event._get_ics_file()
     content = files[event.id]
     return request.make_response(content, [
         ('Content-Type', 'application/octet-stream'),
         ('Content-Length', len(content)),
         ('Content-Disposition', content_disposition('%s.ics' % event.name))
     ])
Esempio n. 33
0
    def _binary_set_headers(self, status, content, filename, mimetype, unique, filehash=None, download=False):
        headers = [('Content-Type', mimetype), ('X-Content-Type-Options', 'nosniff')]
        # cache
        etag = bool(request) and request.httprequest.headers.get('If-None-Match')
        status = status or (304 if filehash and etag == filehash else 200)
        if filehash:
            headers.append(('ETag', filehash))
        headers.append(('Cache-Control', 'max-age=%s' % (STATIC_CACHE if unique else 0)))
        # content-disposition default name
        if download:
            headers.append(('Content-Disposition', content_disposition(filename)))

        return (status, headers, content)
Esempio n. 34
0
    def _show_report(self, model, report_type, report_ref, download=False):
        if report_type not in ('html', 'pdf', 'text'):
            raise UserError("Invalid report type: %s" % report_type)

        report_sudo = request.env.ref(report_ref).sudo()

        if not isinstance(report_sudo, type(request.env['ir.actions.report'])):
            raise UserError("%s is not the reference of a report" % report_ref)

        method_name = 'render_qweb_%s' % (report_type)
        report = getattr(report_sudo, method_name)([model.id], data={'report_type': report_type})[0]
        reporthttpheaders = [
            ('Content-Type', 'application/pdf' if report_type == 'pdf' else 'text/html'),
            ('Content-Length', len(report)),
        ]
        if report_type == 'pdf' and download:
            filename = "%s.pdf" % (re.sub('\W+', '-', model._get_report_base_filename()))
            reporthttpheaders.append(('Content-Disposition', content_disposition(filename)))
        return request.make_response(report, headers=reporthttpheaders)
Esempio n. 35
0
    def portal_my_invoice_report(self, invoice_id, access_token=None, **kw):
        try:
            invoice_sudo = self._document_check_access('account.invoice', invoice_id, access_token)
        except (AccessError, MissingError):
            return request.redirect('/my')

        # print report as sudo, since it require access to taxes, payment term, ... and portal
        # does not have those access rights.
        accountInvoiceReport = request.env.ref('account.account_invoices').sudo()
        report_type = kw.get('report_type', 'pdf')
        method_name = 'render_qweb_%s' % (report_type)
        if hasattr(accountInvoiceReport, method_name):
            invoice_report = getattr(accountInvoiceReport, method_name)([invoice_sudo.id], data={'report_type': report_type})[0]
            reporthttpheaders = [
                ('Content-Type', 'application/pdf' if report_type == 'pdf' else 'text/html'),
                ('Content-Length', len(invoice_report)),
            ]
            if report_type == 'pdf' and not kw.get('print'):
                filename = "%s.pdf" % (re.sub('\W+', '-', invoice_sudo._get_printed_report_name()))
                reporthttpheaders.append(('Content-Disposition', http.content_disposition(filename)))
            return request.make_response(invoice_report, headers=reporthttpheaders)
        raise NotFound()
Esempio n. 36
0
 def content_disposition(self, filename):
     return content_disposition(filename)
Esempio n. 37
0
 def content_disposition(cls, filename):
     return content_disposition(filename)