def send_mail(subject, html_content, text_content, recipients, expert_request=None, attach_tor=False, attach_letter=False): # control of execution if email_is_off(): return # control of environment if env_is_local(): # local env email only to secondments mail list recipients = SECONDMENTS_MAIL_LIST # test indicator to render PDF as test sample test = test_is_on() if test: # subject with TEST subject = "This is a TEST email! " + subject msg = EmailMultiAlternatives(subject, text_content, EMAIL_HOST_USER, recipients, bcc=SECONDMENTS_MAIL_LIST) msg.attach_alternative(html_content, "text/html") msg.mixed_subtype = 'related' # attachments stuff if attach_letter or attach_tor: context = {'expert_request': expert_request, 'pagesize': 'A4', 'BASE_DIR': os.path.join(BASE_DIR, 'crppdmt/static/'), 'test_env': test,} try: tor_pdf = render_to_pdf('crppdmt/pdf/tor.html', context) letter_pdf = render_to_pdf('crppdmt/pdf/letter_of_request.html', context) msg.attach('ToR.pdf',tor_pdf,'application/pdf') msg.attach('LetterOfRequest.pdf',letter_pdf,'application/pdf') except: print("Error attaching ToR and Letter to Email. Request: " + expert_request.name) print("Error: " + str(sys.exc_info())) msg.send()
def get(self, request, *args, **kwargs): self.order = Order.objects.get(number=kwargs['number']) ctx = self.get_context_data() render_to_pdf(request=request, template=self.template_name, context=ctx, download_filename=self.download_filename) return super(InvoiceDownloadView, self).get(request, *args, **kwargs)
def send_mail(subject, html_content, text_content, recipients, expert_request=None, attach_tor=False, attach_letter=False): # control of execution if email_is_off(): return # control of environment if env_is_local(): # local env email only to secondments mail list recipients = SECONDMENTS_MAIL_LIST # test indicator to render PDF as test sample test = test_is_on() if test: # subject with TEST subject = "This is a TEST email! " + subject msg = EmailMultiAlternatives(subject, text_content, EMAIL_HOST_USER, recipients, bcc=SECONDMENTS_MAIL_LIST) msg.attach_alternative(html_content, "text/html") msg.mixed_subtype = 'related' # attachments stuff if attach_letter or attach_tor: context = { 'expert_request': expert_request, 'pagesize': 'A4', 'BASE_DIR': os.path.join(BASE_DIR, 'crppdmt/static/'), 'test_env': test, } try: tor_pdf = render_to_pdf('crppdmt/pdf/tor.html', context) letter_pdf = render_to_pdf( 'crppdmt/pdf/letter_of_request.html', context) msg.attach('ToR.pdf', tor_pdf, 'application/pdf') msg.attach('LetterOfRequest.pdf', letter_pdf, 'application/pdf') except: print("Error attaching ToR and Letter to Email. Request: " + expert_request.name) print("Error: " + str(sys.exc_info())) msg.send()
def render(self, data, accepted_media_type=None, renderer_context=None): try: entry = data["items"][0] except IndexError: context = { "header_rows": [], "content_rows": [], "total": 0, "title": data["title"], } else: group_by_month = entry.has_key("months") context = { "total": data["total_occurrences"], "title": data["title"], "header_rows": self.get_header_rows(entry, year=data.get("year"), group_by_month=group_by_month), "content_rows": self.get_content_rows(data["items"], group_by_month=group_by_month), } return render_to_pdf("nfdrenderers/pdf/aggregation_stats.html", context)
def send_email(obj, user, userdata, doctordata, measurements) -> bool: """sends email from user's email to doctor, message contains all user's measurements and an attachment - PDF file Args: obj (SendDataToDoctor): [object representing view] user (UserData): [user's data] doctor (DoctorData): [doctor's data] measurements (Measurement): [all measurements belongs to logged user] """ topic = "Pomiary ciśnienia krwi" message = "Pomiary ciśnienia krwi dla użytkownika {name} {surname}".format( name=userdata.name, surname=userdata.surname) context = {} context["user"] = userdata context["measurements"] = measurements try: attachment = render_to_pdf("generate_files/PDF_template.html", context) except Exception as e: print(e) print("Błąd przy tworzeniu załącznika") attachment = None return False email = EmailMessage(topic, message, user.email, [doctordata.email]) email.attach("pomiary.pdf", attachment) email.send() return True
def generate_pdf(self): today = datetime.datetime.today() data = { 'surname': self.surname, 'first_name': self.first_name, 'year': today.year, 'month': today.month, 'hours': self.hours, 'last_day_of_month': calendar.monthrange(today.year, today.month)[1], 'unit_of_organisation': self.unit_of_organisation, } timesheet_data, header_date, total_hours = generate_timesheet_data( year=data['year'], month=data['month'], fdom=1, ldom=data['last_day_of_month'], hours=data['hours']) data.update({ 'timesheet_data': timesheet_data, 'header_date': header_date, 'total_hours': total_hours }) return render_to_pdf(template='creator/timesheet.html', context=data)
def generate_final_report(obj, code, labels, pdf, template, filename): labels_serializer = labels(obj) pdf_serializer = pdf(obj) context = { 'engagement': pdf_serializer.data, 'serializer': labels_serializer, } content_type = ContentType.objects.get_for_model(obj) file_type, __ = FileType.objects.get_or_create( code=code, defaults={ "label": code.replace("_", " ").title(), "name": code.replace("_", " "), } ) attachment, __ = Attachment.objects.get_or_create( code=code, content_type=content_type, object_id=obj.pk, defaults={ "file_type": file_type, } ) file_path = generate_file_path(attachment, filename) attachment.file.save( file_path, ContentFile(render_to_pdf(template, context)), )
def render(self, data, accepted_media_type=None, renderer_context=None): occurrences = [] for index, occ in enumerate(data): occurrence = _get_occurrence(occ) occurrence.update(index=index + 1) occurrences.append(occurrence) query_params = renderer_context["request"].query_params.dict() filters = self.get_filters(query_params) filters.update( natural_area_code_nac=query_params.get("natural_area_code_nac"), general_description=query_params.get("general_description"), notable_features=query_params.get("notable_features"), ) default_columns = [ "list_id", "genus", "natural_area_code", "general_description", "cm_status", "latitude", "longitude", ] chosen_table_columns = get_table_columns(query_params, default_columns) table_columns = chosen_table_columns if len( chosen_table_columns) > 0 else default_columns[0:1] return render_to_pdf( "nfdrenderers/pdf/natural_area_occurrence_report.html", context={ "occurrences": occurrences, "filters": {k: v for k, v in filters.items() if v}, "table_columns": table_columns, })
def __email(request): arguments = request.session['job_app_args'] message = request.session['email'] to = [request.POST.get('address')] context = Context(arguments) template = 'cover_letter_pdf.html' cover_letter = render_to_pdf(template, context) print request.POST email = EmailMessage(subject=arguments.get('job_position'), body=message, bcc=['*****@*****.**'], from_email='*****@*****.**', to=to) email.content_subtype = "html" cv = CV.objects.first() email.attach('EkaterinaStepanova.CV.pdf', cv.file.read(), 'application/pdf') if 'vdom' in request.POST: vdom = Reference.objects.filter(name='vdom').first() email.attach('EkaterinaStepanova.Reference.VDOM.pdf', vdom.file.read(), 'application/pdf') if 'nec' in request.POST: nec = Reference.objects.filter(name='nec').first() email.attach('EkaterinaStepanova.Reference.NEC.pdf', nec.file.read(), 'application/pdf') email.attach('EkaterinaStepanova.MotivationLetter.pdf', cover_letter, 'application/pdf') email.send() return render(request, 'home.html')
def render_propietario_report_pdf(inmueble_pk, mes, site_name): ''' this method generates the resumen for propietarios pdf ''' from condominioaldia_app.models import Inmueble month = mes inmueble = Inmueble.objects.get(pk=inmueble_pk) #GET THE EGRESOS month_range = month_range_dt(month) egresos = inmueble.condominio.egreso_condominio_set.filter( mes__range=(month_range[0], month_range[1])) sum_egresos = egresos.aggregate( total_deuda=Sum('monto'))['total_deuda'] or 0 ###################### #cobranzas = inmueble.cobranza_condominio_set.filter(payment__aprobado =True) cobranzas = inmueble.cobranza_condominio_set.filter( mes__range=(month_range[0], month_range[1])) sum_cobranzas = get_total_cobranzas(cobranzas, inmueble, sum_egresos) pagos = inmueble.ingreso_condominio_set.filter(mes__range=(month_range[0], month_range[1]), aprobado=True) factura_propietario = inmueble.factura_propietario_set.filter( mes__range=(month_range[0], month_range[1]))[0] context = {} context['mes'] = month context['aviso'] = ''' De acuerdo a los articulos 14 y 15 de la ley horizontal, el presenteaviso de cobro tiene valor yfuerza ejecutiva ''' #NEED TO GET TOTAL OWED debt_properties = inmueble.condominio.inmueble_set.filter( deuda_actual__lt=0) context['debt_properties'] = debt_properties context['pagos'] = pagos context['site_name'] = site_name context['inmueble'] = inmueble context['cobranzas'] = cobranzas context['cuentas'] = inmueble.condominio.bancos_set.all() context['egresos'] = egresos context['sum_cobranzas'] = decimal.Decimal(sum_cobranzas).quantize( settings.TWOPLACES) context['factura_propietario'] = factura_propietario context['paper_type'] = 'landscape' context['sum_egresos'] = sum_egresos context['pagesize'] = 'letter' context['page_margin_top'] = '1cm' context['page_margin_bottom'] = '1cm' context['page_margin_left'] = '1cm' context['page_margin_right'] = '1cm' context['footer_height'] = '1cm' context[ 'balance_title'] = 'Deuda' if factura_propietario.monto < 0 else 'Balance' template = 'pdf/reporte_mensual_propietario.html' pdf = render_to_pdf(template, context) return pdf
def export_pdf(self): columns = [] for i in range(len(self._datatable.columns)): field = list(self._datatable.columns.keys())[i] col = self._datatable.columns[field] if not col.export or isinstance(col, DisplayColumn): continue columns.append(col) cabecera = [] for i in range(len(columns)): if not columns[i].export: continue cabecera.append(columns[i].label) datos = [] r = 0 for row in self._datatable.search(self.get_queryset()): d = [] for i in range(len(columns)): if not columns[i].export: continue if columns[i].processor: val = getattr(self._datatable, columns[i].processor)(row, self._datatable) else: val = row for attr in columns[i].sources[0].split('__'): try: val = getattr(val, attr) except: val = '' if isinstance(val, models.Model): val = str(val) if val is None: val = '' d.append(val) r += 1 datos.append(d) if hasattr(settings, 'LOGO_URL_DATATABLE'): logo_url = settings.LOGO_URL_DATATABLE else: logo_url = '' if hasattr(settings, 'MEDIA_ROOT'): static_url = settings.MEDIA_ROOT else: static_url = '' pdf = render_to_pdf( 'datatableview/pdf.html', { 'cabecera': cabecera, 'datos': datos, 'logo': logo_url, 'url': static_url }) return make_response(pdf, 'data.pdf')
def payment_complete(request): import os cart_proxy = CartProxy(request) cart_proxy.clear() cart_proxy.cart.delete() order_group = OrderGroup.objects.get(pk=request.session['order_group']) context = { 'order_group': order_group, 'order_group_detail_url': request.build_absolute_uri( reverse('order-details', args={order_group.hash})), 'invoice_no': order_group.hash.hex[:6], 'contact': order_group.contact, 'settings': settings.INVOICE_SETTINGS } paypalLogger.debug('Processing payment complete...') paypalLogger.debug('Setting email context to: ') paypalLogger.debug(context) html_msg = render_to_string('order/email/order_placed/customer_main.html', context=context) text_msg = strip_tags(html_msg) # send email to customer paypalLogger.debug('Sending email ..') msg = EmailMultiAlternatives('Your order', body=text_msg, from_email='*****@*****.**', to=[ order_group.customer.email, ], bcc=__get_admins_email()) #create invoice pdf invoice_pdf = render_to_pdf('order/email/order_placed/invoice.html', context) temp = tempfile.NamedTemporaryFile(mode='wb', delete=False) temp.write(invoice_pdf) temp.close() file_name = 'invoice_{}.pdf'.format(order_group.hash.hex[:6]) os.rename(temp.name, file_name) #attach and send msg.attach_alternative(html_msg, "text/html") msg.attach_file(file_name) msg.send() #clean up os.remove(file_name) paypalLogger.debug('Email sent to {} and admin email {}'.format( order_group.customer.email, __get_admins_email())) return render(request, 'payment/payment_complete.html', { 'section': 'Payment', 'order_id': order_group.pk })
def get_as_response(self): try: pdf = render_to_pdf(self.template_name, self.get_context()) response = make_response(pdf) response['Content-disposition'] = 'inline; filename="{}"'.format(self.file_name) return response except PDFRenderingError: error_message = 'Error trying to render PDF' logger.exception(error_message) return HttpResponse(error_message)
def get(self, *args, **kwargs): salary = get_object_or_404(Salary, **kwargs) pdf = render_to_pdf('emails/payslip.html', {'salary': salary}) filename = slugify(f"{salary.user.get_full_name()} {salary.period}") response = HttpResponse(pdf, content_type="application/pdf") response['Content-Disposition'] = f"attachment; filename=payslip_{filename}.pdf" return response
def get(self, request, *args, **kwargs): context = self.get_context_data(**kwargs) context["query_results"] = self.query_results response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename="filename.pdf"' bts = render_to_pdf(self.template_name, context) # logger.debug(bts) # logger.debug(str(bts)) response.write(bts) return response
def generate_portfolio_pdf(request, pk, context): customer = get_object_or_404(Customer, pk=pk) template = get_template('portfolio/portfolio_pdf.html') html = template.render(context) pdf = render_to_pdf('portfolio/portfolio_pdf.html', context) if pdf: response = HttpResponse(pdf, content_type='application/pdf') response['Content-Disposition'] = 'filename= "portfolio_{}.pdf"'.format(customer.name) return pdf return HttpResponse("Not Found")
def signature_render(request, username, doc_type, signature_file): user = get_object_or_404(User, username=username) today = timezone.localtime(timezone.now()).date() pdf_args = {'name': user.get_full_name, 'date': today, 'doc_type': doc_type, 'signature_file': signature_file} if 'save_file' in request.GET: # Save the PDF as a file and redirect them back to the document list pdf_data = render_to_pdf('tablet/signature_render.html', pdf_args) pdf_file = FileUpload.objects.pdf_from_string(user, pdf_data, doc_type, user) os.remove(os.path.join(settings.MEDIA_ROOT, "signatures/%s" % signature_file)) return HttpResponseRedirect(reverse('tablet:document_list', kwargs={'username': user.username})) return render_to_pdf_response(request, 'tablet/signature_render.html', pdf_args)
def signature_render(request, username, doc_type, signature_file): user = get_object_or_404(User, username=username) today = timezone.localtime(timezone.now()).date() pdf_args = {'name': user.get_full_name, 'date': today, 'doc_type': doc_type, 'signature_file': signature_file} if 'save_file' in request.GET: # Save the PDF as a file and redirect them back to the document list pdf_data = render_to_pdf('tablet/signature_render.html', pdf_args) pdf_file = FileUpload.objects.pdf_from_string(user, pdf_data, doc_type, user) os.remove(os.path.join(settings.MEDIA_ROOT, "signatures/%s" % signature_file)) return HttpResponseRedirect(reverse('tablet_document_list', kwargs={'username': user.username})) return render_to_pdf_response(request, 'tablet/signature_render.html', pdf_args)
def crear_informe_en_archivo_pdf(ruta, perfil, desde, hasta, aplicacion): if aplicacion == 'suite': eventos = perfil.obtener_eventos_por_fecha(desde, hasta) else: eventos = perfil.obtener_eventos_de_robotica_por_fecha(desde, hasta) contexto = { "perfil": perfil, "eventos": eventos, "desde": formatear_fecha(desde), "hasta": formatear_fecha(hasta), } if aplicacion == 'suite': contenido = render_to_pdf("informe.html", contexto) else: contenido = render_to_pdf("informe_robotica.html", contexto) archivo2 = open(ruta, "w") archivo2.write(contenido) archivo2.close()
def test_render_to_pdf(): expert_request = ExpertRequest.objects.get(id=11) context = {'expert_request': expert_request, 'pagesize': 'A4', 'BASE_DIR': BASE_DIR, } #tor_template = loader.get_template('crppdmt/tor.html') #letter_template = loader.get_template('crppdmt/letter_of_request.html') tor_pdf = render_to_pdf('crppdmt/pdf/tor.html', context) tor_file = open("tor_file.pdf",'w') tor_file.write(tor_pdf) tor_file.close()
def patient_summary_generate_pdf(request, pk, context): patient = get_object_or_404(Patient, pk=pk) template = get_template('chs/patient_summary_pdf.html') html = template.render(context) pdf = render_to_pdf('chs/patient_summary_pdf.html', context) if pdf: response = HttpResponse(pdf, content_type='application/pdf') response['Content-Disposition'] = 'filename= "summary{}.pdf"'.format( patient.PatientID) #return response #return HttpResponse(pdf, content_type='application/octet-stream') return pdf return HttpResponse("Not Found")
def send_booking_mail(context): post_pdf = render_to_pdf('hotel/testPDF.html', context) global customer email_subject = "innOcity Booking Confirmation" email_body = "Your booking has been successfully completed . Find your booking pass in the attachment. \n Regrads, \n innOcity Team" msg = EmailMultiAlternatives(email_subject, email_body, settings.EMAIL_HOST_USER, [customer.email]) msg.attach('Booking Pass.pdf', post_pdf) msg.send() return
def get(self, request, *args, **kwargs): context = self.get_context_data(**kwargs) if self.pdf_or_png == "pdf": return self.render_to_response(context) elif self.pdf_or_png == "png": pdf = render_to_pdf("schedule.html", context=context, request=request, **kwargs) img = convert_from_bytes(pdf)[0] response = HttpResponse(content_type='image/png') response['Content-Disposition'] = 'attachment; filename=ITUscheduler' img.save(response, "PNG") return response else: return HttpResponseRedirect("/")
def generate_pdf(request, pk): product = Products.objects.get(id=pk) jumia_data = Jumia.objects.filter(product_id=product) killmall_data = Killmall.objects.filter(product_id=product) avechi_data = Avechi.objects.filter(product_id=product) data = { 'product': product, 'jumia_data': jumia_data, 'killmall_data': killmall_data, 'avechi_data': avechi_data, 'date': datetime.date.today() } pdf = render_to_pdf('pdf/contentpage.html', data) return HttpResponse(pdf, content_type='application/pdf')
def get(self, request, *args, **kwargs): data = {#'today': datetime.date.today(), 'amount': 39.99, 'customer_name': 'Cooper Mann', 'order_id': 1233434, 'base_url' :'file://' + settings.STATIC_URL + '/', 'price_s':price, 'dict':dict_, 'date':date_today, 'query':global_query, } pdf = render_to_pdf('pdf/contentpage.html', data) return HttpResponse(pdf, content_type='application/pdf')
def imprimircita(request,id_paciente,y,m,d,hora,idmedico): fecha=y+"-"+m+"-"+d #if request.GET: # print id_paciente # print hora # print idmedico # print fecha hoy=date.today() cita=Cita.objects.filter(paciente_idpaciente=id_paciente, fecha=fecha, hora_idhora=hora, medico_idmedico=idmedico) return render_to_pdf('citas/imprimircita.html',{ 'pagesize':'A4', 'title':'Comprobante de cita', 'citaprint':cita,'hoy':hoy, })
def get(self, *args, **kwargs): #payroll = get_object_or_404(Salary, **kwargs) pdf = render_to_pdf( 'emails/payslip.html', {} ) html_content = "<p>payslip is attached</p>" msg = EmailMultiAlternatives("Swiftkind Payroll", "payslip is attached", settings.DEFAULT_FROM_EMAIL, ['*****@*****.**']) msg.attach_alternative(html_content, "text/html") msg.attach('payslip.pdf', pdf, 'application/pdf') msg.send() return HttpResponse(status=200)
def pdf_portfolio(request, pk): template = get_template('portfolio/pdf_portfolio.html') customer = get_object_or_404(Customer, pk=pk) customers = Customer.objects.filter(created_date__lte=timezone.now()) investments = Investment.objects.filter(customer=pk) stocks = Stock.objects.filter(customer=pk) mutualfunds = Mutualfund.objects.filter(customer=pk) sum_recent_value = Investment.objects.filter(customer=pk).aggregate( Sum('recent_value')) sum_acquired_value = Investment.objects.filter(customer=pk).aggregate( Sum('acquired_value')) sum_mutual_acquired_value = Mutualfund.objects.filter( customer=pk).aggregate(Sum('acquired_value')) sum_mutual_recent_value = Mutualfund.objects.filter(customer=pk).aggregate( Sum('recent_value')) # overall_investment_results = sum_recent_value-sum_acquired_value # Initialize the value of the stocks sum_current_stocks_value = 0 sum_of_initial_stock_value = 0 for stock in stocks: sum_current_stocks_value += stock.current_stock_value() sum_of_initial_stock_value += stock.initial_stock_value() context = { 'customers': customers, 'investments': investments, 'stocks': stocks, 'sum_acquired_value': sum_acquired_value, 'sum_recent_value': sum_recent_value, 'sum_current_stocks_value': sum_current_stocks_value, 'sum_of_initial_stock_value': sum_of_initial_stock_value, 'mutualfunds': mutualfunds, 'sum_mutual_acquired_value': sum_mutual_acquired_value, 'sum_mutual_recent_value': sum_mutual_recent_value, } html = template.render(context) # 'email_success': email_success}) pdf = render_to_pdf('portfolio/pdf_portfolio.html', context) if pdf: response = HttpResponse(pdf, content_type='application/pdf') filename = 'pdf_portfolio_' + str(customer.name) + '.pdf' content = "inline; filename='%s'" % (filename) download = request.GET.get("download") if download: content = "attachment; filename='%s'" % (filename) response['Content-Disposition'] = content return response return HttpResponse("not found")
def render(self, data, accepted_media_type=None, renderer_context=None): if data.get("geom") is not None: geom = json.loads(data["geom"]) lat, lon = geom["coordinates"] else: lat = None lon = None no_data = "-" if data.get("details") is not None: details = { "gender": models.Gender.objects.get(code=data["details.gender"]), "marks": data["details.marks"] or no_data, "abnormalities": data["details.diseases_and_abnormalities"] or no_data, } else: details = { "gender": no_data, "marks": no_data, "abnormalities": no_data, } name = data["taxon.name"] rank = data["taxon.rank"] tsn = data["taxon.tsn"] return render_to_pdf( "nfdrenderers/pdf/layer_detail.html", { "taxon": { "name": name, "rank": rank, "tsn": tsn, "taxonomic_units": self.get_taxonomic_units(tsn), }, "observation": { "observation_date": data["observation.observation_date"], "daytime": data["observation.daytime"] or no_data, "season": data["observation.season"] or no_data, "reporter_name": data["observation.reporter.name"], "reporter_email": data["observation.reporter.email"], }, "details": details, "location": { "lat": lat, "lon": lon, }, "images": [im["image"] for im in data["images"]] })
def get_context_data ( self, **kwargs ): template_name = settings.APP_ROOT + "/templates/base/print_contract.html" context = { "users" : {}, "calendar" : None, "contracts" : None, "contract" : None, "today" : None, } pdf = rendering.render_to_pdf( template_name, context, encoding = u'utf-8', **kwargs ) return super ( self.__class__, self ).get_context_data( pagesize = "A4", title = "Hi there", **kwargs )
def get(self, request, *args, **kwargs): context = self.get_context_data(**kwargs) context["query_results"] = self.query_results cod = request.GET.get('cod', '') logger.debug("cod: " + cod) bts = render_to_pdf(self.template_name, context) # rs = { "bts": str(bts.decode('utf-8'))} #rs = { "bts": str(bts)} # return HttpResponse(str(bts), # content_type='application/pdf; charset=utf-8') # return HttpResponse(bts, # content_type='application/text') return HttpResponse(bts, content_type='application/pdf')
def mandarEmail(request, ausencias, fecha, asunto, destinatario, observaciones): try: mail_destino = [] mail_destino.append(destinatario) try: config = configuracion.objects.all().first() except configuracion.DoesNotExist: raise ValueError datos = config.get_datos_mail() mensaje_inicial = datos["mensaje_inicial"] mail_cuerpo = datos["mail_cuerpo"] mail_servidor = datos["mail_servidor"] mail_puerto = int(datos["mail_puerto"]) mail_usuario = datos["mail_usuario"] mail_password = str(datos["mail_password"]) mail_origen = datos["mail_origen"] observaciones_finales = observaciones context = Context() template = "ausentismos/informe_ausentismos.html" post_pdf = render_to_pdf(template, locals()) fecha = fecha nombre = "Informe_%s" % fecha html_content = get_template("general/email.html").render( {"mensaje_inicial": mensaje_inicial, "mail_cuerpo": mail_cuerpo} ) backend = EmailBackend( host=mail_servidor, port=mail_puerto, username=mail_usuario, password=mail_password, fail_silently=False ) email = EmailMessage( subject="%s" % (asunto), body=html_content, from_email=mail_origen, to=mail_destino, connection=backend ) email.attach("%s.pdf" % nombre, post_pdf, "application/pdf") email.content_subtype = "html" email.send() return True except Exception as e: print e return False
def send_slip(request, emp_id, mail, month=1): try: emp = Employee.objects.get(pk=emp_id) main_salary = emp.main_salary total_salary = emp.get_tottal_salary(month) net_salary = emp.get_net_salary(month) total_earnings, total_deductions = emp.get_tottals(month) try: s1 = EmployeeEarning.objects.filter(date__month=month, employee=emp) s = EmployeeEarningSerializer(s1, many=True) earnings = s.data except Exception as ex: earnings = [] try: d1 = EmployeeDeduction.objects.filter(date__month=month, employee=emp) d = EmployeeDeductionSerializer(d1, many=True) deductions = d.data except Exception as ex: deductions = [] data = { 'main_salary': main_salary, 'total_salary': total_salary, 'net_salary': net_salary, 'total_earnings': total_earnings, 'total_deductions': total_deductions, 'earnings': earnings, 'deductions': deductions } post_pdf = render_to_pdf('app_wall/slip.html', data) msg = EmailMessage("Employee Slip", "this slip for {}".format(emp.get_full_name()), to=[mail]) msg.attach('file.pdf', post_pdf, 'application/pdf') msg.content_subtype = "html" msg.send() return Response(status.HTTP_200_OK) except: return Response(status.HTTP_404_NOT_FOUND)
def get(self, request, pk, *args, **kwargs): # Render to pdf report = ProgressReport.objects.get(id=pk) data = dict() data['pd'] = report.programme_document data['unicef_office'] = report.programme_document.unicef_office data['title'] = report.programme_document.title data['reference_number'] = report.programme_document.reference_number data['start_date'] = report.programme_document.start_date.strftime( settings.PRINT_DATA_FORMAT) data['end_date'] = report.programme_document.end_date.strftime( settings.PRINT_DATA_FORMAT) data['cso_contribution'] = report.programme_document.cso_contribution data['budget'] = report.programme_document.budget data[ 'funds_received_to_date'] = report.programme_document.funds_received_to_date data[ 'challenges_in_the_reporting_period'] = report.challenges_in_the_reporting_period data['proposed_way_forward'] = report.proposed_way_forward data[ 'partner_contribution_to_date'] = report.partner_contribution_to_date data['submission_date'] = report.get_submission_date() data['reporting_period'] = report.get_reporting_period() data['partner'] = report.programme_document.partner data[ 'authorized_officer'] = report.programme_document.unicef_officers.first( ) data[ 'focal_point'] = report.programme_document.unicef_focal_point.first( ) data['outputs'] = self.prepare_reportable( report.indicator_reports.all().order_by('reportable')) pdf = render_to_pdf("report_annex_c_pdf.html", data) return HttpResponse(pdf, content_type='application/pdf')
def reportgenerator(request): # products = list((TrackedProducts.objects.values_list('product_id'),flat=True)) # # set(ProductOrder.objects.values_list('category', flat=True)) products_count = [] products_to_view = [] products = TrackedProducts.objects.order_by('product_id').values_list( 'product_id').distinct()[:10] # print("products",products) for i in products: product_coun = TrackedProducts.objects.filter(product_id=i[0]).count() product_name_to = Products.objects.get(id=i[0]).product_name products_count.append(product_coun) products_to_view.append(product_name_to) data = { 'products_count': products_count, 'products_name': products_to_view } pdf = render_to_pdf('main/report.html', data) return HttpResponse(pdf, content_type='application/pdf')
def note2pdf(note: Note): template = 'note2pdf.html' note.rendered_content = render_markdown(note.content) context = {'note': note} return render_to_pdf(template, context)