def render_pdf(self):
total = self.doc['total']
if self.home_country:
invoice_country_iso = self.doc['address']['country_iso_alpha2']
if invoice_country_iso and invoice_country_iso != self.home_country: # no tax in bill
total = self.doc['amount']
self.doc['total'] = total
tpl = self.jinja_env.get_template('invoice_tpl.html')
self.invoice_fname = "{date}_CHF{total:.2f}_Nr{nr}_hosting-{name}_ta".format(
date=self.doc['date'].strftime("%Y-%m-%d"),
total=total,
nr=self.doc['nr'],
name=self.client_name_normalized()
)
for file_format in ['html', 'pdf']:
path = "%s/%s" % (self.output_dir, file_format)
if not os.path.exists(path):
os.mkdir(path)
with codecs.open(
'%s/html/%s.html' % (self.output_dir, self.invoice_fname),
'w+', encoding="utf-8"
) as invoice_html:
invoice_html.write(tpl.render(**self.doc))
invoice_html.seek(0)
base_url = "%s/html" % self.invoice_template_dir
html = HTML(invoice_html, base_url=base_url)
html.write_pdf('%s/pdf/%s.pdf' % (self.output_dir, self.invoice_fname))
def html_to_pdf_view(request):
''' converte html para pdf --> html.write_pdf(target='/tmp/mypdf.pdf') fs = FileSystemStorage('/tmp') '''
try:
itens = ItemOrcamento.objects.all
valor_total = list(
ItemOrcamento.objects.aggregate(Sum('valor')).values())[0]
if valor_total != None:
status = None
else:
status = 'disabled'
context = {
'itens': itens,
'valor_total': valor_total,
'status': status
}
html_string = render_to_string('core/orcamento_template.html', context)
html = HTML(string=html_string)
with tempfile.TemporaryDirectory() as tmpdirname:
target_final = '/' + tmpdirname + '/mypdf.pdf'
html.write_pdf(target=target_final)
fs = FileSystemStorage(tmpdirname)
with fs.open('mypdf.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="mypdf.pdf"'
return response
except Exception as e:
print(e)
def export_pdf(pdf_filename, html_string, css_string):
font_config = FontConfiguration()
html = HTML(string=html_string)
css = CSS(string=css_string, font_config=font_config)
html.write_pdf(target=pdf_filename,
stylesheets=[css],
font_config=font_config)
def build_summary(outputfile, template_file, db, night=None, stylesheets=None):
if night is None:
night = (datetime.today() - timedelta(days=2)).strftime('%Y%m%d')
template = load_template(template_file)
runs = read_run(night, db)
qla_data = get_qla_data(night, db)
os.makedirs('build', exist_ok=True)
plot_run_timeline(runs, 'build/runs.svg')
plot_qla(qla_data, 'build/qla.svg')
md = template.render(
night=night,
run_plot='build/runs.svg',
qla_plot='build/qla.svg',
)
html = markdown.markdown(md, extensions=['markdown.extensions.tables'])
document = HTML(string=html, base_url='.')
outputfile = outputfile or 'fact_summary_{}.pdf'.format(night)
document.write_pdf(outputfile, stylesheets=stylesheets)
def get(self, request, pk, format='json'):
try:
todolist = TODOList.objects.get(owner=request.user.id, id=pk)
except (TypeError, ValueError, OverflowError, TODOList.DoesNotExist):
return Response('', status.HTTP_403_FORBIDDEN)
paragraphs = []
for task in todolist.task_set.all().order_by('deadline'):
paragraphs.append(
f'{task.title}, done: {task.done}, deadline: {task.deadline}')
html_string = render_to_string('todo_list_report.html',
{'paragraphs': paragraphs})
html = HTML(string=html_string)
html.write_pdf(target=f'/tmp/{todolist.title}.pdf')
fs = FileSystemStorage('/tmp')
with fs.open(f'{todolist.title}.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="{todolist.title}-{str(datetime.now())}.pdf"'
return response
return response
def relatorio_padrao_grupo(request, pk):
if pk is 12 and not request.user.has_perm('rol.add_ata'):
return HttpResponse('GRUPO RESTRITO AO CONSELHO')
else:
grupo = TipoGrupo.objects.get(pk=pk)
if request.user.has_perm('rol.add_ata'):
turmas = TurmaFrequencia.objects.filter(tipo_grupo_id=pk)
else:
turmas = TurmaFrequencia.objects.filter(tipo_grupo_id=pk).filter(
restrito=False)
turmas_grupo = []
for turma in turmas:
turma.lista_participantes = turma.participantes.all()
turma.lista_lideranca = turma.lideranca.all()
turmas_grupo.append(turma)
tipo = "grupo" + str(pk)
html_string = render_to_string(
'../templates/relatorio_padrao_grupo.html', {
'turmas': turmas_grupo,
'titulo': grupo.nome
})
html = HTML(string=html_string)
html.write_pdf(target=tipo + '.pdf')
fs = FileSystemStorage('./')
with fs.open(tipo + '.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="' + tipo + '.pdf"'
return response
return response
def get(request):
date = request.GET.get('date')
if not date:
return json_error('You must specify date')
date = datetime.datetime.strptime(date, "%Y-%m-%d").date()
doctor_id = request.GET.get('doctor')
if not doctor_id:
return json_error('You must specify doctor')
try:
doctor = UserProfile.objects.get(pk=doctor_id)
except UserProfile.DoesNotExist:
return json_error('You must specify id of existing doctor')
create_visit_for_doctor(doctor, date)
visits = Visit.objects.filter(doctor=doctor, start_date__date=date).order_by('start_date')
visit_serializer = VisitSerializer(visits, many=True, context={'user': request.user})
if request.GET.get('export', False):
context = {
'visits': visit_serializer.data,
'doctor': doctor,
'date': date
}
html = render_to_string('export.html', context=context)
html_document = HTML(string=html)
pdf_buffer = BytesIO()
html_document.write_pdf(pdf_buffer)
response = HttpResponse(pdf_buffer.getvalue(), content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="report_%s_%s.pdf"' % (doctor.get_full_name(),
date.strftime("%d %b %Y"))
return response
return JsonResponse(visit_serializer.data, safe=False)
def html_to_pdf_view(request):
request.LANG = getattr(settings, 'LANGUAGE_CODE', settings.LANGUAGE_CODE)
translation.activate(request.LANG)
from django.core.files.storage import FileSystemStorage
from django.http import HttpResponse
from django.template.loader import render_to_string
from weasyprint import HTML
invoice = cache.get('invoice')
inv_details = cache.get('inv_details')
invoice = get_object_or_404(Invoice, invoice_number="INV-00005")
inv_details = Invoice_details.objects.filter(invoicenumber="INV-00005")
context = {'invoice': invoice, 'inv_details': inv_details}
paragraphs = {'invoice': invoice, 'inv_details': inv_details}
html_string = render_to_string('project/invoice_print.html', context)
html = HTML(string=html_string)
html.write_pdf(target='/tmp/mypdf.pdf')
fs = FileSystemStorage('/tmp')
with fs.open('mypdf.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="mypdf.pdf"'
return response
return response
def Bill_pdf_view(request):
data = Order.objects.filter(user=request.user).latest('id')
u = data.user_id
users = UserProfile.objects.get(user_id=u)
list = data.item
itemName = []
itemprice = []
for item in list:
# print(item)
menu = Menu.objects.get(id=item)
# print(menu)
# print(menu.item_name)
itemName.append(menu.item_name)
itemprice.append(menu.price)
context = {
'orders': data,
'users': users,
'menu': itemName,
'menus': itemprice
}
html_string = render_to_string('Bill_pdf.html', context)
html = HTML(string=html_string)
html.write_pdf(target='Bill_pdf.pdf')
fs = FileSystemStorage('')
with fs.open('Bill_pdf.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attatchment; filename="Bill_pdf.pdf"'
return response
return response
def makeReport(name, links, preds, instnames):
#sort
links = sorted(links)
preds = sorted(preds)
instnames = sorted(instnames)
name = name.strip()
name = name.replace('%20', '-')
with open('./report/template.html', 'r') as f:
template_data = f.read()
template_data = template_data.replace('{{INPUT_NAME}}', name)
links_str = ""
for l in links:
links_str += "<li>"
links_str += '<a href="{0}">{0}</a>'.format(l)
links_str += "</li>"
template_data = template_data.replace('{{SOCIAL_URLS}}', links_str)
preds_str = ""
for p in preds:
preds_str += "<li>"
preds_str += p
preds_str += "</li>"
template_data = template_data.replace('{{GOOGLE_PREDS}}', preds_str)
insta_str = ""
for i in instnames:
insta_str += "<li>"
insta_str += '<a href="https://www.instagram.com/{0}">https://instagram.com/{0}</a>'.format(
i)
insta_str += "</li>"
template_data = template_data.replace('{{INSTA_PROFILES}}', insta_str)
with open('tmp.html', 'w') as t:
t.write(template_data)
doc = HTML('tmp.html')
doc.write_pdf('{0}_Report.pdf'.format(name))
os.remove('tmp.html')
def savePDF(self, pdf_filename, parent_soup, target_node, yes_phrase, url, key, school_name):
if target_node:
grandparent_node = target_node.parent.parent
tag = self.highlightedNode(target_node, yes_phrase, parent_soup)
self.replaceNode(target_node, tag)
body = Tag(parent_soup,"body")
body.append(grandparent_node)
else:
body = parent_soup
try:
weasyprint = HTML(string=body.prettify())
tmp_filename = 'pdfs/tmp.pdf'
weasyprint.write_pdf(tmp_filename,stylesheets=[CSS(string='body { font-size: 10px; font-family: serif !important }')])
except:
print "weasyprint failed on url: "+url
if target_node:
self.replaceNode(tag, target_node) #return to old state
return
if target_node:
self.replaceNode(tag, target_node) #return to old state
sep_filename = "pdfs/sep.pdf"
self.makeSepPage(sep_filename, url, key, school_name)
merger = PdfFileMerger()
if (os.path.exists(pdf_filename)):
merger.append(PdfFileReader(file(pdf_filename, 'rb')))
merger.append(PdfFileReader(file(sep_filename, 'rb')))
merger.append(PdfFileReader(file(tmp_filename, 'rb')))
merger.write(pdf_filename)
def generate_pdf(prefix, data):
template = get_template(app_settings.BATCH_PDF_TEMPLATE)
html = HTML(string=template.render(data))
f = open(f'/tmp/{prefix}.pdf', 'w+b')
html.write_pdf(target=f)
f.seek(0)
return File(f)
def pdf_print(request, requisition_id):
"""Exports the requisition in PDF."""
# Selecting the requisition
requisition = get_object_or_404(models.Requisition, pk=requisition_id)
rendered = render_to_response('purchase/requisition_report.html', {
'vessel': Vessel.objects.latest('id'),
'title': _("Requisition"),
'user': request.user,
'requisition': requisition,
'today': datetime.date.today(),
},
context_instance=RequestContext(request))
# Creating the response
filename = "pharmaship_requisition_{0}.pdf".format(requisition.reference)
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="{0}"'.format(filename)
# Converting it into PDF
html = HTML(string=rendered.content,
base_url=request.build_absolute_uri()
)
html.write_pdf(response,
stylesheets=[
CSS(settings.BASE_DIR + '/purchase/static/css/purchase/report.css')
])
return response
def pdf_generation_supervisor(request, form_info, t_form_info):
html_string = render_to_string('track/pdf-output.html', {
'form': form_info,
't_form': t_form_info,
})
html = HTML(string=html_string, base_url=request.build_absolute_uri())
html.write_pdf(target='report.pdf')
def md2pdf(pdf_file_path, md_content=None, md_file_path=None,
css_file_path=None, base_url=None):
"""
Convert markdown file to pdf with styles
"""
# Convert markdown to html
raw_html = ""
extras = ["cuddled-lists"]
if md_file_path:
raw_html = markdown_path(md_file_path, extras=extras)
elif md_content:
raw_html = markdown(md_content, extras=extras)
if not len(raw_html):
raise ValidationError('Input markdown seems empty')
# Weasyprint HTML object
html = HTML(string=raw_html, base_url=base_url)
# Get styles
css = []
if css_file_path:
css.append(CSS(filename=css_file_path))
# Generate PDF
html.write_pdf(pdf_file_path, stylesheets=css)
return
def pdf(obj, path, site_url=None):
activate(obj.language_code) # required if called from command line
# first page
header_url = urljoin(
site_url,
reverse('activities:print-preview-header', kwargs={
'code': obj.code,
}))
header_html_source = url_read(header_url)
header = HTML(string=header_html_source, base_url=site_url).render()
# other pages
content_url = urljoin(
site_url,
reverse('activities:print-preview-content',
kwargs={
'code': obj.code,
}))
content_html_source = url_read(content_url)
content = HTML(string=content_html_source, base_url=site_url).render()
header.pages += content.pages
header.write_pdf(path)
def generate_pdf(request, id):
hasil = RekamMedis.objects.all().select_related(
'idpendaftaran', 'idantrian').filter(id=id).order_by('created_on')
print(hasil.get().idpendaftaran.norm.norm)
pesanobat = PemesananObat.objects.all().filter(idrm=id)
biayadokter = BiayaPemeriksaan.objects.all()[:1].get()
totalobat = 0
for i in pesanobat:
totalobat += i.subtotal_obat
harusbayar = biayadokter.biaya_pemeriksaan + totalobat
uangnya = Pembayaran.objects.all().filter(idpendaftaran=id).get()
data = {
'totalobat': totalobat,
'biayadokter': biayadokter.biaya_pemeriksaan,
'pesanan': pesanobat,
'nonota': id,
'data': hasil.get(),
'namaakun': request.session['namapegawai'],
'total': harusbayar,
'uang': uangnya,
'kembalian': uangnya.uang_dibayarkan - harusbayar
}
html_string = render_to_string('hal_admin/pegawaiadmin/pdf/bayar.html',
data)
html = HTML(string=html_string)
html.write_pdf(target='/tmp/mypdf.pdf')
fs = FileSystemStorage('/tmp')
with fs.open('mypdf.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
# response['Content-Disposition'] = 'attachment; filename="mypdf.pdf"'
return response
return response
def generate_pdf(url, context, ignore_context=False):
"""
Builds a PDF of the passed in url.
The URL is fetched relative to the context, unless ignore_context is True
"""
request = getattr(context, "REQUEST", None)
base_url = context.getParentDatabase().absolute_url()
# Use subrequest to access the passed in url
if ignore_context:
page = subrequest(url)
else:
page = subrequest(url, root=context)
# Transform the html
# Have to set the content-type header to text/html before we can transform
actual_header = request.response.getHeader('Content-Type')
request.response.setHeader('Content-Type', 'text/html')
html = transform_html(page.getBody(), request)
request.response.setHeader('Content-Type', actual_header)
pdf = HTML(string=html, base_url=base_url, url_fetcher=my_fetcher)
output = StringIO()
pdf.write_pdf(output)
output.seek(0)
return output
def payroll_report_export_pdf(request, **kwargs):
context = {
'business': kwargs.get('business'),
'takehome_total': kwargs.get('takehome_total'),
'takehome': kwargs.get('takehome'),
'wcf': kwargs.get('wcf'),
'nssf': kwargs.get('nssf'),
'loan_board': kwargs.get('loan_board'),
'paye': kwargs.get('paye'),
'bonus': kwargs.get('bonus'),
'overtime': kwargs.get('overtime'),
'salaries_total': kwargs.get('salaries_total'),
'total_expenses': kwargs.get('total_expenses'),
'employees': kwargs.get('employees'),
'deduction': kwargs.get('deduction'),
'sdl': kwargs.get('sdl')
}
html_string = render_to_string('payroll-report-pdf.html', context)
html = HTML(string=html_string, base_url=request.build_absolute_uri())
html.write_pdf(target='/tmp/payroll_report.pdf')
fs = FileSystemStorage('/tmp')
with fs.open('payroll_report.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
return response
def download_pdf(story, output='', message=True):
""" Download a story to pdf.
:type message: bool
"""
if output == '':
output = _get_download_name(story)
output = _add_extension(output, 'pdf')
if message:
print 'Downloading \'%s\' to %s...' % (story.title, output)
html = ''
for chapter in story.get_chapters():
if message:
print 'Adding %s...' % (chapter.title)
html += '<h2>Chapter %d: %s</h2>' % (chapter.number, chapter.title)
html += chapter.raw_text
html += '</br>' * 10
if message:
print 'Compiling PDF...'
# This turned out not to work on the command line as it needed an X interface.
#pdfkit.from_string(html, output)
# Instead trying with weasyprint
content = unicode(html.strip(codecs.BOM_UTF8), 'utf-8')
h = HTML(content)
h.write_pdf(output)
def printpdf(self, filepath):
app_path = os.path.abspath(os.path.dirname(__file__))
path = Path(app_path)
parentpath = str(path.parent)
env_path = os.path.join(parentpath, 'data', 'html')
css_path = os.path.join(env_path, 'style.css')
env = Environment(loader=FileSystemLoader(env_path))
template = env.get_template('column_report.html')
if self.__corrected:
status = 'Applied'
null_replaced = 'have been'
else:
status = 'Suggested'
null_replaced = 'will be'
template_vars = {
'cname': self.qcfield.name,
'gen_stat_table': tupples2table(self.prettygeneral.items()),
'stat_table': tupples2table(self.prettystats.items()),
'status': status,
'null_replaced': null_replaced,
'dcorrections_table': tupples2table(self.dcorrections),
'ccorrections_table': tupples2table(self.ccorrections),
'removed_values': list2parag(self.cnulls | self.dnulls),
}
html_out = template.render(template_vars)
document = HTML(string=html_out).render(stylesheets=[css_path])
document.write_pdf(target=filepath)
def printPdf(request, filename, queryset, template):
html_string = render_to_string('{template}'.format(template=template),
{'entities': queryset})
html = HTML(string=html_string, base_url=request.build_absolute_uri())
filename = '{filename}-{date}'.format(
date=datetime.now().strftime('%Y-%m-%d'),
filename=filename,
)
html.write_pdf(
target='/tmp/{filename}.pdf'.format(filename=filename),
stylesheets=[CSS(settings.STATIC_ROOT + '/css/print.css')],
# presentational_hints=True
)
fs = FileSystemStorage('/tmp')
with fs.open('{filename}.pdf'.format(filename=filename)) as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="{filename}.pdf"'.format(
filename=filename)
return response
return response
def envia_pdf(request, id, destinatario):
questionario = Questionario.objects.get(id=id)
titulo = questionario.titulo
titulo_formatado = slugify(titulo)
perguntas = Pergunta.objects.filter(questionario=questionario).distinct()
context = {
'questionario': questionario,
'perguntas': perguntas,
}
html_string = render_to_string('core/template_pdf.html', context)
html = HTML(string=html_string)
html.write_pdf(target='detalhes-{}.pdf'.format(titulo_formatado))
fs = FileSystemStorage('/tmp')
with fs.open('detalhes-{}.pdf'.format(titulo_formatado)) as pdf:
arquivo = pdf.read()
response = HttpResponse(arquivo, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="detalhes-{}.pdf"'.format(
titulo_formatado)
email = EmailMessage(
subject=f'Detalhes { questionario.titulo }',
body=
f'Email enviado com o relatório do { questionario.titulo } anexo',
to=[destinatario],
)
email.attach_file('/tmp/detalhes-{}.pdf'.format(titulo_formatado))
email.send()
def make_book(self, filename, config):
#QtGui.QMessageBox.critical(None, "Network Error","make_book")
with tempfile.TemporaryDirectory(prefix="pySpellbook-") as tempdir:
temphtml = tempfile.NamedTemporaryFile(dir=tempdir, delete=False, suffix=".html", mode="w")
temphtml.write(self.rendered)
#QtGui.QMessageBox.critical(None, "Network Error","wrote html")
tmpname = temphtml.name
temphtml.close()
#QtGui.QMessageBox.critical(None, "Network Error",tmpname)
#os.mkdir(os.path.join(tempdir, "resources"))
#for r in self.resourcelist:
# shutil.copy(r, os.path.join(tempdir,"resources"))
if config['backend'] == 'prince':
os.system("\"%s\" %s -o %s" % (config['prince_path'], tmpname, filename))
elif config['backend'] == 'HTML':
shutil.copy(os.path.join(tempdir, tmpname), filename)
webbrowser.open_new_tab("file:///%s" % filename)
elif config['backend'] == 'custom':
custom_command = config['custom'].replace("$INPUT", temphtml).replace("$OUTPUT", filename)
shutil.copy(custom_command)
else:
if weasy:
html = HTML("file://%s" % tmpname)
html.write_pdf(target=filename)
else:
import pySpellbook.qtpdf
os.chdir(tempdir)
printer = pySpellbook.qtpdf.Printer(self.parent)
printer.load(tmpname)
printer.print(filename)
def create_and_save_doc(document_data, index_html, output_pdf):
"""
Creates a PDF invoice by filling an HTML template with a YML file.
Parameters
----------
document_data : dict
Data to use for filling the HTML template.
index_html : str
Absolute path to html template file.
output_pdf : str
Name of the output PDF file.
Returns
-------
Saves the output PDF to output/ directory
"""
pos_number = 1
document_data['totals'] = {'net': 0, 'gross': 0, 'tax': 0}
for pos in document_data['positions']:
if not 'tax_rate' in pos:
pos['tax_rate'] = document_data['tax_rate']
pos['pos_number'] = pos_number
pos['total_net_price'] = pos['net_price'] * pos['amount']
pos['total_tax'] = \
pos['total_net_price'] * (pos['tax_rate'] / float(100))
pos['total_gross_price'] = pos['total_net_price'] + pos['total_tax']
document_data['totals']['net'] += pos['total_net_price']
document_data['totals']['gross'] += pos['total_gross_price']
document_data['totals']['tax'] += pos['total_tax']
pos['amount'] = locale.format_string("%.2f", pos['amount'])
pos['tax_rate'] = locale.format_string("%.2f", pos['tax_rate'])
pos['net_price'] = locale.format_string("%.2f", pos['net_price'])
pos['total_net_price'] = \
locale.format_string("%.2f", pos['total_net_price'])
pos['text'] = pos['text'].replace('\n', '<br>')
pos_number += 1
document_data['totals']['net'] = \
locale.format_string("%.2f", document_data['totals']['net'])
document_data['totals']['gross'] = \
locale.format_string("%.2f", document_data['totals']['gross'])
document_data['totals']['tax'] = \
locale.format_string("%.2f", document_data['totals']['tax'])
with codecs.open(index_html, encoding="utf-8") as index_file:
html_text = index_file.read()
compiler = Compiler()
template = compiler.compile(html_text)
html_text = template(document_data)
weasytemplate = HTML(string=html_text)
weasytemplate.write_pdf(os.path.join('/app', 'output', output_pdf))
return
def render_pdf():
with open(index_html, encoding="utf-8") as index_file:
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template(index_html)
html_text = template.render(document_data)
weasytemplate = HTML(string=html_text, base_url=base_url)
weasytemplate.write_pdf(output_pdf)
def pdf(self, text=TEXT):
""" Generate a PDF file from the report data. """
self.logger.debug("Generating the PDF report...")
html = HTML(string=self.html())
css_file = self.css or join(dirname(abspath(__file__)),
"{}.css".format(self.theme))
css = [css_file, CSS(string=PAGE_CSS % self.__dict__)]
html.write_pdf("{}.pdf".format(self.filename), stylesheets=css)
def convert_rst(self, output_path):
rst_file = self.read_file_to_bytes()
html_code = core.publish_string(source=rst_file,
writer_name='html').decode()
result = html_code[html_code.find('<body>') +
6:html_code.find('</body>')].strip()
html = HTML(string=result)
html.write_pdf(output_path, )
def generate_invoice_pdf(data):
file_path = os.path.join(settings.MEDIA_ROOT, 'static', 'invoice')
html_string = render_to_string('invoice_pdf.html', data)
html = HTML(string=html_string)
file_path = f'{file_path}/invoice.pdf'
html.write_pdf(target=file_path)
print(file_path)
return file_path
def getAllBooks1PDF(self):
fn = self.getAllBooks1HTML()
if fn:
html = HTML(fn, encoding='utf8')
css = CSS(string='body { font-family: "Microsoft YaHei" }')
fnOut = '%s.pdf' % BOT_NAME
html.write_pdf(fnOut, stylesheets=[css])
return fnOut
def getBookPDF(self, name):
fn = self.getBookHTML(name)
if fn:
html = HTML(fn, encoding='utf8')
css = CSS(string='body { font-family: "Microsoft YaHei" }')
fnOut = '%s.pdf' % name
html.write_pdf(fnOut, stylesheets=[css])
return fnOut
def writepdf(file_data):
global global_root_dir, image_base
font_config = FontConfiguration()
css = read_css()
image_base_url()
html = HTML(string=file_data, base_url=image_base, encoding="utf8")
# print(css)
html.write_pdf(filename + '.pdf', stylesheets=css, font_config=font_config)
def generate_pdf(template, data, filename):
template_rendered = render_template(template, data=data)
html_file = HTML(string=template_rendered,
base_url=current_app.config['API_ENDPOINT'],
encoding="utf-8")
file_abs_path = str(BACKEND_DIR) + "/static/pdf/" + filename
html_file.write_pdf(file_abs_path)
return file_abs_path
def convert_html_to_pdf(html_path, output_path, encoding='utf-8'):
try:
html = HTML(html_path, encoding=encoding)
html.write_pdf(output_path)
return True
except Exception as e:
print("exception occurred: {}".format(str(e)))
return False
def pdf(obj, path, site_url=None):
activate(obj.language_code) # required if called from command line
url = urljoin(site_url,
reverse('scoops:print-preview', kwargs={
'code': obj.code,
}))
html_source = url_read(url)
html_obj = HTML(string=html_source, base_url=site_url).render()
html_obj.write_pdf(path)
def raport_to_pdf_view(self, request, surveys, today):
html_string = render_to_string('pdf_template.html', {
'surveys': surveys,
'today': today
})
html = HTML(string=html_string)
html.write_pdf(target='media/pdf_report/survey_report.pdf',
stylesheets=[CSS('survey/static/css/PDFstyle.css')])
def generate_pdf(self):
''' renders html from file with given context and creates pdf file from it
'''
html_string = Template(self.template.template.read()).render(Context(json.loads(self.content)))
html = HTML(string=html_string, base_url='')
filename = self.name.replace('/', '.') + '.pdf'
buffer = BytesIO()
html.write_pdf(target=buffer)
pdf = buffer.getvalue()
buffer.close()
self.file.save(filename, ContentFile(pdf))
def make_pdf(config, data):
"""
Generate PDF file out of generated 'index.html' page.
"""
from weasyprint import HTML
output_dir = config.get('output_dir', 'build')
output_file = os.path.join(output_dir, config.get('pdf_file', 'resume.pdf'))
input_file = os.path.join(output_dir, 'index.html')
theme_location = os.path.join('themes', config['theme'])
html = HTML(input_file, base_url=theme_location)
html.write_pdf(output_file)
def print_order(orders, name, phone):
template = env.get_template('template.md')
total = sum(order.price for order in orders)
md = template.render(name=name, phone=phone, orders=orders, total=total)
html = markdown.markdown(md, extensions=['markdown.extensions.tables'])
document = HTML(string=html)
tmp = tempfile.NamedTemporaryFile(mode='wb', suffix='.pdf')
document.write_pdf(tmp, stylesheets=[CSS(filename='order-style.css')])
return tmp
def render_to_pdf(template_name, pdf_filename=None, template_values=None, css_sheets=None):
context_extras = {'LANGUAGES': settings.LANGUAGES, 'LANGUAGE_CODE': translation.get_language(),
'LANGUAGE_BIDI': translation.get_language_bidi()}
template_values.update(context_extras)
html_content = render_to_string(template_name, template_values or {})
css_objs = [CSS(filename=finders.find(x)) for x in css_sheets] if css_sheets else []
html_obj = HTML(string=html_content)
if pdf_filename is None:
with tempfile.NamedTemporaryFile() as n:
pdf_filename = n.name
html_obj.write_pdf(pdf_filename, stylesheets=css_objs)
return pdf_filename
def createPdf(htmlreport, outfile=None, css=None, images={}):
"""create a PDF from some HTML.
htmlreport: rendered html
outfile: pdf filename; if supplied, caller is responsible for creating
and removing it.
css: remote URL of css file to download
images: A dictionary containing possible URLs (keys) and local filenames
(values) with which they may to be replaced during rendering.
# WeasyPrint will attempt to retrieve images directly from the URL
# referenced in the HTML report, which may refer back to a single-threaded
# (and currently occupied) zeoclient, hanging it. All image source
# URL's referenced in htmlreport should be local files.
"""
# A list of files that should be removed after PDF is written
cleanup = []
css_def = ''
if css:
if css.startswith("http://") or css.startswith("https://"):
# Download css file in temp dir
u = urllib2.urlopen(css)
_cssfile = tempfile.mktemp(suffix='.css')
localFile = open(_cssfile, 'w')
localFile.write(u.read())
localFile.close()
cleanup.append(_cssfile)
else:
_cssfile = css
cssfile = open(_cssfile, 'r')
css_def = cssfile.read()
htmlreport = to_utf8(htmlreport)
for (key, val) in images.items():
htmlreport = htmlreport.replace(key, val)
# render
htmlreport = to_utf8(htmlreport)
renderer = HTML(string=htmlreport, encoding='utf-8')
pdf_fn = outfile if outfile else tempfile.mktemp(suffix=".pdf")
if css:
renderer.write_pdf(pdf_fn, stylesheets=[CSS(string=css_def)])
else:
renderer.write_pdf(pdf_fn)
# return file data
pdf_data = open(pdf_fn, "rb").read()
if outfile is None:
os.remove(pdf_fn)
for fn in cleanup:
os.remove(fn)
return pdf_data
def _get_pdf(self, markup):
logger = logging.getLogger(__name__)
base_url = self.base_url if self.base_url else ''
pdf_file = StringIO.StringIO()
logger.info("Creating weasy")
weasy = HTML(
file_obj=StringIO.StringIO(markup.encode("UTF-8")),
encoding='UTF-8',
base_url=base_url,
url_fetcher=self._url_fetcher
)
logger.info("Starting pdf generation")
weasy.write_pdf(pdf_file)
logger.info("PDF generated, returning")
return pdf_file.getvalue()
def execute(self, id_user, id_meeting):
render = RenderHtml(id_user, id_meeting, self.__dirToProject)
value = render.split_question_on_pages()
with codecs.open(self.__dir, 'w', 'utf8') as f2:
f2.write(value)
pdf = HTML(self.__dir)
newName = str(id_user) + str(id_meeting) + self.__file_name
pdf.write_pdf(self.__result_dir + newName)
res = []
res.append(newName)
res.append(self.__result_dir)
return res
def render():
html = request.args['html']
assert html.strip()
if html:
assert 'fuu' not in html
# Save the input HTML
with open(INPUT, 'w') as fd:
fd.write(html.encode('utf-8'))
html = HTML(INPUT, encoding='utf8')
html.write_pdf(PDF_OUTPUT)
html.write_png(PNG_OUTPUT)
return send_file(PNG_OUTPUT, cache_timeout=0)
def pdf(obj, path, site_url=None):
activate(obj.language_code) # required if called from command line
# first page
header_url = urljoin(site_url, reverse('activities:print-preview-header', kwargs={'code': obj.code, }))
header_html_source = url_read(header_url)
header = HTML(string=header_html_source, base_url=site_url).render()
# other pages
content_url = urljoin(site_url, reverse('activities:print-preview-content', kwargs={'code': obj.code, }))
content_html_source = url_read(content_url)
content = HTML(string=content_html_source, base_url=site_url).render()
header.pages += content.pages
header.write_pdf(path)
def export_schedule_to_pdf(request, callgroup):
from weasyprint import HTML
context = get_context(request)
context['site'] = callgroup.description
month, year = int(request.GET.get('month', 1)), int(request.GET.get('year', 9999))
weekstart = int(request.GET.get('weekstart', 0))
monthstart = datetime.date(year, month, day=1)
context['month'] = monthstart.strftime("%B %Y")
monthstart = monthstart - datetime.timedelta(days=monthstart.day - 1)
# make sure we start on a sunday (or monday if weekstart=1)
monthstart = monthstart - datetime.timedelta(days=(monthstart.isoweekday() % 7)) + \
datetime.timedelta(weekstart)
user = request.session['MHL_Users']['MHLUser']
context['weeks'] = generateOnCallList(callgroup, monthstart, weekstart, user)
context['days'] = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
for _ in range(weekstart):
context['days'].append(context['days'].pop(0))
# load template with context and static root for pdf renderer, generate pdf buffer
static_root = settings.STATICFILES_DIRS[0]
html = render_to_string('pdf_schedule.html', {'STATIC_ROOT': static_root}, context)
weasyhtml = HTML(string=html)
schedcss = join(static_root, 'css', 'pdf_schedule.css')
pdf = weasyhtml.write_pdf(stylesheets=[schedcss]) # ,target='/tmp/test.pdf')
# prepare response, append &nopdf to GET url for test
response = HttpResponse(pdf, mimetype="application/pdf")
response["Cache-Control"] = "no-cache"
response["Accept-Ranges"] = "none"
response["Content-Disposition"] = "attachment; filename=schedule-%d-%d.pdf" % (year, month)
return response if 'nopdf' not in request.GET else \
render_to_response("pdf_schedule.html", context)
def main():
submissions = {}
submissions_path = get_submissions_path(app.root_path)
for submission_pkl in sorted(glob.glob(os.path.join(submissions_path, '*.pkl'))):
with open(submission_pkl, 'rb') as submission_file:
submission = cPickle.loads(submission_file.read())
submissions[submission['student_email']] = submission
os.unlink(submission_pkl)
for s in submissions.values():
weasy = HTML(string=s['receipt'])
pdf_path = os.path.join(submissions_path, s['student_name'] + ".pdf")
weasy.write_pdf(pdf_path)
response = send_welcome_mail(s, pdf_path)
print "Response " + str(response.status_code) + " for " + s['student_name'] + " - ",
print response.json()
os.unlink(pdf_path)
def execute(self, id_user, id_meeting, css=None, qs=None):
render = RenderHtml(id_user, id_meeting, self.__dirToProject, css=css, qs=qs)
value = render.render_doc()
with codecs.open(self.__dir, 'w', 'utf8') as file:
file.write(value)
pdf = HTML(self.__dir)
newName = str(id_user) + str(id_meeting) + self.__file_name
pdf.write_pdf(self.__result_dir + newName)
res = []
res.append(newName)
res.append(self.__result_dir)
return res
def savePDFURL(self, pdf_filename, soup, url, keys, school_name):
try:
weasyprint = HTML(string=soup.prettify())
tmp_filename = 'pdfs/tmp.pdf'
weasyprint.write_pdf(tmp_filename,stylesheets=[CSS(string='body { font-size: 10px; font-family: serif !important }')])
except:
print "weasyprint failed on url: "+url
return
sep_filename = "pdfs/sep.pdf"
self.makeSepPageURL(sep_filename, url, keys, school_name)
merger = PdfFileMerger()
if (os.path.exists(pdf_filename)):
merger.append(PdfFileReader(file(pdf_filename, 'rb')))
merger.append(PdfFileReader(file(sep_filename, 'rb')))
merger.append(PdfFileReader(file(tmp_filename, 'rb')))
merger.write(pdf_filename)
def process_IN_CREATE(self, event):
if event.pathname.endswith(".html"):
print "Creating:", event.pathname
print "Loading file"
wprint = HTML(filename=event.pathname)
print "writing thumbnail"
wprint.write_png(event.pathname.replace(".html", "_thumbnail.png")+".partial", resolution=10)
print "writing pdf"
wprint.write_pdf(event.pathname.replace(".html", ".pdf")+".partial")
print "writing png"
wprint.write_png(event.pathname.replace(".html", ".png")+".partial", resolution=300)
# Remove the ".partial" to indicate that it's done generating both.
for suffix in ('.pdf', '.png', '_thumbnail.png'):
dest = event.pathname.replace(".html", suffix)
src = dest + ".partial"
os.rename(src, dest)
def generate():
name = request.args.get('filename', 'unnamed.pdf')
app.logger.info('POST /pdf?filename=%s' % name)
html = HTML(string=request.data)
pdf = html.write_pdf()
response = make_response(pdf)
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = 'inline;filename=%s' % name
app.logger.info(' ==> POST /pdf?filename=%s ok' % name)
return response
def md2pdf(pdf_file_path, md_content=None, md_file_path=None,
css_file_path=None, base_url=None):
"""
Converts input markdown to styled HTML and renders it to a PDF file.
Args:
pdf_file_path: output PDF file path.
md_content: input markdown raw string content.
md_file_path: input markdown file path.
css_file_path: input styles path (CSS).
base_url: absolute base path for markdown linked content (as images).
Returns:
None
Raises:
ValidationError: if md_content and md_file_path are empty.
"""
# Convert markdown to html
raw_html = ''
extras = ['cuddled-lists', 'tables']
if md_file_path:
raw_html = markdown_path(md_file_path, extras=extras)
elif md_content:
raw_html = markdown(md_content, extras=extras)
if not len(raw_html):
raise ValidationError('Input markdown seems empty')
# Weasyprint HTML object
html = HTML(string=raw_html, base_url=base_url)
# Get styles
css = []
if css_file_path:
css.append(CSS(filename=css_file_path))
# Generate PDF
html.write_pdf(pdf_file_path, stylesheets=css)
return
def create_pdf(username, totals):
"""Test out functionality."""
html = HTML(string='<body width="600px"><div class="top"><br /><br /><h4>SPRY Report</h4><p>Data about <b>{}</b></p></div>\
<div><img class="insta" src="./{}.jpg"/></div\
<div>Total accounts found: {}</div></body>'.format(username, username, totals))
css = CSS(string='''
.top { text-align: center; border-bottom: 2px dashed deepskyblue; padding: 5px; }
p { font-family: mono; font-size: 12px; }
h2,h3,h4 { font-family: "Andale Mono"; font-size: 14px; }
ul,li { font-family: "Andale Mono"; font-size: 11px; letter-spacing: 0.08em; }
ul { list-style: none; }
ul { width: 500px; margin-bottom: 20px; border-top: 1px solid #ccc; }
li { border-bottom: 1px solid #ccc; float: left; display: inline;}
#double li { width:50%;}
#triple li { width:33.333%; }
#six li { width:16.666%; }
#quad li { width:25%; }
''')
html.write_pdf(
'{}-report.pdf'.format(username), stylesheets=[css])
def pdf(first_name,last_name):
theme = Themes.query.filter_by(first_name=first_name).filter_by(last_name=last_name).first()
if theme:
htmlcontent = theme.html_content
css = theme.css_content
user = UserProfile.query.filter_by(first_name=first_name).filter_by(last_name=last_name).first()
if user:
positions = Positions.query.filter_by(user_id=user.user_id).all()
educations = Education.query.filter_by(user_id=user.user_id).all()
certifications = Certifications.query.filter_by(user_id=user.user_id).all()
if htmlcontent:
content = render_template_string(htmlcontent,first_name=first_name,last_name=last_name,
user=user,positions=positions,educations=educations,
certifications=certifications)
print 'Saved content'
else:
content = render_template('basictheme.html',
user=user,positions=positions,educations=educations,
certifications=certifications)
data = render_template('resume.html',theme=content,themestyle=css,first_name=first_name,last_name=last_name)
html = HTML(string=data)
css_file = file('print.css','r')
css_content = css_file.read()
css_content = css_content % (first_name+'.'+last_name+'s CV')
css = CSS(string=css_content)
output_file = '/tmp/cv.pdf'
if os.path.exists(output_file):
os.remove(output_file)
html.write_pdf(output_file,stylesheets=[css])
content = file(output_file).read()
print 'PDF Generated at %s'%output_file
return Response(content,
mimetype="application/pdf",
headers={"Content-Disposition":
"attachment;filename=resume.pdf"})
def __call__(self, REQUEST, RESPONSE):
content = super(ExportaMinutaPDFView, self).__call__(self)
portal_url = api.portal.get().absolute_url()
base_url = '{0}/++resource++smdu.participacao/'.format(portal_url)
html = HTML(string=content, base_url=base_url)
stylesheets = []
with open('src/smdu/participacao/browser/static/css/print.css', 'r') as css:
stylesheets.append(CSS(string=css.read()))
minuta_exportada_pdf = html.write_pdf(stylesheets=stylesheets)
RESPONSE.setHeader('Content-Type', 'application/pdf; charset=utf-8')
RESPONSE.setHeader('Content-Length', len(minuta_exportada_pdf))
RESPONSE.setHeader('Content-Disposition', 'attachment; filename="Relatorio.pdf"')
return minuta_exportada_pdf
def form_valid(self, form):
self.post_data = self.request.POST
if 'download' in self.post_data:
html = self.render_to_response(self.get_context_data(form=form))
f = open(os.path.join(
os.path.dirname(__file__), './static/payslip/css/payslip.css'))
html = HTML(string=html.render().content)
pdf = html.write_pdf(stylesheets=[CSS(string=f.read())])
f.close()
resp = HttpResponse(pdf, content_type='application/pdf')
resp['Content-Disposition'] = \
u'attachment; filename="{}_{}.pdf"'.format(
self.date_start.year, self.date_start.month)
return resp
return self.render_to_response(self.get_context_data(form=form))
def generate_pdf(refer, request, context):
"""
generate_pdf
:param refer: Refer info
:type refer: TODO
:param request: The request info
:type request: django.core.handlers.wsgi.WSGIRequest
:param context: context
:type context: TODO
:returns: None -- Creates PDF file in refer/pdf directory
"""
try:
from weasyprint import HTML
# path contains leading / so use string join instead of path join
img = ''.join([settings.INSTALLATION_PATH, context['current_practice_photo']])
html = render_to_string('DoctorCom/Messaging/PreviewDialog.html',
{'pdf': True, 'practice_photo_path': img}, context)
htmlobj = HTML(string=html)
pdf = htmlobj.write_pdf()
encrypted_data = refer.encrypt_file(request, pdf)
refer_pdf = '%s/refer/pdf' % (settings.MEDIA_ROOT,)
if not os.path.exists(refer_pdf):
os.makedirs(refer_pdf)
f = create_file('refer/pdf/%s' % refer.uuid)
f.set_contents(encrypted_data)
f.close()
except IOError as e:
err_email_body = '\n'.join([
('PDF folder not exist!'),
''.join(['Server: ', settings.SERVER_ADDRESS]),
''.join(['Session: ', str(request.session.session_key)]),
''.join(['Message: ', (u'PDF folder not exist: media/refer/pdf')]),
''.join(['Exception: ', str(e)]),
''.join(['Exception data: ', str(e.args)]),
])
mail_admins('PDF folder not exist', err_email_body)
def asPDF(html, header=None, water=None, images=None):
"""
Renders an html as PDF.
Uses the "report.css" as stylesheet
"""
# url fetcher for weasyprint
def report_fetcher(url):
logger.debug('Getting url for weasyprint {}'.format(url))
if url.startswith('stock://'):
imagePath = stock.getStockImagePath(url[8:])
with open(imagePath, 'rb') as f:
image = f.read()
return dict(string=image,
mime_type='image/png')
elif url.startswith('image://'):
img = '' # Empty image
if isinstance(images, dict):
img = images.get(url[8:], None)
logger.debug('Getting image {}? {}'.format(url[8:], img is not None))
return dict(string=img,
mime_type='image/png')
else:
return default_url_fetcher(url)
with open(stock.getStockCssPath('report.css'), 'r') as f:
css = f.read()
css = (
css.replace("{header}", _('Report') if header is None else header)
.replace('{page}', _('Page'))
.replace('{of}', _('of'))
.replace('{water}', 'UDS Report' if water is None else water)
.replace('{printed}', _('Printed in {now:%Y, %b %d} at {now:%H:%M}').format(now=datetime.now()))
)
h = HTML(string=html, url_fetcher=report_fetcher)
c = CSS(string=css)
return h.write_pdf(stylesheets=[c])
def __call__(self, REQUEST, RESPONSE):
content = super(ExportaConsultaPDFView, self).__call__(self)
portal_url = api.portal.get().absolute_url()
base_url = '{0}/++resource++smdu.participacao/'.format(portal_url)
html = HTML(string=content, base_url=base_url)
stylesheets = []
css_path = '{0}/++resource++smdu.participacao/css/proposta.css'.format(portal_url)
r = requests.get(css_path)
stylesheets.append(CSS(string=r.content))
css_path = '{0}/++resource++smdu.participacao/css/print_proposta.css'.format(portal_url)
r = requests.get(css_path)
stylesheets.append(CSS(string=r.content))
css_path = '{0}/++resource++smdu.participacao/css/print.css'.format(portal_url)
r = requests.get(css_path)
stylesheets.append(CSS(string=r.content))
consulta_exportada_pdf = html.write_pdf(stylesheets=stylesheets)
RESPONSE.setHeader('Content-Type', 'application/pdf; charset=utf-8')
RESPONSE.setHeader('Content-Length', len(consulta_exportada_pdf))
RESPONSE.setHeader('Content-Disposition', 'attachment; filename="Relatorio.pdf"')
return consulta_exportada_pdf
def html2file(self, html, filename):
pdf = HTML(string=html)
pdf.write_pdf(filename)
