def generate(template_path, data_file, out_file=None, year=None):
"""
Generate a week calendar for an entire year in odt format.
Args:
template_path (str): The file path of the template to render.
data_file (str): The path of the configuration to load.
out_file (io.IOBase): A file-like object to write the calendar
to.
year (int): The year to render the calendar for. A year
specified in the data_file is used as a fallback value.
Raises:
.BadConfigError: If the given configuration file is missing
configurations.
"""
with open(data_file) as f:
calendar_data = yaml.load(f)
try:
year = year or calendar_data['year']
birthdays = calendar_data['birthdays']
weddings = calendar_data['weddings']
special_dates = calendar_data['special dates']
except KeyError:
raise BadConfigError()
weeks = create_weeks_for_year(year, birthdays, weddings, special_dates)
template = Template(source=None, filepath=template_path)
generated = template.generate(weeks=weeks)
data = generated.render().getvalue()
if not out_file:
out_file = open('calendar-{:d}.odt'.format(year), 'wb')
out_file.write(data)
def test_generate_fod(self):
"Testing generate fod"
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.fodt')
with open(filepath, mode='rb') as source:
oot = Template(source)
oot.generate(**self.data)
def createLetter():
# if request.form:
# data={'recipient':json.loads(request.form['recipient']),
# 'sender':json.loads(request.form['sender'])}
# elif (request.json):
# data=request.json
#
data = {"recipient": json.loads(request.form["recipient"]), "sender": json.loads(request.form["sender"])}
letter_data = jsonToLetterData(data)
print letter_data
basic = Template(source="IPC_DATA", filepath=os.path.join(topPath, "IPC_ger_Letter.odt"))
print ("TemplateDone")
basic_generated = basic.generate(o=letter_data).render()
print ("filled Done")
odt_data = basic_generated.getvalue()
print ("generated Done")
f = tempfile.NamedTemporaryFile(delete=False, mode="wb", dir=os.path.join(topPath, "static"))
print ("%s.odt" % f.name)
f.write(odt_data)
response = make_response(odt_data)
fileRecipientFirst = letter_data["recipient"]["surname"].encode("ascii", "ignore")
fileRecipientSur = letter_data["recipient"]["firstname"].encode("ascii", "ignore")
fileDate = letter_data["date"]
filename = "Letter_to_%s_%s_%s" % (fileRecipientFirst, fileRecipientSur, fileDate)
response.headers["Content-Disposition"] = "attachment; filename=%s.odt" % filename
response.mimetype = "text/odt"
return response
def setUp(self):
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.odt')
self._source = open(filepath, mode='rb')
self.oot = Template(self._source)
self.data = {
'first_name':
u'Trente',
'last_name':
u'Møller',
'ville':
u'Liège',
'friends': [{
'first_name': u'Camille',
'last_name': u'Salauhpe'
}, {
'first_name': u'Mathias',
'last_name': u'Lechat'
}],
'hobbies': [u'Music', u'Dancing', u'DJing'],
'animals': [u'Felix da housecat', u'Dog eat Dog'],
'images': [(open(os.path.join(thisdir, 'one.jpg'),
'rb'), 'image/jpeg', None, None, 'One'),
(open(os.path.join(thisdir, 'two.png'),
'rb'), 'image/png', '2cm', '2.2cm', 'Two')],
'oeuf':
open(os.path.join(thisdir, 'egg.jpg'), 'rb'),
'footer':
u'We sell stuff'
}
def generate(template_path, data_file, out_file=None, year=None):
"""
Generate a week calendar for an entire year in odt format.
Args:
template_path (str): The file path of the template to render.
data_file (str): The path of the configuration to load.
out_file (io.IOBase): A file-like object to write the calendar
to.
year (int): The year to render the calendar for. A year
specified in the data_file is used as a fallback value.
Raises:
.BadConfigError: If the given configuration file is missing
configurations.
"""
with open(data_file) as f:
calendar_data = yaml.load(f, yaml.Loader)
try:
year = year or calendar_data['year']
birthdays = calendar_data['birthdays']
weddings = calendar_data['weddings']
special_dates = calendar_data['special dates']
except KeyError:
raise BadConfigError()
weeks = create_weeks_for_year(year, birthdays, weddings, special_dates)
template = Template(source=None, filepath=template_path)
generated = template.generate(weeks=weeks)
data = generated.render().getvalue()
if not out_file:
out_file = open('calendar-{:d}.odt'.format(year), 'wb')
out_file.write(data)
def eff_client_report(request, client_slug):
client = get_object_or_404(Client, slug=client_slug)
context = __process_dates(request)
from_date = context['from_date']
to_date = context['to_date']
if 'export' in request.GET:
if request.GET['export'] == 'odt':
if 'detailed' in request.GET:
basic = Template(source=None, filepath=os.path.join(cur_dir, '../templates/reporte_cliente_detallado.odt'))
report_by_project = dict(map(lambda x:x[0], client.report(from_date, to_date, True)))
report_data = format_report_data(report_by_project, client, from_date, to_date, True)
report_data['clientname'] = client.name
basic_generated = basic.generate(o=report_data).render()
resp = HttpResponse(basic_generated.getvalue(), mimetype='application/vnd.oasis.opendocument.text')
cd = 'filename=billing-%s-%s-logs.odt' % (from_date.year, from_date.strftime("%m"), )
resp['Content-Disposition'] = cd
return resp
else:
basic = Template(source=None, filepath=os.path.join(cur_dir, '../templates/reporte_cliente.odt'))
report_by_project = dict(map(lambda x:x[0], client.report(from_date, to_date, with_rates=True)))
report_data = format_report_data(report_by_project, client, from_date, to_date)
basic_generated = basic.generate(o=report_data).render()
resp = HttpResponse(basic_generated.getvalue(), mimetype='application/vnd.oasis.opendocument.text')
cd = 'filename=billing-%s-%s.odt' % (from_date.year, from_date.strftime("%m"), )
resp['Content-Disposition'] = cd
return resp
elif request.GET['export'] == 'csv':
response = HttpResponse(mimetype='text/csv')
if 'detailed' in request.GET:
cd = 'attachment; filename=billing_%s_%s_%s_logs.csv' % (client_slug, from_date, to_date, )
response['Content-Disposition'] = cd
report_by_project = dict(map(lambda x:x[0], client.report(from_date, to_date, True)))
report_data = format_report_data(report_by_project, client, from_date, to_date, True)
t = loader.get_template('csv/reporte_cliente_detallado.txt')
c = Context({'data': report_data['projects_users'],})
else:
cd = 'attachment; filename=billing_%s_%s_%s.csv' % (client_slug, from_date, to_date, )
response['Content-Disposition'] = cd
report_by_project = dict(map(lambda x:x[0], client.report(from_date, to_date)))
report_data = format_report_data(report_by_project, client, from_date, to_date)
t = loader.get_template('csv/reporte_cliente.txt')
c = Context({'data': report_data['projects_users'],})
response.write(t.render(c))
return response
context['report_by_project'] = client.report(from_date, to_date, True)
context['clientname'] = client.name
if MONTHLY_FLAG in request.GET:
context[MONTHLY_FLAG] = request.GET[MONTHLY_FLAG]
context['navs'] = [('prev', 'previo', '«'), ('next', 'siguiente', '»')]
return render_to_response('reporte_cliente.html', context)
def generate_odf(filename, template_path, data, tmp_path, uuid):
uniq_tmp = tmp_path + '/' + uuid
if not os.path.exists(tmp_path):
os.makedirs(tmp_path)
if not os.path.exists(uniq_tmp):
os.makedirs(uniq_tmp)
basic = Template(source='', filepath=template_path)
with open(uniq_tmp + '/' + filename, 'wb') as file:
file.write(basic.generate(o=data).render().getvalue())
def make(self, metadatas):
raw = []
with open(self["input"]) as csvfile:
raw = sorted(list(csv.DictReader(csvfile)),
key=lambda x: self._sortKey(x))
data = self._makeGroups(raw, self.get("groups", []))
with open(self["output"], "wb") as outfile:
template = Template(source='', filepath=self["template"])
doc = template.generate(data=data, meta=metadatas)
outfile.write(doc.render().getvalue())
def render_template(self):
"""Returns document like BytesIO object and new filename"""
template_name, template_ext = self.template.filename.split('.', 1)
if self.ext == template_ext and self.ext in ALLOWED_EXTENSIONS:
basic = Template(source=self.template, filepath='')
basic_generated = basic.generate(o=self.data).render()
document = BytesIO(basic_generated.getvalue())
filename = self.new_filename(template_name)
return document, filename
else:
raise DocumentWorkerException('Incorrect extension!')
def listarProductoPDF(request):
"""docstring for listarProducto"""
listasProducto = []
productos = []
productoSinStock = []
depositos = Deposito.objects.all()
filtro = request.GET.get("filtro")
filtroDeposito = request.GET.get("deposito")
if filtroDeposito != "":
filtroDeposito = Deposito.objects.get(pk=filtroDeposito)
else:
filtroDeposito = "ALL"
if filtro == "":
if filtroDeposito == "ALL":
stocks = Stock.objects.all()
productoSinStock = Producto.objects.filter(cantidad = 0)
else:
stocks = Stock.objects.filter(deposito=filtroDeposito)
else:
listasProducto = list(Producto.objects.filter(Q(nombre__contains=filtro) | Q(descripcion__contains=filtro)))
if filtroDeposito == "ALL":
stocks = []
for producto in listasProducto:
listaStock=Stock.objects.filter(producto=producto)
stocks = stocks+list(listaStock)
productoSinStock = filter(lambda x: x.cantidad == 0 , listasProducto)
else:
stocks = []
for producto in listasProducto:
try:
stocks.append(Stock.objects.get(producto=producto, deposito=filtroDeposito))
except ObjectDoesNotExist:
pass
#stocks = Stock.objects.filter(Q(producto__icontains=listasProducto) , Q(deposito=filtroDeposito))
stocks = list(stocks)
stocks.sort()
stocks = filter(lambda x: x.disponibles != 0 , stocks)
repos = relatorio.ReportRepository()
basic = Template(source="",filepath=TEMPLATE_DIRS+'/gstProducto/listarProductoBase.odt')
file(TEMPLATE_DIRS+'/gstProducto/listarProducto.odt', 'wb').write(basic.generate(stocks=stocks, productos=productoSinStock).render().getvalue())
# p = subprocess.Popen('unoconv -f pdf '+TEMPLATE_DIRS+'/gstDeposito/listarDeposito.odt', shell=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT)
os.system('unoconv -f pdf '+TEMPLATE_DIRS+'/gstProducto/listarProducto.odt')
with open(TEMPLATE_DIRS+'/gstProducto/listarProducto.pdf', 'r') as pdf:
response = HttpResponse(pdf.read(), mimetype='application/pdf')
response['Content-Disposition'] = 'inline;filename=some_file.pdf'
pdf.close()
return response
def render_report(self, form_data, format='odt'):
locals_ = locals()
locals_.update(dict([(x.__name__, x) for x in get_models()]))
locals_.update({'form': form_data})
report = Template(source=None, filepath=self.template.path)
if hasattr(settings, 'AUTOREPORT_CONTEXT_PROCESSOR'):
path = settings.AUTOREPORT_CONTEXT_PROCESSOR
i = path.rfind('.')
context_processor = getattr(import_module(path[:i]), path[i+1:])
else:
context_processor = lambda d: d
response = http.HttpResponse(report.generate(**context_processor(eval(self.params, globals(), locals_))).render().getvalue(), mimetype=self._formats[format])
response['Content-Disposition'] = 'attachment; filename=%s.%s' % (self.short_name(), format)
return response
def create_single_odt(self, cr, uid, ids, data, report_xml, context=None):
if not context:
context={}
context = context.copy()
report_type = report_xml.report_type
context['parents'] = sxw_parents
sxw_path = os.path.join(tools.config['addons_path'], report_xml.report_sxw)
odt_template = Template(source=None, filepath=sxw_path)
objs = self.getObjects(cr, uid, ids, context)
odt_parser = self.parser(cr, uid, self.name2, context)
odt_parser.set_context(objs, data, ids, report_xml.report_type)
odt_generated = odt_template.generate(**odt_parser.localcontext).render()
final_op = odt_generated.getvalue()
return (final_op, "odt")
def listadoProductoEstadistico(request):
detallesFacturas = DetalleFactura.objects.all()
af = AdaptadorFactura()
af.setDetalles(detallesFacturas)
repos = relatorio.ReportRepository()
basic = Template(source="", filepath=TEMPLATE_DIRS+'/estadisticaBase.ods')
file(TEMPLATE_DIRS+'/estadistica.ods', 'wb').write(basic.generate(detalles=af.detalles).render().getvalue())
with open(TEMPLATE_DIRS+'/estadistica.ods', 'r') as odt:
response = HttpResponse(odt.read(), mimetype='application/vnd.oasis.opendocument.text')
response['Content-Disposition'] = 'inline;filename=Estadistica.ods'
odt.close()
return response
def generate(table_name,
nb=DEFAULT_Q_NB,
scheme=None,
oldest_prevail=False,
output=None,
force=False,
tpl=None,
edit_after=True,
use_previous=False):
"""
Generate a new document using n data from the table and the matching
template.
"""
if use_previous:
sw_data = sweepstakes.load_sweepstake(int(table_name))
table_name, rows = sw_data[0], sw_data[1:]
table_name = table_name[0]
if len(rows[0]) != len(database.get_cols(table_name)):
raise ColumnsDoNotMatchError(
len(database.get_cols(table_name)), len(rows[0]), table_name,
database.get_cols(table_name),
sweepstakes._get_sweepstake_name(use_previous))
if tpl is None:
tpl_name = table_name
else:
if not os.path.isfile(template.path(tpl)):
raise NotFoundError(f'Cannot find template file: {tpl}')
tpl_name = tpl
if output is None:
output = f'{table_name}.{TEMPLATE_EXT}'
if os.path.exists(output) and not force:
overwrite = terminal.ask_yes_no(f'Output file {output} already '
f'exists, overwrite it?')
if not overwrite:
raise CommandCancelledError('generate')
if not use_previous:
rows = database.draw_rows(table_name,
nb,
oldest_prevail=oldest_prevail)
data = _process_data(rows, scheme=scheme)
template.sanitize(template.path(tpl_name))
basic = Template(source='', filepath=template.path(tpl_name))
basic_generated = basic.generate(o=data).render()
with open(output, 'wb') as f:
f.write(basic_generated.getvalue())
if edit_after:
edit(output)
def eff_fixed_price_client_reports(request):
if not request.is_ajax():
context = __get_context(request)
context['title'] = "Reporte de Clientes - Projectos con costo fijo"
context['clients'] = Client.objects.filter(project__billing_type='FIXED').distinct()
if request.method == 'POST':
client = Client.objects.get(id=request.POST['client'])
project = Project.objects.get(id=request.POST['project'])
state_and_country = client.state or ''
if state_and_country.strip(): state_and_country += ' - '
state_and_country += client.country
client_data = {'name' : client.name or '',
'address' : client.address or '',
'city' : client.city or '',
'state_and_country' : state_and_country,
'currency' : client.currency.ccy_symbol or client.currency.ccy_code,
}
reverse_billing = FixedPriceClientReverseBilling(
project_data = {'name' : project.name, 'price' : "%.2f" % project.fixed_price},
client_data = client_data,
today = datetime.now().strftime("%A, %d %B %Y")
)
basic = Template(source=None, filepath=os.path.join(cur_dir, '../templates/reporte_cliente_precio_fijo.odt'))
basic_generated = basic.generate(o=reverse_billing).render()
resp = HttpResponse(basic_generated.getvalue(), mimetype='application/vnd.oasis.opendocument.text')
cd = 'filename=billing-%s.odt' % project.external_id
resp['Content-Disposition'] = cd
return resp
return render_to_response('admin_reportes_cliente_costo_fijo.html', context)
else:
client_id = request.POST['client']
client = get_object_or_404(Client, id=client_id)
projects = Project.objects.filter(client=client, billing_type='FIXED')
ret = '<option selected="selected" value="">----</option>'
ret += ''.join(['<option value="%s">%s</option>' % (p.id, p.name) for p in projects])
return HttpResponse(ret, mimetype="text/html")
def generarFactura(request):
try:
nroNota = request.GET.get("nroNota")
notaVenta = NotaVenta.objects.get(pk = nroNota)
af = AdaptadorFactura()
af.inicializar(notaVenta)
print "path = " + TEMPLATE_DIRS+'/facturaBase.odt'
af.inicializar(notaVenta)
repos = relatorio.ReportRepository()
basic = Template(source="", filepath=TEMPLATE_DIRS+'/facturaBase.odt')
file(TEMPLATE_DIRS+'/factura.odt', 'wb').write(basic.generate(factura=af, detalles=af.detalles).render().getvalue())
os.system('unoconv -f pdf '+TEMPLATE_DIRS+'/factura.odt')
with open(TEMPLATE_DIRS+'/factura.pdf', 'r') as pdf:
response = HttpResponse(pdf.read(), mimetype='application/pdf')
response['Content-Disposition'] = 'inline;filename=some_file.pdf'
pdf.close()
return response
except ObjectDoesNotExist:
raise ErrorCobro()
def listarDepositoPDF(request):
listasDepos=[]
filtro = request.GET.get("filtro")
if filtro == "":
listasDepos = Deposito.objects.all()
else:
listasDeposDir = list(Deposito.objects.filter(direccion__contains=filtro))
listasDeposTel = list(Deposito.objects.filter(telefono__contains=filtro))
listasDepos = set(listasDeposDir + listasDeposTel)
depositos= listasDepos
repos = relatorio.ReportRepository()
inv = depositos
basic = Template(source="", filepath=TEMPLATE_DIRS+'/gstDeposito/listarDepositoBase.odt')
file(TEMPLATE_DIRS+'/gstDeposito/listarDeposito.odt', 'wb').write(basic.generate(o=inv).render().getvalue())
# p = subprocess.Popen('unoconv -f pdf '+TEMPLATE_DIRS+'/gstDeposito/listarDeposito.odt', shell=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT)
os.system('unoconv -f pdf '+TEMPLATE_DIRS+'/gstDeposito/listarDeposito.odt')
with open(TEMPLATE_DIRS+'/gstDeposito/listarDeposito.pdf', 'r') as pdf:
response = HttpResponse(pdf.read(), mimetype='application/pdf')
response['Content-Disposition'] = 'inline;filename=some_file.pdf'
pdf.close()
return response
def setUp(self):
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.odt')
self.oot = Template(open(filepath, mode='rb'))
self.data = {'first_name': u'Trente',
'last_name': u'Møller',
'ville': u'Liège',
'friends': [{'first_name': u'Camille',
'last_name': u'Salauhpe'},
{'first_name': u'Mathias',
'last_name': u'Lechat'}],
'hobbies': [u'Music', u'Dancing', u'DJing'],
'animals': [u'Felix da housecat', u'Dog eat Dog'],
'images': [(open(os.path.join(thisdir, 'one.jpg'), 'rb'),
'image/jpeg'),
(open(os.path.join(thisdir, 'two.png'), 'rb'),
'image/png')],
'oeuf': open(os.path.join(thisdir, 'egg.jpg'), 'rb'),
'footer': u'We sell stuff'}
# -*- coding: utf-8 -*-
"""
Created on Mon May 12 15:24:07 2014
@author: peterb
"""
#!python
from relatorio.templates.opendocument import Template
from ipc_data import letter_data
basic = Template(source="IPC_DATA", filepath='IPC_ger_Letter.odt')
basic_generated = basic.generate(o=letter_data).render()
file('IPC_FULL.odt', 'wb').write(basic_generated.getvalue())
def download_document(invoice, model, type_document_partner_it, inv_id, filename=None, **kw):
cr, uid, context = request.cr, request.uid, request.context
invoice = request.registry[model]
invoice = invoice.browse(cr, uid, int(inv_id), context)
picking_name = ""
if invoice.picking_ids:
pickings = [i.nro_documento for i in invoice.picking_ids]
if i.nro_documento:
picking_name = ", ".join(pickings)
order_name = ""
if invoice.sale_ids:
orders = [i.name for i in invoice.sale_ids]
if i.name:
order_name = ", ".join(orders)
lines = []
for item in invoice.invoice_line:
description = ""
codigo = ""
if item.name:
description = str(item.name).upper()
if item.product_id.default_code:
codigo = item.product_id.default_code
lines.append({
"codigo": codigo,
"product": item.product_id.name,
"description": description,
"qty": int(item.quantity),
"price_unit": item.price_unit,
"price_subtotal": '{:,.2f}'.format(item.price_subtotal),
"price_subtotal_igv": '{:,.2f}'.format(item.invoice_line_tax_id.amount * item.price_subtotal + item.price_subtotal)
})
if(invoice.tax_line != False):
igv = 18
else:
igv = 0
#Validacion de datos
name =""
street = ""
nro_documento = ""
date_invoice = ""
day = ""
month = ""
month_number = ""
year = ""
y = ""
payment_term = ""
user = ""
doc_modificado = ""
nro_doc_modificado = ""
fecha_doc_modificado = ""
informacion_adicional = ""
tipo_nd = ""
number_invoice = ""
if invoice.number:
number_invoice = invoice.number
if invoice.partner_id.name:
name = invoice.partner_id.name
if invoice.partner_id.street:
street = str(invoice.partner_id.street)[:90].upper()
if invoice.partner_id.nro_documento:
nro_documento = invoice.partner_id.nro_documento
if invoice.date_invoice:
date_invoice=invoice.date_invoice
day = time.strftime('%d', time.strptime(invoice.date_invoice,'%Y-%m-%d'))
month = str(time.strftime('%B', time.strptime(invoice.date_invoice,'%Y-%m-%d'))).upper()
month_number = str(time.strftime('%m', time.strptime(invoice.date_invoice,'%Y-%m-%d'))).upper()
year = time.strftime('%y', time.strptime(invoice.date_invoice,'%Y-%m-%d'))
y = time.strftime('%y', time.strptime(invoice.date_invoice,'%Y-%m-%d'))[1]
if invoice.payment_term:
payment_term = str(invoice.payment_term.name).upper()
if invoice.user_id.name:
user = str(invoice.user_id.name).upper()
datas = {
"number": number_invoice,
"name": name,
"street": street,
"nro_documento": nro_documento,
"date_invoice": date_invoice,
"guia": "",
"day": day,
"month": month,
"month_number": month_number,
"year": year,
"y": y,
"picking_name": picking_name,
"order_name": order_name,
"lines": lines,
"payment_term": payment_term,
"a_untaxed": 'S/{:,.2f}'.format(invoice.amount_untaxed),
"igv": igv,
"a_tax": 'S/{:,.2f}'.format(invoice.amount_tax),
"a_total": 'S/{:,.2f}'.format(invoice.amount_total),
"user": user,
"number2letter": number_to_letter(str('{0:.2f}'.format(invoice.amount_total))) + " SOLES",
##################################
"prueba": "",
"null": "",
}
if "invoice" == type_document_partner_it:
invoice_path = openerp.modules.get_module_resource('fxo_mv_print_documents','templates', "invoice.odt")
if "ticket" == type_document_partner_it:
invoice_path = openerp.modules.get_module_resource('fxo_mv_print_documents','templates', "ticket.odt")
if not invoice_path:
error = {
'code': 200,
'message': "Odoo Server Error",
'data': "Not found file template in module!."
}
return werkzeug.exceptions.InternalServerError(simplejson.dumps(error))
try:
basic = Template(source="", filepath=invoice_path)
except:
error = {
'code': 200,
'message': "Odoo Server Error",
'data': "You do not have permission to read\nfile template!."
}
return werkzeug.exceptions.InternalServerError(simplejson.dumps(error))
basic_generated = basic.generate(o=datas).render()
filecontent = basic_generated.getvalue()
if not filecontent:
return request.not_found()
else:
if not filename:
filename = '%s_%s' % (model.replace('.', '_'), wid)
return request.make_response(filecontent,
[('Content-Type', 'application/octet-stream'),
('Content-Disposition', content_disposition(filename))])
def form():
if request.method == 'POST':
classData = request.get_json(force=True)
class Schedules(dict):
testingCounter = 0
contentCounter = -1
yearCounter = -1
monthIntervals = [1]
monthNames = []
years = []
def __init__(self, classData):
self.classData = classData
def monthNumberToName(monthNumber):
if monthNumber == '01':
return 'January'
elif monthNumber == '02':
return 'February'
elif monthNumber == '03':
return 'March'
elif monthNumber == '04':
return 'April'
elif monthNumber == '05':
return 'May'
elif monthNumber == '06':
return 'June'
elif monthNumber == '07':
return 'July'
elif monthNumber == '08':
return 'August'
elif monthNumber == '09':
return 'September'
elif monthNumber == '10':
return 'October'
elif monthNumber == '11':
return 'November'
elif monthNumber == '12':
return 'December'
monthNames.append(monthNumberToName(classData[0]['start'][5:7]))
years.append(classData[0]['start'][0:4])
monthIntervalsCounter = 1
for index, item in enumerate(classData):
monthIntervalsCounter += 1
try:
if item['start'][5:7] != classData[index +
1]['start'][5:7]:
monthIntervals.append(monthIntervalsCounter)
monthNames.append(
monthNumberToName(classData[index +
1]['start'][5:7]))
# if item['start'][0:4] != classData[index + 1]['start'][0:4]:
years.append(classData[index + 1]['start'][0:4])
except:
continue
@property
def testing(self):
Schedules.testingCounter += 1
for i in Schedules.monthIntervals:
if Schedules.testingCounter == i:
return True
return False
@property
def content(self):
Schedules.contentCounter += 1
return Schedules.monthNames[Schedules.contentCounter]
@property
def year(self):
Schedules.yearCounter += 1
return Schedules.years[Schedules.yearCounter]
sched = Schedules(classData)
basic = Template(source='', filepath='template-schedules.odt')
open('app/static/generated-iftest.odt',
'wb').write(basic.generate(o=sched).render().getvalue())
return str(classData)
return render_template('form.html')
# [{'start': '2018-12-12',
# 'end': '2018-12-13',
# 'length': '6 weeks',
# 'course': 'Beg. Obedience',
# 'price': '$140',
# 'city': 'Glendora',
# 'preregister': 'Pre-Registration Required! Call (999) 222-3333',
# 'time': '6PM - 7PM',
# 'address': '555 A St, 98821',
# 'note': 'No dogs at first meeting!'},
# {'start': '2019-01-16',
# 'end': '2019-02-13',
# 'length': '4 weeks',
# 'course': 'Beg. Obedience',
# 'price': '$180',
# 'city': 'Upland',
# 'preregister': 'Pre-Registration Required! Call (999) 555-3333',
# 'time': '6PM - 7PM',
# 'address': '555 A St, 98821',
# 'note': 'No dogs at first meeting!'},
# {'start': '2019-01-16',
# 'end': '2018-12-13',
# 'length': '6 weeks',
# 'course': 'Beg. Obedience',
# 'price': '$140',
# 'city': 'Glendora',
# 'preregister': 'Pre-Registration Required! Call (999) 222-3333',
# 'time': '6PM - 7PM',
# 'address': '555 A St, 98821',
# 'note': 'No dogs at first meeting!'},
# {'start': '2019-01-18',
# 'end': '2018-12-13',
# 'length': '6 weeks',
# 'course': 'Beg. Obedience',
# 'price': '$140',
# 'city': 'Glendora',
# 'preregister': 'Pre-Registration Required! Call (999) 222-3333',
# 'time': '6PM - 7PM',
# 'address': '555 A St, 98821',
# 'note': 'No dogs at first meeting!'},
# {'start': '2019-02-16',
# 'end': '2018-12-13',
# 'length': '6 weeks',
# 'course': 'Beg. Obedience',
# 'price': '$140',
# 'city': 'Glendora',
# 'preregister': 'Pre-Registration Required! Call (999) 222-3333',
# 'time': '6PM - 7PM',
# 'address': '555 A St, 98821',
# 'note': 'No dogs at first meeting!'}]
def product_movement(self, *args, **kwargs):
self.parent._print("*" * 10, " product_movement ", "*" * 10)
self.parent._print(args)
self.parent._print(kwargs)
self.parent._print("*" * 10, " product_movement ", "*" * 10)
doc_type = 'products_movements'
date1 = kwargs.get('date1')
date2 = kwargs.get('date2')
arr_fg = kwargs.get('arr_fg')
dep_fg = kwargs.get('dep_fg')
item_id = kwargs.get('item_id')
answer = {
"params": args,
"kwargs": kwargs,
}
d_data = []
a_data = []
sql_move = f"""select
jmh.n_number as doc_number,
jmh.n_dt_invoice as doc_date,
'' as suppl,
rp.n_name as point,
0,
(jmb.n_product->'n_amount')::text::numeric as amount,
(select c_name from ref_products where c_id = {item_id})
from journals_movements_bodies jmb
join journals_movements_headers jmh on jmb.n_doc_id = jmh.n_id
join ref_partners rp ON rp.n_id = jmh.n_recipient
where (jmb.n_product->'n_balance_id')::text in (select jpb.n_id::text
from journals_products_balance jpb
where jpb.n_product_id = {item_id})
and jmb.n_deleted=false
and jmh.n_dt_invoice >= '{date1}'::date
and jmh.n_dt_invoice <= '{date2}'::date
"""
sql_arr = f"""select
jah.n_number as doc_number,
jah.n_dt_invoice as doc_date,
rp.n_name as suppl,
'' as point,
(jab.n_product->'n_amount')::text::numeric as amount,
0,
(select c_name from ref_products where c_id = {item_id})
from journals_arrivals_bodies jab
join journals_arrivals_headers jah on jab.n_doc_id = jah.n_id
join ref_partners rp ON rp.n_id = jah.n_supplier
where (jab.n_product->'n_product')::text = '{item_id}'
and jab.n_deleted=false
and jah.n_dt_invoice >= '{date1}'::date
and jah.n_dt_invoice <= '{date2}'::date
"""
sqls = []
if not arr_fg and not dep_fg:
return answer
if arr_fg:
sqls.append(sql_arr)
if dep_fg:
sqls.append(sql_move)
sqls = '\nunion all\n'.join(sqls)
sql = f"""select * from (
{sqls}
) as aa
order by doc_date asc, doc_number
"""
# print(sql)
a_data = self.parent._request(sql)
if a_data:
data = {
'lines': [],
'tovar':
a_data[0][6],
'date1':
datetime.datetime.strptime(
date1, '%Y-%m-%d %H:%M:%S').strftime('%d-%m-%y'),
'date2':
datetime.datetime.strptime(
date2, '%Y-%m-%d %H:%M:%S').strftime('%d-%m-%y'),
'arr_total':
0,
'dep_total':
0,
}
for i, row in enumerate(a_data, 1):
d = datetime.datetime.strptime(row[1], '%Y-%m-%d')
r = {
'item': {
'doc': row[0],
'date': d.strftime('%d-%m-%y'),
'suppl': row[2],
'recip': row[3],
'arriv': row[4] or '',
'depart': row[5] or ''
}
}
data['lines'].append(r)
ta = sum([
int(i['item']['arriv']) if i['item']['arriv'] != '' else 0
for i in data['lines']
])
td = sum([
int(i['item']['depart']) if i['item']['depart'] != '' else 0
for i in data['lines']
])
data['arr_total'] = ta
data['dep_total'] = td
inv = Prod_movements(**data)
zip_path = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
with zipfile.ZipFile(zip_path, mode='r') as _zf:
_zf.extract(f'doc_tmpl/{inv.doc_template}', path=self.temp_dir)
t_path = os.path.join(self.temp_dir, 'doc_tmpl', inv.doc_template)
basic = Template(source='', filepath=t_path)
basic_generated = basic.generate(o=inv).render()
fn = os.path.join(self.temp_dir, self.gen_file_name(doc_type))
file_data = basic_generated.getvalue()
with open(fn, 'wb') as _f:
_f.write(file_data)
md5 = self.parent.filesave(fn)
l_file_name = os.path.basename(fn).replace('.ods', '')
link_name = f"""https://sklad71.org/filehash/{l_file_name}.pdf?{md5}"""
print(link_name)
bi = base64.b64encode(file_data)
bi = bi.decode()
# print(bi)
# print(len(bi))
answer = {
"params": args,
"kwargs": kwargs,
"timing": {
"sql": 0,
"process": 0
},
"data": {
"link": link_name,
"file_name": os.path.basename(fn),
"binary": bi
}
}
return answer
class TestOOTemplating(unittest.TestCase):
def setUp(self):
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.odt')
self._source = open(filepath, mode='rb')
self.oot = Template(self._source)
self.data = {
'first_name':
u'Trente',
'last_name':
u'Møller',
'ville':
u'Liège',
'friends': [{
'first_name': u'Camille',
'last_name': u'Salauhpe'
}, {
'first_name': u'Mathias',
'last_name': u'Lechat'
}],
'hobbies': [u'Music', u'Dancing', u'DJing'],
'animals': [u'Felix da housecat', u'Dog eat Dog'],
'images': [(open(os.path.join(thisdir, 'one.jpg'),
'rb'), 'image/jpeg', None, None, 'One'),
(open(os.path.join(thisdir, 'two.png'),
'rb'), 'image/png', '2cm', '2.2cm', 'Two')],
'oeuf':
open(os.path.join(thisdir, 'egg.jpg'), 'rb'),
'footer':
u'We sell stuff'
}
def tearDown(self):
self._source.close()
for image in self.data['images']:
image[0].close()
self.data['oeuf'].close()
def test_init(self):
"Testing the correct handling of the styles.xml and content.xml files"
self.assertTrue(isinstance(self.oot.stream, list))
self.assertEqual(self.oot.stream[0],
(PI, ('relatorio', 'content.xml'), None))
self.assertTrue((PI, ('relatorio', 'content.xml'),
None) in self.oot.stream)
def test_directives(self):
"Testing the directives interpolation"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://foo">foo</text:a>
</xml>'''
interpolated = self.oot.insert_directives(xml)
root_interpolated = lxml.etree.parse(interpolated).getroot()
child = root_interpolated[0]
self.assertEqual(child.get('{http://genshi.edgewall.org/}replace'),
'__relatorio_escape_invalid_chars(foo)')
def test_column_looping(self):
xml = b'''
<table:table
xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
xmlns:xlink="http://www.w3.org/1999/xlink"
table:name="Tableau1"
table:style-name="Tableau1">
<table:table-column table:style-name="Tableau1.A"
table:number-columns-repeated="2"/>
<table:table-column table:style-name="Tableau1.C"/>
<table:table-column table:style-name="Tableau1.A"/>
<table:table-column table:style-name="Tableau1.E"/>
<table:table-header-rows>
<table:table-row table:style-name="Tableau1.1">
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">Brol</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">
<text:a xlink:type="simple"
xlink:href="relatorio://for each="title in titles"">for each="title in titles"</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">${title}</text:p>
<text:p text:style-name="Table_20_Heading"/>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.E1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">Truc</text:p>
</table:table-cell>
</table:table-row>
</table:table-header-rows>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A2"
table:number-columns-spanned="5"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio://for%20each=%22items%20in%20lst%22">for each="items in lst"</text:a>
</text:p>
</table:table-cell>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
</table:table-row>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">Brol</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio://for%20each=%22item%20in%20items%22">for each="item in items"</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">${item}</text:p>
<text:p text:style-name="Table_20_Contents"/>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A2"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">Truc</text:p>
</table:table-cell>
</table:table-row>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A2"
table:number-columns-spanned="5"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
</table:table-row>
</table:table>'''
interpolated = self.oot.insert_directives(xml)
root = lxml.etree.parse(interpolated).getroot()
child2 = root[1]
self.assertEqual(child2.tag, "{%s}repeat" % RELATORIO_URI)
self.assertEqual(child2.get("closing"), "3")
self.assertEqual(child2.get("opening"), "1")
self.assertEqual(len(child2), 1)
child4 = root[3]
self.assertEqual(child4.tag, "{%s}table-header-rows" % OO_TABLE_NS)
row1 = child4[0]
self.assertTrue(
row1.get("{%s}attrs" %
GENSHI_URI).startswith('__relatorio_reset_col_count'))
self.assertEqual(len(row1), 4)
loop = row1[1]
self.assertEqual(loop.tag, "{%s}for" % GENSHI_URI)
cell = loop[0]
self.assertTrue(
cell.get("{%s}attrs" %
GENSHI_URI).startswith('__relatorio_inc_col_count'))
last_row_node = row1[3]
self.assertEqual(last_row_node.tag, "{%s}replace" % GENSHI_URI)
self.assertTrue(
last_row_node.get("value").startswith(
'__relatorio_store_col_count'))
@unittest.skipIf(not getattr(unittest.TestCase, 'assertWarnsRegex', None),
"assertWarns not supported")
def test_statement_no_text_warning(self):
"Test warning for missing statement text"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://*****:*****@unittest.skipIf(not getattr(unittest.TestCase, 'assertWarnsRegex', None),
"assertWarns not supported")
def test_statement_missmatch_text_warning(self):
"Test warning for missing statement text"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://*****:*****@unittest.skipIf(not getattr(unittest.TestCase, 'assertWarnsRegex', None),
"assertWarns not supported")
def test_statement_text_warning_closing(self):
"Test warning for statement text in closing"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://with foo='test'">with foo='test'</text:a>
<text:a xlink:href="relatorio:///with"></text:a>
</xml>'''
with self.assertWarnsRegex(
UserWarning,
r".* corresponding to opening tag 'with foo='test'"):
self.oot.insert_directives(xml)
def test_text_outside_p(self):
"Testing that the tail text of a directive node is handled properly"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://if%20test=%22True%22">if test="True"</text:a>
xxx
<text:p text:style-name="other">yyy</text:p>
zzz
<text:a xlink:href="relatorio:///if">/if</text:a>
aaa
</xml>'''
interpolated = self.oot.insert_directives(xml)
root_interpolated = lxml.etree.parse(interpolated).getroot()
child = root_interpolated[0]
self.assertEqual(child.tag, '{http://genshi.edgewall.org/}if')
self.assertEqual(child.text.strip(), 'xxx')
self.assertEqual(child.tail.strip(), 'aaa')
def test_styles(self):
"Testing that styles get rendered"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
self.assertTrue('We sell stuff' in rendered)
dico = self.data.copy()
del dico['footer']
stream = self.oot.generate(**dico)
self.assertRaises(UndefinedError,
lambda: stream.events.render(encoding='utf-8'))
def test_generate(self):
"Testing that content get rendered"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
self.assertTrue('Bonjour,' in rendered)
self.assertTrue('Trente' in rendered)
self.assertTrue(u'Møller' in rendered)
self.assertTrue('Dog eat Dog' in rendered)
self.assertTrue('Felix da housecat' in rendered)
def test_filters(self):
"Testing the filters with the Translator filter"
stream = self.oot.generate(**self.data)
translated = stream.filter(Translator(pseudo_gettext))
translated_xml = stream_to_string(
translated.events.render(encoding='utf-8'))
self.assertTrue("Hello," in translated_xml)
self.assertTrue("I am an odt templating test" in translated_xml)
self.assertTrue('Felix da housecat' not in translated_xml)
self.assertTrue(u'Félix le chat de la maison' in translated_xml)
self.assertTrue('We sell stuff' not in translated_xml)
self.assertTrue('On vend des choses' in translated_xml)
def test_images(self):
"Testing the image replacement directive"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
styles_idx = rendered.find('<?relatorio styles.xml?>')
tree = lxml.etree.parse(StringIO(rendered[25:styles_idx]))
root = tree.getroot()
images = root.xpath('//draw:frame', namespaces=self.oot.namespaces)
self.assertEqual(len(images), 3)
self.assertFalse(images[0].get('{%s}name' %
self.oot.namespaces['draw']))
self.assertEqual(
images[1].get('{%s}name' % self.oot.namespaces['draw']), 'One')
self.assertEqual(
images[2].get('{%s}name' % self.oot.namespaces['draw']), 'Two')
self.assertEqual(
images[1].get('{%s}width' % self.oot.namespaces['svg']), '1.732cm')
self.assertEqual(
images[1].get('{%s}height' % self.oot.namespaces['svg']),
'1.513cm')
self.assertEqual(
images[2].get('{%s}width' % self.oot.namespaces['svg']), '2cm')
self.assertEqual(
images[2].get('{%s}height' % self.oot.namespaces['svg']), '2.2cm')
def test_regexp(self):
"Testing the regexp used to find relatorio tags"
# a valid expression
group = GENSHI_EXPR.match('for each="foo in bar"').groups()
self.assertEqual(group, (None, 'for', 'each', 'foo in bar'))
# invalid expr
group = GENSHI_EXPR.match('foreach="foo in bar"').groups()
self.assertEqual(group, (None, None, None, None))
# valid closing tags
group = GENSHI_EXPR.match('/for').groups()
self.assertEqual(group, ('/', 'for', None, None))
group = GENSHI_EXPR.match('/for ').groups()
self.assertEqual(group, ('/', 'for', None, None))
# another non matching expr
group = GENSHI_EXPR.match('formatLang("en")').groups()
self.assertEqual(group, (None, None, None, None))
def test_fodt2odt(self):
"Testing converter fodt to odt"
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.fodt')
fod2od(filepath)
def test_generate_fod(self):
"Testing generate fod"
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.fodt')
with open(filepath, mode='rb') as source:
oot = Template(source)
oot.generate(**self.data)
def generate(self, *args, **kwargs):
self.parent._print("*" * 10, " generate ", "*" * 10)
self.parent._print(args)
self.parent._print(kwargs)
self.parent._print("*" * 10, " generate ", "*" * 10)
doc_type = kwargs.get('doc_type')
doc_number = kwargs.get('doc_number')
data = kwargs.get('data')
answer = {
"params": args,
"kwargs": kwargs,
}
if doc_type and doc_number and not data:
#пришел документ и его номер, достаем данные из базы, делаем обработку
if doc_type == 'shipment':
doc_gen = Shipment
data = self._generate_short_shipment(doc_number)
elif doc_type == 'arrival':
doc_gen = Arrival
data = self._generate_short_arrival(doc_number)
elif doc_type == 'rest':
doc_gen = Rest
data = self._generate_short_rest(doc_number)
elif doc_type == 'movement':
doc_gen = Movement
data = self._generate_short_movement(doc_number)
elif doc_type == 'balance':
doc_gen = Balance
data = self._generate_balance()
if data:
#есть данные
inv = doc_gen(**data)
zip_path = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
with zipfile.ZipFile(zip_path, mode='r') as _zf:
_zf.extract(f'doc_tmpl/{inv.doc_template}', path=self.temp_dir)
t_path = os.path.join(self.temp_dir, 'doc_tmpl', inv.doc_template)
basic = Template(source='', filepath=t_path)
basic_generated = basic.generate(o=inv).render()
fn = os.path.join(self.temp_dir, self.gen_file_name(doc_type))
file_data = basic_generated.getvalue()
with open(fn, 'wb') as _f:
_f.write(file_data)
md5 = self.parent.filesave(fn)
l_file_name = os.path.basename(fn).replace('.ods', '')
link_name = f"""https://sklad71.org/filehash/{l_file_name}.pdf?{md5}"""
print(link_name)
bi = base64.b64encode(file_data)
bi = bi.decode()
# print(bi)
# print(len(bi))
answer = {
"params": args,
"kwargs": kwargs,
"timing": {
"sql": 0,
"process": 0
},
"data": {
"link": link_name,
"file_name": os.path.basename(fn),
"binary": bi
}
}
return answer
# from relatorio.templates.opendocument import Template
# from data import sched
# basic = Template(source='', filepath='schedules-template.odt')
# basic_generated = basic.generate(o=sched).render()
# file('generated-schedules.odt', 'wb').write(basic_generated.getvalue())
# basic = Template(source='', filepath='schedules-template.odt')
# file('generated-schedules.odt', 'wb').write(basic.generate(o=sched).render().getvalue())
from common import inv
from relatorio.templates.opendocument import Template
basic = Template(source='', filepath='basic.odt')
open('bonham_basic.odt', 'wb').write(basic.generate(o=inv).render().getvalue())
from relatorio.templates.opendocument import Template
from exdata import inv
# basic = Template(source='', filepath='schedules-template.odt')
# basic_generated = basic.generate(o=sched).render()
# file('generated-schedules.odt', 'wb').write(basic_generated.getvalue())
basic = Template(source='', filepath='from-basic-nfor.odt')
open('generated-ex-nfor.odt',
'wb').write(basic.generate(o=inv).render().getvalue())
# from common import inv
# from relatorio.templates.opendocument import Template
# basic = Template(source='', filepath='basic.odt')
# open('bonham_basic.odt', 'wb').write(basic.generate(o=inv).render().getvalue())
class TestOOTemplating(unittest.TestCase):
def setUp(self):
thisdir = os.path.dirname(__file__)
filepath = os.path.join(thisdir, 'test.odt')
self.oot = Template(open(filepath, mode='rb'))
self.data = {'first_name': u'Trente',
'last_name': u'Møller',
'ville': u'Liège',
'friends': [{'first_name': u'Camille',
'last_name': u'Salauhpe'},
{'first_name': u'Mathias',
'last_name': u'Lechat'}],
'hobbies': [u'Music', u'Dancing', u'DJing'],
'animals': [u'Felix da housecat', u'Dog eat Dog'],
'images': [(open(os.path.join(thisdir, 'one.jpg'), 'rb'),
'image/jpeg'),
(open(os.path.join(thisdir, 'two.png'), 'rb'),
'image/png')],
'oeuf': open(os.path.join(thisdir, 'egg.jpg'), 'rb'),
'footer': u'We sell stuff'}
def test_init(self):
"Testing the correct handling of the styles.xml and content.xml files"
self.assertTrue(isinstance(self.oot.stream, list))
self.assertEqual(
self.oot.stream[0], (PI, ('relatorio', 'content.xml'), None))
self.assertTrue(
(PI, ('relatorio', 'content.xml'), None) in self.oot.stream)
def test_directives(self):
"Testing the directives interpolation"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://foo">foo</text:a>
</xml>'''
interpolated = self.oot.insert_directives(xml)
root_interpolated = lxml.etree.parse(interpolated).getroot()
child = root_interpolated[0]
self.assertEqual(
child.get('{http://genshi.edgewall.org/}replace'), 'foo')
def test_column_looping(self):
xml = b'''
<table:table
xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
xmlns:xlink="http://www.w3.org/1999/xlink"
table:name="Tableau1"
table:style-name="Tableau1">
<table:table-column table:style-name="Tableau1.A"
table:number-columns-repeated="2"/>
<table:table-column table:style-name="Tableau1.C"/>
<table:table-column table:style-name="Tableau1.A"/>
<table:table-column table:style-name="Tableau1.E"/>
<table:table-header-rows>
<table:table-row table:style-name="Tableau1.1">
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">Brol</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">
<text:a xlink:type="simple"
xlink:href="relatorio://for each="title in titles"">for each="title in titles"</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">${title}</text:p>
<text:p text:style-name="Table_20_Heading"/>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.E1"
office:value-type="string">
<text:p text:style-name="Table_20_Heading">Truc</text:p>
</table:table-cell>
</table:table-row>
</table:table-header-rows>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A2"
table:number-columns-spanned="5"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio://for%20each=%22items%20in%20lst%22">for each="items in lst"</text:a>
</text:p>
</table:table-cell>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
</table:table-row>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">Brol</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio://for%20each=%22item%20in%20items%22">for each="item in items"</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">${item}</text:p>
<text:p text:style-name="Table_20_Contents"/>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A3"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:table-cell table:style-name="Tableau1.A2"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">Truc</text:p>
</table:table-cell>
</table:table-row>
<table:table-row>
<table:table-cell table:style-name="Tableau1.A2"
table:number-columns-spanned="5"
office:value-type="string">
<text:p text:style-name="Table_20_Contents">
<text:a xlink:type="simple"
xlink:href="relatorio:///for">/for</text:a>
</text:p>
</table:table-cell>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
<table:covered-table-cell/>
</table:table-row>
</table:table>'''
interpolated = self.oot.insert_directives(xml)
root = lxml.etree.parse(interpolated).getroot()
child2 = root[1]
self.assertEqual(child2.tag, "{%s}repeat" % RELATORIO_URI)
self.assertEqual(child2.get("closing"), "3")
self.assertEqual(child2.get("opening"), "1")
self.assertEqual(len(child2), 1)
child4 = root[3]
self.assertEqual(child4.tag, "{%s}table-header-rows" % OO_TABLE_NS)
row1 = child4[0]
self.assertTrue(row1.get("{%s}attrs" % GENSHI_URI)
.startswith('__relatorio_reset_col_count'))
self.assertEqual(len(row1), 4)
loop = row1[1]
self.assertEqual(loop.tag, "{%s}for" % GENSHI_URI)
cell = loop[0]
self.assertTrue(cell.get("{%s}attrs" % GENSHI_URI)
.startswith('__relatorio_inc_col_count'))
last_row_node = row1[3]
self.assertEqual(last_row_node.tag, "{%s}replace" % GENSHI_URI)
self.assertTrue(last_row_node.get("value")
.startswith('__relatorio_store_col_count'))
def test_text_outside_p(self):
"Testing that the tail text of a directive node is handled properly"
xml = b'''<xml xmlns:text="urn:text" xmlns:xlink="urn:xlink">
<text:a xlink:href="relatorio://if%20test=%22True%22">if test="True"</text:a>
xxx
<text:p text:style-name="other">yyy</text:p>
zzz
<text:a xlink:href="relatorio:///if">/if</text:a>
aaa
</xml>'''
interpolated = self.oot.insert_directives(xml)
root_interpolated = lxml.etree.parse(interpolated).getroot()
child = root_interpolated[0]
self.assertEqual(child.tag, '{http://genshi.edgewall.org/}if')
self.assertEqual(child.text.strip(), 'xxx')
self.assertEqual(child.tail.strip(), 'aaa')
def test_styles(self):
"Testing that styles get rendered"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
self.assertTrue('We sell stuff' in rendered)
dico = self.data.copy()
del dico['footer']
stream = self.oot.generate(**dico)
self.assertRaises(UndefinedError,
lambda: stream.events.render(encoding='utf-8'))
def test_generate(self):
"Testing that content get rendered"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
self.assertTrue('Bonjour,' in rendered)
self.assertTrue('Trente' in rendered)
self.assertTrue(u'Møller' in rendered)
self.assertTrue('Dog eat Dog' in rendered)
self.assertTrue('Felix da housecat' in rendered)
def test_filters(self):
"Testing the filters with the Translator filter"
stream = self.oot.generate(**self.data)
translated = stream.filter(Translator(pseudo_gettext))
translated_xml = stream_to_string(
translated.events.render(encoding='utf-8'))
self.assertTrue("Hello," in translated_xml)
self.assertTrue("I am an odt templating test" in translated_xml)
self.assertTrue('Felix da housecat' not in translated_xml)
self.assertTrue(u'Félix le chat de la maison' in translated_xml)
self.assertTrue('We sell stuff' not in translated_xml)
self.assertTrue('On vend des choses' in translated_xml)
def test_images(self):
"Testing the image replacement directive"
stream = self.oot.generate(**self.data)
rendered = stream_to_string(stream.events.render(encoding='utf-8'))
styles_idx = rendered.find('<?relatorio styles.xml?>')
tree = lxml.etree.parse(StringIO(rendered[25:styles_idx]))
root = tree.getroot()
images = root.xpath('//draw:frame', namespaces=self.oot.namespaces)
self.assertEqual(len(images), 3)
self.assertEqual(
images[0].get('{%s}name' % self.oot.namespaces['draw']), "")
self.assertEqual(
images[1].get('{%s}name' % self.oot.namespaces['draw']), '')
self.assertEqual(
images[1].get('{%s}width' % self.oot.namespaces['svg']), '1.732cm')
self.assertEqual(
images[1].get('{%s}height' % self.oot.namespaces['svg']),
'1.513cm')
self.assertEqual(
images[2].get('{%s}width' % self.oot.namespaces['svg']), '1.732cm')
self.assertEqual(
images[2].get('{%s}height' % self.oot.namespaces['svg']),
'1.513cm')
def test_regexp(self):
"Testing the regexp used to find relatorio tags"
# a valid expression
group = GENSHI_EXPR.match('for each="foo in bar"').groups()
self.assertEqual(group, (None, 'for', 'each', 'foo in bar'))
# invalid expr
group = GENSHI_EXPR.match('foreach="foo in bar"').groups()
self.assertEqual(group, (None, None, None, None))
# valid closing tags
group = GENSHI_EXPR.match('/for').groups()
self.assertEqual(group, ('/', 'for', None, None))
group = GENSHI_EXPR.match('/for ').groups()
self.assertEqual(group, ('/', 'for', None, None))
# another non matching expr
group = GENSHI_EXPR.match('formatLang("en")').groups()
self.assertEqual(group, (None, None, None, None))
def eff_report(request, user_name):
context = __process_dates(request)
context['export_allowed'] = True
if not (request.user.has_perm('eff.view_billable') and request.user.has_perm('eff.view_wage')):
if request.user.username != user_name:
return HttpResponseRedirect('/accounts/login/?next=%s' % quote(request.get_full_path()))
else:
if 'export' in request.GET:
return HttpResponseRedirect('/accounts/login/?next=%s' % quote(request.get_full_path()))
else:
del context['export_allowed']
from_date = context['from_date']
to_date = context['to_date']
user = User.objects.get(username=user_name)
project = None
if 'project' in request.GET:
project = request.GET['project']
context['project'] = project
# detailed log report
context['report'] = user.get_profile().report(from_date, to_date, project)
if 'export' in request.GET:
if request.GET['export'] == 'odt':
if 'detailed' in request.GET:
basic = Template(source=None, filepath=os.path.join(cur_dir, '../templates/reporte_usuario_detallado.odt'))
report_data = format_report_data_user(context['report'], user, from_date, to_date, True)
basic_generated = basic.generate(o=report_data).render()
resp = HttpResponse(basic_generated.getvalue(), mimetype='application/vnd.oasis.opendocument.text')
cd = 'filename=reverse_billing-%s-%s-logs.odt' % (from_date.year, from_date.strftime("%m"), )
resp['Content-Disposition'] = cd
return resp
else:
basic = Template(source=None, filepath=os.path.join(cur_dir, '../templates/reporte_usuario.odt'))
report_by_project = list(TimeLog.get_summary_per_project(user.get_profile(), from_date, to_date, True))
report_by_project.sort(cmp=lambda (x0,x1,x2,x3,x4), (y0,y1,y2,y3,y4) : cmp(x1,y1))
rep_by_proj = []
for p in set(map(lambda ph: ph[1], report_by_project)):
r4proj = filter(lambda ph: ph[1]==p, report_by_project)
rates = sorted(map(lambda ph: (ph[3], ph[4]), r4proj), reverse=True)
rep_by_proj.append((r4proj[0][0], r4proj[0][1], r4proj[0][2], rates))
report_data = format_report_data_user(rep_by_proj, user, from_date, to_date)
basic_generated = basic.generate(o=report_data).render()
resp = HttpResponse(basic_generated.getvalue(), mimetype='application/vnd.oasis.opendocument.text')
cd = 'filename=reverse_billing-%s-%s.odt' % (from_date.year, from_date.strftime("%m"), )
resp['Content-Disposition'] = cd
return resp
elif request.GET['export'] == 'csv':
response = HttpResponse(mimetype='text/csv')
if 'detailed' in request.GET:
cd = 'attachment; filename=reverse_billing_%s_%s_%s_logs.csv' % (user_name, from_date, to_date, )
response['Content-Disposition'] = cd
report_data = format_report_data_user(context['report'], user, from_date, to_date, True)
t = loader.get_template('csv/reporte_usuario_detallado.txt')
c = Context({'data': report_data['user_data']['hs_detail'],})
else:
cd = 'attachment; filename=reverse_billing_%s_%s_%s.csv' % (user_name, from_date, to_date, )
response['Content-Disposition'] = cd
report_by_project = list(TimeLog.get_summary_per_project(user.get_profile(), from_date, to_date))
report_by_project.sort(cmp=lambda (x0,x1,x2,x3), (y0,y1,y2,y3) : cmp(x3,y3))
report_data = format_report_data_user(report_by_project, user, from_date, to_date)
t = loader.get_template('csv/reporte_usuario.txt')
c = Context({'data': report_data['user_hours'],})
response.write(t.render(c))
return response
# report grouped by project
report_by_project = list(TimeLog.get_summary_per_project(user.get_profile(), from_date, to_date))
report_by_project.sort(cmp=lambda (x0,x1,x2,x3), (y0,y1,y2,y3) : cmp(x3,y3))
context['username'] = user_name
context['target_user'] = user
# per-project report
context['report_by_project'] = report_by_project
context['projects'] = sorted(map(lambda p: p[1], report_by_project))
# detailed total of hours between [from_date, to_date]
totalHrs = 0
for r in context['report']:
totalHrs += r[3]
context['TotalHrsDetailed'] = totalHrs
# total of hours between [from_date, to_date]
totalHrs = 0
for r in context['report_by_project']:
totalHrs += r[3]
context['TotalHrs'] = totalHrs
for flag in (OVERTIME_FLAG, MONTHLY_FLAG):
if flag in request.GET:
context[flag] = request.GET[flag]
context['navs'] = [('prev', 'previo', '«'), ('next', 'siguiente', '»')]
return render_to_response('reporte.html', context)
def download_stock_picking(stock_picking, model, type_document_partner_it, stock_picking_id, filename=None, **kw):
cr, uid, context = request.cr, request.uid, request.context
stock_picking = request.registry[model]
stock_picking = stock_picking.browse(cr, uid, int(stock_picking_id), context)
lines = []
i = 0
for item in stock_picking.move_lines:
codigo = ""
description = ""
unidad_de_medida = ""
i = i + 1
if item.product_id.default_code:
codigo = item.product_id.default_code
if item.name:
description = str(item.name).upper()
if item.product_uom.name:
unidad_de_medida = item.product_uom.name
lines.append({
"item": i,
"codigo": codigo,
"description": description,
"qty": int(item.product_qty),
"unit_uom": unidad_de_medida,
"peso": "",
})
#verificar si existen datos y poner "- -" para que no salga False
date = ""
min_date = ""
origin_address = ""
delivery_address_id = ""
name = ""
nro_documento = ""
vehicle_transport = ""
name_transport = ""
addres_transport = ""
ruc_transport = ""
type_document_partner_it = ""
delivery_address = ""
if stock_picking.date:
date = str(stock_picking.date)[0:11]
if stock_picking.min_date:
min_date = str(stock_picking.min_date)[0:11]
if stock_picking.origin_address_id.street:
origin_address = str(stock_picking.origin_address_id.street)[0:92]
if stock_picking.delivery_address_id.street:
delivery_address = str(stock_picking.delivery_address_id.street)[0:92]
if stock_picking.partner_id.name:
name = str(stock_picking.partner_id.name)
if stock_picking.partner_id.nro_documento:
nro_documento = stock_picking.partner_id.nro_documento
if stock_picking.driver_id.vehicle_id.model_id.brand_id.name != False and stock_picking.driver_id.vehicle_id.license_plate != False:
vehicle_transport = str(stock_picking.driver_id.vehicle_id.model_id.brand_id.name) + " - " + str(stock_picking.driver_id.vehicle_id.license_plate)
if stock_picking.carrier_id.partner_id.name:
name_transport = stock_picking.carrier_id.partner_id.name
if stock_picking.carrier_id.partner_id.street:
addres_transport = str(stock_picking.carrier_id.partner_id.street)
if stock_picking.carrier_id.partner_id.nro_documento:
ruc_transport = stock_picking.carrier_id.partner_id.nro_documento
if stock_picking.picking_type_id.name:
type_document_partner_it = stock_picking.picking_type_id.name
datas = {
"date": date,
"min_date": min_date,
"origin_address": origin_address,
"delivery_address": delivery_address,
"name": name,
"nro_documento": nro_documento,
"vehicle_transport": vehicle_transport,
"name_transport": name_transport,
"addres_transport": addres_transport,
"constancia": "",
"ruc_transport": ruc_transport,
"nro_licencia": "",
"nro_constancia": "",
"lines": lines,
#"type_document_partner_it": type_document_partner_it,
"null": ""
}
stock_picking_path = openerp.modules.get_module_resource('fxo_mv_print_documents','templates', "stock_picking.odt")
if not stock_picking_path:
error = {
'code': 200,
'message': "Odoo Server Error",
'data': "Not found file template in module!."
}
return werkzeug.exceptions.InternalServerError(simplejson.dumps(error))
try:
basic = Template(source="", filepath=stock_picking_path)
except:
error = {
'code': 200,
'message': "Odoo Server Error",
'data': "You do not have permission to read\nfile template!."
}
return werkzeug.exceptions.InternalServerError(simplejson.dumps(error))
basic_generated = basic.generate(o=datas).render()
filecontent = basic_generated.getvalue()
if not filecontent:
return request.not_found()
else:
if not filename:
filename = '%s_%s' % (model.replace('.', '_'), wid)
return request.make_response(filecontent,
[('Content-Type', 'application/octet-stream'),
('Content-Disposition', content_disposition(filename))])
from relatorio.templates.opendocument import Template
from data import sched
# basic = Template(source='', filepath='schedules-template.odt')
# basic_generated = basic.generate(o=sched).render()
# file('generated-schedules.odt', 'wb').write(basic_generated.getvalue())
basic = Template(source='', filepath='schedules-template-p-l.odt')
open('generated-iftest.odt', 'wb').write(basic.generate(o=sched).render().getvalue())
# from common import inv
# from relatorio.templates.opendocument import Template
# basic = Template(source='', filepath='basic.odt')
# open('bonham_basic.odt', 'wb').write(basic.generate(o=inv).render().getvalue())
#!/usr/bin/python
from relatorio.templates.opendocument import Template
import sys
import fileinput
transaction_separator = "\n\n"
description_separators = ['|', ':']
invoice_template = Template(source=None, filepath='invoice.odt')
infile = file(sys.argv[1]).read()
transactions = infile.split(transaction_separator)
for transaction in transactions:
transaction_dict = dict()
transaction_dict['invoiced'] = False
transaction_dict['total'] = False
transaction_dict['description'] = 'Miscellaneous Hardware'
transaction_lines = transaction.splitlines()
#The first line of each transaction is its overall description
desc_line = transaction_lines[0].split(' ', 1)
transaction_dict['date'] = desc_line[0]
transaction_dict['customer'] = desc_line[1]
for sep in description_separators:
if sep in desc_line[1]:
desc_split = desc_line[1].split(sep)
transaction_dict['customer'] = desc_split[0].strip('* ')
transaction_dict['description'] = desc_split[1].strip()
