Пример #1
0
    def build(self, ar, action, elem):
        if render_pdf_from_template is None:
            raise Warning(
                "wkhtmltopdf build fails because django-wkhtmltopdf "
                "is not installed.")
        filename = action.before_build(self, elem)
        if filename is None:
            return
        tpl = self.get_template(action, elem)
        htpl = None
        ftpl = None

        lang = str(elem.get_print_language()
                   or settings.SITE.DEFAULT_LANGUAGE.django_code)
        with translation.override(lang):
            cmd_options = elem.get_build_options(self)
            logger.info(
                "wkhtmltopdf render %s -> %s (%r, %s)",
                tpl, filename, lang, cmd_options)

            context = elem.get_printable_context(ar)
            html = render_pdf_from_template(
                tpl, htpl, ftpl, context, cmd_options)
            # html = html.encode("utf-8")
            file(filename, 'w').write(html)
            return os.path.getmtime(filename)
Пример #2
0
 def generate_invoice(self):
     self.set_invoice_id()
     response = render_pdf_from_template('invoices/invoice.html',
                                         None,
                                         None,
                                         context={'object': self})
     self.attached_file.save('invoice{}.pdf'.format(self.invoice_id),
                             File(BytesIO(response)))
Пример #3
0
    def get_initial(self):
        if not self.inv_class:
            raise ValueError(
                'Improperly configured, needs an inv_class attribute')

        inv = self.inv_class.objects.get(pk=self.kwargs['pk'])

        out_file = os.path.join(os.getcwd(), 'media', 'temp', 'out.pdf')
        if os.path.exists(out_file):
            out_file = os.path.join(os.getcwd(), 'media', 'temp',
                                    f'out_{random.randint(1, 100000)}.pdf')

        #use the context for pagination and the object
        obj = self.inv_class.objects.get(pk=self.kwargs['pk'])
        context = {
            'object': obj,
        }
        config = GlobalConfig.objects.first()
        context.update(config.__dict__)
        context.update({
            'logo': config.logo,
            'logo_width': config.logo_width,
            'business_name': config.business_name,
            'business_address': config.business_address
        })
        options = {'output': out_file}
        try:
            pdf_tools.render_pdf_from_template(self.pdf_template_name,
                                               None,
                                               None,
                                               apply_style(context),
                                               cmd_options=options)

        except Exception as e:
            print('Error occured creating pdf %s' % e)
            raise PDFException()

        return {
            'owner': self.request.user.pk,
            'folder': 'sent',
            'attachment_path': out_file
        }
Пример #4
0
    def post(self, request, *args, **kwargs):
        resp = super(EmailPlusPDFView, self).post(request, *args, **kwargs)
        form = self.form_class(request.POST)

        if not form.is_valid():
            return resp

        config = GlobalConfig.objects.get(pk=1)
        msg = EmailMessage(subject=form.cleaned_data['subject'],
                           body=form.cleaned_data['content'],
                           from_email=config.email_user,
                           to=[form.cleaned_data['recipient']])
        if not self.pdf_template_name:
            raise ValueError(
                'Improperly configured. Needs pdf_template_name attribute.')

        out_file = os.path.join(os.getcwd(), 'media', 'temp', 'out.pdf')

        #use the context for pagination and the object
        obj = self.inv_class.objects.get(pk=self.kwargs['pk'])
        context = {
            'object': obj,
        }
        context.update(SalesConfig.objects.first().__dict__)
        options = {'output': out_file}
        try:
            pdf_tools.render_pdf_from_template(self.pdf_template_name,
                                               None,
                                               None,
                                               apply_style(context),
                                               cmd_options=options)

        except Exception as e:
            raise Exception('Error occured creating pdf %s' % e)

        if os.path.isfile(out_file):
            msg.attach_file(out_file)
            msg.send()
            os.remove(out_file)

        # if the message is successful delete it.
        return resp
Пример #5
0
    def test_render_with_null_request(self):
        """If request=None, the file should render properly."""
        title = 'A test template.'
        template = loader.get_template('sample.html')
        pdf_content = render_pdf_from_template('sample.html',
                                               header_template=None,
                                               footer_template=None,
                                               context={'title': title})

        self.assertTrue(pdf_content.startswith(b'%PDF-'))
        self.assertTrue(pdf_content.endswith(b'%%EOF\n'))
Пример #6
0
def render_badge_pdf(user):
    text = ("{:0%s}" % BARCODE_LENGTH).format(user.pk)
    qrcode_value = get_barcode(text)
    image_url = "https://enjazportal.com/static/static/img/hpc.png"
    context = {'qrcode_value': qrcode_value,
               'image_url': image_url,
               'text': text,
               'barcode_user': user}
    qrcode_output = StringIO.StringIO()
    badge_template = get_template("events/partials/badge.html")
    pdf_content = render_pdf_from_template(badge_template,
                                        header_template=None,
                                        footer_template=None,
                                        context=context,
                                        cmd_options=WKHTMLTOPDF_OPTIONS.copy())
    return pdf_content
Пример #7
0
def render_badge_pdf(user):
    text = ("{:0%s}" % BARCODE_LENGTH).format(user.pk)
    qrcode_value = get_barcode(text)
    image_url = "https://enjazportal.com/static/static/img/hpc.png"
    context = {'qrcode_value': qrcode_value,
               'image_url': image_url,
               'text': text,
               'barcode_user': user}
    qrcode_output = StringIO.StringIO()
    badge_template = get_template("events/partials/badge.html")
    pdf_content = render_pdf_from_template(badge_template,
                                        header_template=None,
                                        footer_template=None,
                                        context=context,
                                        cmd_options=WKHTMLTOPDF_OPTIONS.copy())
    return pdf_content
