def createpdf_pisa(pagename):
"creates a pdf file from a saved page using pisa (python module)"
import ho.pisa as pisa
if (not exists(pagename + ".pdf", image=True)) or OVERWRTIE:
infile = open(FOLDER + os.sep + pagename + '.html', 'ro')
outfile = open(FOLDER + os.sep + pagename + '.pdf', 'wb')
if VERBOSE: print("Converting " + pagename + " to pdf...")
pdf = pisa.CreatePDF(infile,
outfile,
FOLDER,
link_callback=fetch_resources)
outfile.close()
if pdf.err:
return pdf.err
return 0
def render_to_pdf(template_src, context_dict):
template = loader.get_template(template_src)
context = Context(context_dict)
html = template.render(context)
result = StringIO.StringIO()
MEDIA_URL = getattr(settings, 'MEDIA_ROOT')
css = open(cur_dir + '/css/pisa.css').read()
pdf = pisa.CreatePDF(StringIO.StringIO(html.encode("ISO-8859-1")),
result,
default_css=css)
if not pdf.err:
response = HttpResponse(result.getvalue(), mimetype='application/pdf')
response['Content-Disposition'] = 'filename=boletim.pdf'
return response
return http.HttpResponse('We had some errors<pre>%s</pre>' %
cgi.escape(html))
def HTML2PDF(data, filename, open=False):
"""
Simple test showing how to create a PDF file from
PML Source String. Also shows errors and tries to start
the resulting PDF
"""
pdf = pisa.CreatePDF(
cStringIO.StringIO(data),
file(filename, "wb"))
if open and (not pdf.err):
pisa.startViewer(filename)
return not pdf.err
def helloWorld():
filename = __file__ + ".pdf"
lc = myLinkLoader(database="some_name", port=666).getFileName
pdf = pisa.CreatePDF(
u"""
<p>
Hello <strong>World</strong>
<p>
<img src="apath/some.png">
""",
file(filename, "wb"),
link_callback = lc,
)
if not pdf.err:
pisa.startViewer(filename)
def report_regiao(request, regiao='NE'):
if request.POST:
if 'regiao' in request.POST:
regiao = request.POST['regiao']
REGIAO_CHOICES = dict(UnidadeFederativa.REGIAO_CHOICES)
projetos = Projeto.objects.all()
camaras = CasaLegislativa.objects.filter(tipo__sigla='CM')
tabelas = list()
# Geral
convenios = Convenio.objects.filter(casa_legislativa__tipo__sigla='CM')
tabela = casas_estado_to_tabela(camaras, convenios, regiao)
tabela["projeto"] = _(u"Geral")
tabelas.append(tabela)
for projeto in projetos:
convenios_proj = convenios.filter(projeto=projeto)
tabela = casas_estado_to_tabela(camaras, convenios_proj, regiao)
tabela["projeto"] = projeto.nome
tabelas.append(tabela)
data = datetime.datetime.now().strftime('%d/%m/%Y')
hora = datetime.datetime.now().strftime('%H:%M')
pisa.showLogging()
response = HttpResponse(content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=RelatorioRegiao_' + regiao + '.pdf'
#tabelas = ({'projeto':"PI"},{'projeto':"PML"},)
t = loader.get_template('convenios/tabela_regiao.html')
c = Context({
'tabelas': tabelas,
'regiao': REGIAO_CHOICES[regiao],
'data': data,
'hora': hora
})
pdf = pisa.CreatePDF(t.render(c), response)
if not pdf.err:
pisa.startViewer(response)
return response
def testSimple(
data="""Hello <b>World</b><br/><img src="img/test.jpg"/>""",
dest="test.pdf"):
"""
Simple test showing how to create a PDF file from
PML Source String. Also shows errors and tries to start
the resulting PDF
"""
pdf = pisa.CreatePDF(
cStringIO.StringIO(data),
file(dest, "wb")
)
if pdf.err:
dumpErrors(pdf)
else:
pisa.startViewer(dest)
def testBackgroundAndImage(
src="test-background.html",
dest="test-background.pdf"):
"""
Simple test showing how to create a PDF file from
PML Source String. Also shows errors and tries to start
the resulting PDF
"""
pdf = pisa.CreatePDF(
file(src, "r"),
file(dest, "wb"),
log_warn = 1,
log_err = 1,
path = os.path.join(os.getcwd(), src)
)
dumpErrors(pdf)
if not pdf.err:
pisa.startViewer(dest)
def testCGI(data="Hello <b>World</b>"):
"""
This one shows, how to get the resulting PDF as a
file object and then send it to STDOUT
"""
result = cStringIO.StringIO()
pdf = pisa.CreatePDF(
cStringIO.StringIO(data),
result
)
if pdf.err:
print "Content-Type: text/plain"
print
dumpErrors(pdf)
else:
print "Content-Type: application/octet-stream"
print
sys.stdout.write(result.getvalue())
def __call__(self):
response = self.request.response
title = self.context.Title()
ftitle = "/tmp/%s_CV.pdf" % (title)
filename = ftitle
attachment = 'attachment; filename=%s' % (ftitle)
f = file(filename, "wb")
pdf_template = ViewPageTemplateFile('templates/pdf-view.pt')(self)
response.setHeader('Content-Type', 'application/pdf')
response.setHeader('Content-Disposition', attachment)
pdf = pisa.CreatePDF(pdf_template.encode("UTF-8"), response)
f.flush()
f.close()
if not pdf.err:
return response
else:
# Something is wrong
# Fledge this out later
pass
def filter(self,
script_name,
path_info,
environ,
status,
headers,
body):
topdf = environ.get("pisa.topdf", "")
if topdf:
dst = StringIO.StringIO()
result = pisa.CreatePDF(
body,
dst,
show_error_as_pdf=True,
)
headers = [
("content-type", "application/pdf"),
("content-disposition", "attachment; filename=" + topdf)
]
body = dst.getvalue()
return status, headers, body
def createPDF(inputFile):
input = open(inputFile).read()
output = file(pdf, "wb")
pisa.showLogging()
pisa.CreatePDF(input, output)
output.close()
#!/usr/bin/python
import sys
import re
import glob
import os
import shutil
import MySQLdb
import ho.pisa as pisa
pisa.CreatePDF("pdf_test.htm", "pdf_test.pdf")
def render_to_pdf(self, html): pdf = StringIO.StringIO() pisa.CreatePDF(html, pdf, encoding='utf-8') pdf.seek(0) return pdf
def geraPDF(self, nome, texto):
arq = open('/var/lib/netcontrol/plugins/sarg/files/%s.pdf' % (nome),
'wb')
pdf = pisa.CreatePDF(texto, arq)
arq.close()
def create(data, filename):
f = file(filename, 'wb')
pdf = pisa.CreatePDF(data, f)
f.close()
if not pdf.err:
pisa.startViewer(filename)
def helloWorld():
filename = __file__ + ".pdf"
pdf = pisa.CreatePDF(u"Hello <strong>World</strong>", file(filename, "wb"))
if not pdf.err:
pisa.startViewer(filename)
def report(request, report_id, template_name="report/report.html"):
if request.user.is_staff:
rtype = get_object_or_404(ReportType, id=report_id)
if not request.user.is_superuser:
if rtype.permissao.count() and not len([val for val in rtype.permissao.all() if val in request.user.groups.all()]):
raise Http404
rtadmin = admin.site._registry[rtype.modelo.model_class()]
campos_dinamicos = {}
for filtro in rtadmin.list_filter:
if type(filtro) == type(()):
filtro = filtro[0]
if "__" in filtro:
filtro = filtro[:filtro.index("__")]
field = get_field(rtype.modelo.model_class(), filtro)
if type(field) == models.BooleanField:
choices = (('1', _(u'Sim')), ('0', _(u'Não')), ('', _(u'Todos')))
campos_dinamicos[filtro] = forms.ChoiceField(required=False, choices=choices, label=_(field.verbose_name), widget=forms.RadioSelect())
elif type(field) == models.CharField:
if field.choices:
choices = field.choices
campos_dinamicos[filtro] = forms.MultipleChoiceField(required=False, choices=choices, label=_(field.verbose_name), widget=forms.CheckboxSelectMultiple())
else:
choices = set()
for obj in rtype.modelo.model_class().objects.all():
choices.add((get_value(obj, filtro), get_value(obj, filtro)))
choices = list(choices)
campos_dinamicos[filtro] = forms.MultipleChoiceField(required=False, choices=choices, label=_(field.verbose_name), widget=forms.SelectMultiple())
elif type(field) == models.DateField or type(field) == models.DateTimeField:
choices = (('q', _(u'Qualquer data')), ('h', _(u'Hoje')), ('m', _(u'Este mês')), ('a', _(u'Este ano')))
campos_dinamicos[filtro] = forms.ChoiceField(required=False, choices=choices, initial='q', label=_(field.verbose_name), widget=forms.RadioSelect())
elif type(field) == models.ForeignKey or type(field) == models.OneToOneField:
queryset = rtype.modelo.model_class()._meta.get_field(filtro).rel.to.objects.all()
campos_dinamicos[filtro] = forms.ModelMultipleChoiceField(required=False, queryset=queryset, label=_(field.verbose_name), widget=forms.SelectMultiple())
else:
choices = set()
for obj in rtype.modelo.model_class().objects.all():
choices.add((get_value(obj, filtro), get_value(obj, filtro)))
choices = list(choices)
campos_dinamicos[filtro] = forms.MultipleChoiceField(required=False, choices=choices, label=_(field.verbose_name), widget=forms.SelectMultiple())
FilterForm = type('', (forms.Form,), campos_dinamicos)
if request.method == "POST":
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename=%s.pdf' % smart_str(rtype.titulo).replace(" ", "_")
queryset = rtype.modelo.model_class().objects.all()
for field_name in rtadmin.list_filter:
field = get_field(rtype.modelo.model_class(), field_name)
sql = {}
if type(field) == models.DateField or type(field) == models.DateTimeField:
try:
value = request.POST[field_name]
if value == 'q': pass
elif value == 'h': sql["%s__day" % field_name] = datetime.now().day
elif value == 'm': sql["%s__month" % field_name] = datetime.now().month
elif value == 'a': sql["%s__year" % field_name] = datetime.now().year
except: pass
elif type(field) == models.BooleanField:
try:
value = request.POST[field_name]
sql["%s" % field_name] = value
except: pass
else:
try:
value = request.POST.getlist(field_name)
if len(value) == 0: continue
sql["%s__in" % field_name] = value
except: pass
query = models.Q(**sql)
queryset = queryset.filter(query)
campos = rtype.campos.replace('[', '').replace(']', '').replace('u\'', '').replace('\'', '').replace(',', '').split(' ')
list_report = []
for c in campos:
list_report.append(rtadmin.list_report[get_key(c)])
try:
model = str(queryset.model)
except:
model = str(queryset)
if "PendenciaProcesso" in model:
html = html_report_pendencias(smart_str(rtype.cabecalho), list_report, queryset)
else:
html = html_report_generic(smart_str(rtype.cabecalho), list_report, queryset)
import logging
class PisaNullHandler(logging.Handler):
def emit(self, record):
pass
log = logging.getLogger(__name__)
log.addHandler(PisaNullHandler())
pdf = pisa.CreatePDF(html, response)
return response
else:
form = FilterForm()
return render_to_response(template_name, {
'form': form,
'title': rtype.titulo,
'rtype': rtype,
'rtadmin' : rtadmin,
}, context_instance=RequestContext(request))
else:
raise PermissionDenied
def html_to_pdf(self,
req,
html_pages,
book=True,
title='',
subject='',
version='',
date=''):
self.env.log.debug('WikiPrint => Start function html_to_pdf')
page = Markup('\n<div><pdf:nextpage /></div>'.join(html_pages))
#Replace PageOutline macro with Table of Contents
if book:
#If book, remove [[TOC]], and add at beginning
page = page.replace('[[pdf-toc]]', '')
page = Markup(self.get_toc()) + Markup(page)
else:
page = page.replace('[[pdf-toc]]', self.get_toc())
page = self.add_headers(req,
page,
book,
title=title,
subject=subject,
version=version,
date=date)
page = page.encode(self.default_charset, 'replace')
css_data = self.get_css(req)
pdf_file = StringIO.StringIO()
auth_cookie = hex_entropy()
loader = linkLoader(self.env, req, auth_cookie)
#Temporary authentication
self.env.log.debug("Storing temporary auth cookie %s for user %s",
auth_cookie, req.authname)
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"INSERT INTO auth_cookie (cookie,name,ipnr,time) "
"VALUES (%s, %s, %s, %s)",
(auth_cookie, req.authname, '127.0.0.1', int(time.time())))
db.commit()
pdf = pisa.CreatePDF(page,
pdf_file,
show_errors_as_pdf=True,
default_css=css_data,
link_callback=loader.getFileName)
out = pdf_file.getvalue()
pdf_file.close()
cursor.execute("DELETE FROM auth_cookie WHERE cookie=%s",
(auth_cookie, ))
db.commit()
self.env.log.debug('WikiPrint => Finish function html_to_pdf')
return out
