def gera_pdf_boletos(lista_boletos, template_boleto=None):
if template_boleto is None:
boleto = lista_boletos[0]
if boleto.template_boleto is not None:
if isinstance(boleto.template_boleto, basestring):
template_boleto = BytesIO().write(
open(boleto.arquivo_template_boleto, 'rb').read())
else:
template_boleto = boleto.template_boleto
else:
template_boleto = boleto.banco.template_boleto
arquivo_renderizado = tempfile.NamedTemporaryFile(delete=False)
arquivo_pdf = arquivo_renderizado.name + '.pdf'
template = Template(template_boleto, arquivo_renderizado.name)
template.render({'boletos': lista_boletos})
sh.libreoffice('--headless', '--invisible', '--convert-to', 'pdf',
'--outdir', '/tmp', arquivo_renderizado.name)
pdf = open(arquivo_pdf, 'rb').read()
os.remove(arquivo_pdf)
os.remove(arquivo_renderizado.name)
return pdf
def _renderiza_documento(self):
'''
Renderiza o documento e salva o pdf do tipo de documento especificado
de acordo com o template correspondente
:return:
'''
script_dir = os.path.dirname(__file__)
template_path = os.path.join(script_dir, self.tipo_impressao + '.odt')
template = open(template_path, 'rb')
arq_template = tempfile.NamedTemporaryFile()
arq_template.write(template.read())
arq_template.seek(os.SEEK_SET)
template.close()
arq_odt = tempfile.NamedTemporaryFile(suffix=".odt")
t = Template(arq_template.name, arq_odt.name)
t.render({'danfe': self})
lo = sh.libreoffice('--headless', '--invisible', '--convert-to',
'pdf', '--outdir', tempfile.gettempdir(),
arq_odt.name, _bg=True)
lo.wait()
arq_pdf = arq_odt.name[:-3] + 'pdf'
self.pdf = open(arq_pdf, 'rb').read()
arq_template.close()
arq_odt.close()
def gerar_danfce(self):
if self.NFe is None:
raise ValueError(
'Não é possível gerar um DANFCE sem a informação de uma NFC-e')
if self.protNFe is None:
self.protNFe = ProtNFe_310()
if self.procEventoCancNFe is None:
self.procEventoCancNFe = ProcEventoCancNFe_100()
#
# Prepara o queryset para impressão
#
self.NFe.monta_chave()
self.NFe.monta_qrcode()
self.NFe.site = self.site
# Emissão para simples conferência / sem protocolo de autorização
self.mensagem_protocolo = ''
self.mensagem_sem_valor = ''
if (not self.protNFe.infProt.nProt.valor
) or self.NFe.infNFe.ide.tpAmb.valor == 2:
self.mensagem_sem_valor = u'Sem valor fiscal'
# NF-e denegada
if self.protNFe.infProt.cStat.valor in ('110', '301', '302'):
self.mensagem_protocolo = u'Protocolo de Denegação '
self.mensagem_protocolo += self.protNFe.protocolo_formatado
# Emissão normal
elif self.protNFe.infProt.nProt.valor:
self.mensagem_protocolo = u'Protocolo de Autorização '
self.mensagem_protocolo += self.protNFe.protocolo_formatado
# A NF-e foi cancelada por um evento de cancelamento, , no DANFCE imprimir o "carimbo" de cancelamento
self.mensagem_cancelamento = ''
self.motivo_cancelamento = ''
if self.procEventoCancNFe.retEvento.infEvento.nProt.valor:
self.mensagem_cancelamento = self.procEventoCancNFe.retEvento.protocolo_formatado
self.motivo_cancelamento = self.procEventoCancNFe.evento.infEvento.detEvento.xJust.valor
##
## Observação de impressão
##
#if self.nome_sistema:
#self.obs_impressao = self.nome_sistema + ' - ' + self.obs_impressao
#else:
#self.obs_impressao = self.obs_impressao
if self.template:
if isinstance(self.template, file):
template = self.template
else:
template = open(self.template)
else:
template = open(os.path.join(DIRNAME, 'danfce_a4.odt'))
self.caminho_temporario = self.caminho_temporario or '/tmp/'
nome_arq_template = self.caminho_temporario + uuid4().hex
open(nome_arq_template, 'w').write(template.read())
template.close()
nome_arq_temp = uuid4().hex
nome_arq_odt = self.caminho_temporario + nome_arq_temp + '.odt'
nome_arq_pdf = self.caminho_temporario + nome_arq_temp + '.pdf'
t = Template(nome_arq_template, nome_arq_odt)
t.render({'danfce': self})
print(
sh.libreoffice('--headless', '--invisible', '--convert-to', 'pdf',
'--outdir', '/tmp', nome_arq_odt))
self.conteudo_pdf = open(nome_arq_pdf, 'r').read()
os.remove(nome_arq_template)
os.remove(nome_arq_odt)
os.remove(nome_arq_pdf)
if self.salvar_arquivo:
nome_arq = self.caminho + self.NFe.chave + '.pdf'
open(nome_arq, 'w').write(self.conteudo_pdf)
def gerar_danfce(self):
if self.NFe is None:
raise ValueError('Não é possível gerar um DANFCE sem a informação de uma NFC-e')
if self.protNFe is None:
self.protNFe = ProtNFe_310()
if self.procEventoCancNFe is None:
self.procEventoCancNFe = ProcEventoCancNFe_100()
#
# Prepara o queryset para impressão
#
self.NFe.monta_chave()
self.NFe.monta_qrcode()
self.NFe.site = self.site
# Emissão para simples conferência / sem protocolo de autorização
self.mensagem_protocolo = ''
self.mensagem_sem_valor = ''
if (not self.protNFe.infProt.nProt.valor) or self.NFe.infNFe.ide.tpAmb.valor == 2:
self.mensagem_sem_valor = u'Sem valor fiscal'
# NF-e denegada
if self.protNFe.infProt.cStat.valor in ('110', '301', '302'):
self.mensagem_protocolo = u'Protocolo de Denegação '
self.mensagem_protocolo += self.protNFe.protocolo_formatado
# Emissão normal
elif self.protNFe.infProt.nProt.valor:
self.mensagem_protocolo = u'Protocolo de Autorização '
self.mensagem_protocolo += self.protNFe.protocolo_formatado
# A NF-e foi cancelada por um evento de cancelamento, , no DANFCE imprimir o "carimbo" de cancelamento
self.mensagem_cancelamento = ''
self.motivo_cancelamento = ''
if self.procEventoCancNFe.retEvento.infEvento.nProt.valor:
self.mensagem_cancelamento = self.procEventoCancNFe.retEvento.protocolo_formatado
self.motivo_cancelamento = self.procEventoCancNFe.evento.infEvento.detEvento.xJust.valor
##
## Observação de impressão
##
#if self.nome_sistema:
#self.obs_impressao = self.nome_sistema + ' - ' + self.obs_impressao
#else:
#self.obs_impressao = self.obs_impressao
if self.template:
if isinstance(self.template, file):
template = self.template
else:
template = open(self.template)
else:
template = open(os.path.join(DIRNAME, 'danfce_a4.odt'))
self.caminho_temporario = self.caminho_temporario or '/tmp/'
nome_arq_template = self.caminho_temporario + uuid4().hex
open(nome_arq_template, 'w').write(template.read())
template.close()
nome_arq_temp = uuid4().hex
nome_arq_odt = self.caminho_temporario + nome_arq_temp + '.odt'
nome_arq_pdf = self.caminho_temporario + nome_arq_temp + '.pdf'
t = Template(nome_arq_template, nome_arq_odt)
t.render({'danfce': self})
print(sh.libreoffice('--headless', '--invisible', '--convert-to', 'pdf', '--outdir', '/tmp', nome_arq_odt))
self.conteudo_pdf = open(nome_arq_pdf, 'r').read()
os.remove(nome_arq_template)
os.remove(nome_arq_odt)
os.remove(nome_arq_pdf)
if self.salvar_arquivo:
nome_arq = self.caminho + self.NFe.chave + '.pdf'
open(nome_arq, 'w').write(self.conteudo_pdf)
def create_single_pdf(self, cr, uid, ids, data, report_xml, context=None):
""" Overide this function to generate our py3o report
"""
if report_xml.report_type != 'py3o':
return super(Py3oParser, self).create_single_pdf(
cr, uid, ids, data, report_xml, context=context
)
pool = registry(cr.dbname)
model_data_ids = pool['ir.model.data'].search(
cr, uid, [
('model', '=', 'ir.actions.report.xml'),
('res_id', '=', report_xml.id),
]
)
xml_id = None
if model_data_ids:
model_data = pool['ir.model.data'].browse(
cr, uid, model_data_ids[0], context=context
)
xml_id = '%s.%s' % (model_data.module, model_data.name)
parser_instance = self.parser(cr, uid, self.name2, context=context)
parser_instance.set_context(
self.getObjects(cr, uid, ids, context),
data, ids, report_xml.report_type
)
if xml_id in _extender_functions:
for fct in _extender_functions[xml_id]:
fct(pool, cr, uid, parser_instance.localcontext, context)
tmpl_data = self.get_template(report_xml)
in_stream = StringIO(tmpl_data)
out_stream = StringIO()
template = Template(in_stream, out_stream)
expressions = template.get_all_user_python_expression()
py_expression = template.convert_py3o_to_python_ast(expressions)
convertor = Py3oConvertor()
data_struct = convertor(py_expression)
filetype = report_xml.py3o_fusion_filetype
datadict = parser_instance.localcontext
parsed_datadict = data_struct.render(datadict)
fusion_server_obj = pool.get('py3o.server')
fusion_server_ids = fusion_server_obj.search(
cr, uid, [('is_active', '=', True)], context=context, limit=1
)
if not fusion_server_ids:
if filetype.fusion_ext == report_xml.py3o_template_id.filetype:
# No format conversion is needed, render the template directly
template.render(parsed_datadict)
res = out_stream.getvalue()
else:
if USE_LOCAL_LIBREOFFICE:
import sh
import tempfile
template.render(parsed_datadict)
res = out_stream.getvalue()
arq = tempfile.NamedTemporaryFile(delete=False)
arq.seek(0)
arq.write(res)
arq.flush()
res_arq_name = arq.name + '.' + filetype.fusion_ext
sh.libreoffice('--headless', '--invisible', \
'--convert-to', filetype.fusion_ext, \
'--outdir', '/tmp', arq.name)
res = file(res_arq_name, 'r').read()
os.remove(res_arq_name)
os.remove(arq.name)
else:
raise exceptions.MissingError(
_(u"No Py3o server configuration found")
)
else: # Call py3o.server to render the template in the desired format
fusion_server_id = fusion_server_ids[0]
fusion_server = fusion_server_obj.browse(
cr, uid, fusion_server_id, context=context
)
in_stream.seek(0)
files = {
'tmpl_file': in_stream,
}
fields = {
"targetformat": filetype.fusion_ext,
"datadict": json.dumps(parsed_datadict),
"image_mapping": "{}",
}
r = requests.post(fusion_server.url, data=fields, files=files)
if r.status_code != 200:
# server says we have an issue... let's tell that to enduser
raise exceptions.Warning(
_('Fusion server error %s') % r.text,
)
# Here is a little joke about Odoo
# we do nice chunked reading from the network...
chunk_size = 1024
with NamedTemporaryFile(
suffix=filetype.human_ext,
prefix='py3o-template-'
) as fd:
for chunk in r.iter_content(chunk_size):
fd.write(chunk)
fd.seek(0)
# ... but odoo wants the whole data in memory anyways :)
res = fd.read()
return res, filetype.human_ext
from openerp import registry
from py3o.template.helpers import Py3oConvertor
from py3o.template import Template
libreoffice_present = os.path.expanduser('~/.py3o_libreoffice_present')
if os.path.exists(libreoffice_present):
USE_LOCAL_LIBREOFFICE = open(libreoffice_present).read() == 'True'
else:
USE_LOCAL_LIBREOFFICE = False
try:
import sh
import tempfile
sh.libreoffice('--headless', '--version')
USE_LOCAL_LIBREOFFICE = True
except:
pass
open(libreoffice_present, 'w').write(str(USE_LOCAL_LIBREOFFICE))
_extender_functions = {}
class TemplateNotFound(Exception):
pass