Пример #8
0
    def build(self, ar, action, elem):
        filename = action.before_build(self, elem)
        if filename is None:
            return
        tpl = self.get_template(action, elem)
        htpl = None
        ftpl = None

        lang = str(elem.get_print_language()
                   or settings.SITE.DEFAULT_LANGUAGE.django_code)
        logger.info("wkhtmltopdf render %s -> %s (%r)", tpl, filename, lang)

        with translation.override(lang):

            context = elem.get_printable_context(ar)
            html = render_pdf_from_template(tpl, htpl, ftpl, context)
            # html = html.encode("utf-8")
            file(filename, 'w').write(html)
            return os.path.getmtime(filename)
Пример #9
0
def send_upn(request, event_name=False):
    event_instance = get_event_by_name_no_rights(event_name)
    profile = get_object_or_404(EventProfile,
                                event=event_instance,
                                user=request.user)
    context = {
        'event': event_instance,
        'profile': profile,
        'date': datetime.now(),
        'date_to': date.today() + timedelta(days=10)
    }

    for payment in event_instance.payment.all():
        t_payment = payment.get_payments()
        if t_payment[0] == 'UPN':
            context['payment'] = t_payment[1]
            break

    print(context)
    return_file = "tmp/" + 'upn_' + event_instance.name + '_' + str(
        profile.id) + '.pdf'

    t = loader.get_template('Visitor/email/upn.html')
    #DEBUG FOR UPN
    #return render(request, 'Visitor/email/upn.html', context)
    response = render_pdf_from_template(
        request=request,
        context=context,
        input_template=t,
        header_template='',
        footer_template='',
    )

    message = EmailMessage(
        'Visitor/email/base_email.html',
        {'user': profile},
        '*****@*****.**',  #event_instance.sent_mail,
        to=[profile.user.email])
    message.attach('invoice.pdf', response, 'application/pdf')
    message.send()

    return render(request, 'Visitor/mail_redirect.html', {})
Пример #10
0
    def build(self, ar, action, elem):
        if render_pdf_from_template is None:
            raise Warning("wkhtmltopdf build fails because django-wkhtmltopdf "
                          "is not installed.")
        filename = action.before_build(self, elem)
        if filename is None:
            return
        tpl = self.get_template(action, elem)
        htpl = None
        ftpl = None

        lang = str(elem.get_print_language()
                   or settings.SITE.DEFAULT_LANGUAGE.django_code)
        with translation.override(lang):
            cmd_options = elem.get_build_options(self)
            logger.info("wkhtmltopdf render %s -> %s (%r, %s)", tpl, filename,
                        lang, cmd_options)

            context = elem.get_printable_context(ar)
            html = render_pdf_from_template(tpl, htpl, ftpl, context,
                                            cmd_options)
            # html = html.encode("utf-8")
            file(filename, 'w').write(html)
            return os.path.getmtime(filename)
Пример #11
0
def generate_daily_speeding_report():
    template = os.path.join('reports', 'report', 'speeding_summary.html')
    today = datetime.date.today()
    context = {
        'date': today,
    }
    events = []

    start = datetime.datetime(today.year, today.month, today.day, 0, 0, 0)
    end = datetime.datetime(today.year, today.month, today.day, 23, 59, 59)

    #login
    #get parameters from config
    config = Config.objects.first()

    session = login()
    if isinstance(session, HttpResponse):
        logging.critical(session.content)
        return

    #get vehicle list
    vehicle_ids = get_vehicle_list(session, config)
    if not vehicle_ids:
        return

    class EventTracker:
        speeding_records = []
        speed_tracks = []
        duration = 0

    tracker = EventTracker()

    #get speeding records for each vehicle.
    for vehicle in vehicle_ids:
        url = f'http://{config.host}:{config.server_port}/' + \
              f'StandardApiAction_queryTrackDetail.action'
        params = {
            'jsession': session,
            'devIdno': vehicle['did'],
            'begintime': start.strftime('%Y-%m-%d %H:%M:%S'),
            'endtime': end.strftime('%Y-%m-%d %H:%M:%S'),
            'currentPage': 1,
            'toMap': 1,
            'pageRecords': 100,
        }
        resp = requests.get(url, params=params)
        #process for speeding and discard each chunk
        data = json.loads(resp.content)
        SpeedingReport.process_data(tracker,
                                    data,
                                    config,
                                    vehicle_id=vehicle['id'])
        current_page = 1
        if not data['pagination']:
            continue

        while data['pagination']['hasNextPage']:
            current_page += 1
            params['currentPage'] = current_page
            resp = requests.get(url, params=params)
            if resp.status_code != 200:
                break
            data = json.loads(resp.content)
            SpeedingReport.process_data(tracker,
                                        data,
                                        config,
                                        vehicle_id=vehicle['id'])

    #store the records in a list and return the list.
    context.update({
        'events': events,
        'vehicles': len(vehicle_ids),
        'config': config,
        'ip': socket.gethostbyname(socket.gethostname())
    })
    outfile = os.path.abspath(
        os.path.join('daily_reports', f'speeding-summary {today}.pdf'))

    pdf_tools.render_pdf_from_template(template,
                                       None,
                                       None,
                                       context,
                                       cmd_options={'output': outfile})

    email_speeding_report(outfile, config)
    return True