def create_aeroo_report(self, cr, uid, ids, data, report_xml, context=None, output='odt'):
""" Returns an aeroo report generated with aeroolib
"""
pool = pooler.get_pool(cr.dbname)
if not context:
context={}
context = context.copy()
if self.name=='report.printscreen.list':
context['model'] = data['model']
context['ids'] = ids
print_id = context.get('print_id', False)
aeroo_print = self.active_prints[print_id] # Aeroo print object
aeroo_print.subreports = []
#self.oo_subreports[print_id] = []
objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) or []
oo_parser = self.parser(cr, uid, self.name2, context=context)
oo_parser.localcontext.update(context)
oo_parser.set_context(objects, data, ids, report_xml.report_type)
self.set_xml_data_fields(objects, oo_parser) # Get/Set XML
oo_parser.localcontext['data'] = data
oo_parser.localcontext['user_lang'] = context.get('lang', False)
if len(objects)>0:
oo_parser.localcontext['o'] = objects[0]
xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext)
oo_parser.localcontext.update(xfunc.functions)
#company_id = objects and 'company_id' in objects[0]._table._columns.keys() and \
# objects[0].company_id and objects[0].company_id.id or False # for object company usage
company_id = False
style_io=self.get_styles_file(cr, uid, report_xml, company=company_id, context=context)
if report_xml.tml_source in ('file', 'database'):
if not report_xml.report_sxw_content or report_xml.report_sxw_content=='False':
raise osv.except_osv(_('Error!'), _('No template found!'))
file_data = base64.decodestring(report_xml.report_sxw_content)
else:
file_data = self.get_other_template(cr, uid, data, oo_parser)
if not file_data and not report_xml.report_sxw_content:
self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode
return False, output
#elif file_data:
# template_io = StringIO()
# template_io.write(file_data or report_xml.report_sxw_content)
# basic = Template(source=template_io, styles=style_io)
else:
if report_xml.preload_mode == 'preload' and hasattr(self, 'serializer'):
serializer = copy.copy(self.serializer)
serializer.apply_style(style_io)
template_io = serializer.template
else:
template_io = StringIO()
template_io.write(file_data or base64.decodestring(report_xml.report_sxw_content) )
serializer = OOSerializer(template_io, oo_styles=style_io)
try:
basic = Template(source=template_io, serializer=serializer)
except Exception, e:
self._raise_exception(e, print_id)
def _render_aeroo(self, template, data, output_format):
"""Generate the aeroo report binary from the template.
:param template: the Libreoffice template to use
:param data: the data used for rendering the report
:param output_format: the output format
:return: the report's binary data
"""
# The first given record is
template_io = BytesIO()
template_io.write(template)
serializer = OOSerializer(template_io)
report_context = GenshiContext(**data)
report_context.update(self._get_aeroo_extra_functions())
report_context['t'] = AerooNamespace()
output = Template(source=template_io, serializer=serializer)\
.generate(report_context).render().getvalue()
if self.aeroo_in_format != output_format:
output = self._convert_aeroo_report(output, output_format)
return output
def create_aeroo_report(self, cr, uid, ids, data, report_xml, context):
""" Return an aeroo report generated with aeroolib
"""
context = context.copy()
assert report_xml.out_format.code in (
'oo-odt',
'oo-ods',
'oo-doc',
'oo-xls',
'oo-csv',
'oo-pdf',
)
assert report_xml.in_format in ('oo-odt', 'oo-ods')
output_format = report_xml.out_format.code[3:]
input_format = report_xml.in_format[3:]
oo_parser = self.parser(cr, uid, self.name2, context=context)
env = Environment(cr, uid, context)
objects = env[self.table].browse(ids)
oo_parser.localcontext.update(context)
oo_parser.set_context(objects, data, ids, report_xml.report_type)
oo_parser.localcontext['data'] = data
oo_parser.localcontext['user_lang'] = context.get('lang', False)
oo_parser.localcontext['o'] = objects[0]
xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext)
oo_parser.localcontext.update(xfunc.functions)
template = report_xml.get_aeroo_report_template(objects[0])
template_io = StringIO()
template_io.write(template)
serializer = OOSerializer(template_io)
basic = Template(source=template_io,
serializer=serializer,
lookup=DynamicLookup)
data = basic.generate(**oo_parser.localcontext).render().getvalue()
if input_format != output_format:
temp_file = self.generate_temporary_file(cr, uid, ids, data,
input_format)
filedir, filename = os.path.split(temp_file.name)
libreoffice_location = (
report_xml.env['ir.config_parameter'].get_param(
'report_aeroo.libreoffice_location'))
if not libreoffice_location:
raise ValidationError(
_('Aeroo reports are wrongly configured. '
'The global parameter report_aeroo.libreoffice_location '
'must be defined.'))
cmd = [
libreoffice_location, "--headless", "--convert-to",
output_format, "--outdir", filedir, temp_file.name
]
self.run_subprocess(cr, uid, ids, report_xml, temp_file, cmd)
output_filename = temp_file.name[:-3] + output_format
with open(output_filename, 'r') as f:
data = f.read()
os.remove(temp_file.name)
os.remove(output_filename)
return data, output_format
def create_aeroo_report(self, cr, uid, ids, data, report_xml, context=None, output='odt'):
""" Returns an aeroo report generated with aeroolib
"""
pool = pooler.get_pool(cr.dbname)
if not context:
context={}
context = context.copy()
if self.name=='report.printscreen.list':
context['model'] = data['model']
context['ids'] = ids
objects = not context.get('no_objects', False) and self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) or []
oo_parser = self.parser(cr, uid, self.name2, context=context)
oo_parser.objects = objects
self.set_xml_data_fields(objects, oo_parser) # Get/Set XML
oo_parser.localcontext['objects'] = objects
oo_parser.localcontext['data'] = data
oo_parser.localcontext['user_lang'] = context.get('lang', False)
if len(objects)==1:
oo_parser.localcontext['o'] = objects[0]
xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext)
oo_parser.localcontext.update(xfunc.functions)
company_id = objects and 'company_id' in objects[0]._table._columns.keys() and \
objects[0].company_id and objects[0].company_id.id or False # for object company usage
style_io=self.get_styles_file(cr, uid, report_xml, company=company_id, context=context)
if report_xml.tml_source in ('file', 'database'):
file_data = base64.decodestring(report_xml.report_sxw_content)
else:
file_data = self.get_other_template(cr, uid, data, oo_parser)
if not file_data and not report_xml.report_sxw_content:
return False, output
#elif file_data:
# template_io = StringIO()
# template_io.write(file_data or report_xml.report_sxw_content)
# basic = Template(source=template_io, styles=style_io)
else:
if report_xml.preload_mode == 'preload' and hasattr(self, 'serializer'):
serializer = copy.copy(self.serializer)
serializer.apply_style(style_io)
template_io = serializer.template
else:
template_io = StringIO()
template_io.write(file_data or base64.decodestring(report_xml.report_sxw_content) )
serializer = OOSerializer(template_io, oo_styles=style_io)
basic = Template(source=template_io, serializer=serializer)
#if not file_data:
# return False, output
#basic = Template(source=template_io, serializer=serializer)
aeroo_ooo = context.get('aeroo_ooo', False)
oo_parser.localcontext['include_subreport'] = self._subreport(cr, uid, output='odt', aeroo_ooo=aeroo_ooo, context=context)
oo_parser.localcontext['include_document'] = self._include_document(aeroo_ooo)
####### Add counter functons to localcontext #######
oo_parser.localcontext.update({'def_inc':self._def_inc,
'get_inc':self._get_inc,
'prev':self._prev,
'next':self._next})
user_name = pool.get('res.users').browse(cr, uid, uid, {}).name
model_id = pool.get('ir.model').search(cr, uid, [('model','=',context['active_model'])])[0]
model_name = pool.get('ir.model').browse(cr, uid, model_id).name
#basic = Template(source=None, filepath=odt_path)
basic.Serializer.add_title(model_name)
basic.Serializer.add_creation_user(user_name)
module_info = load_information_from_description_file('report_aeroo')
version = module_info['version']
basic.Serializer.add_generator_info('Aeroo Lib/%s Aeroo Reports/%s' % (aeroolib.__version__, version))
basic.Serializer.add_custom_property('Aeroo Reports %s' % version, 'Generator')
basic.Serializer.add_custom_property('OpenERP %s' % release.version, 'Software')
basic.Serializer.add_custom_property(module_info['website'], 'URL')
basic.Serializer.add_creation_date(time.strftime('%Y-%m-%dT%H:%M:%S'))
try:
data = basic.generate(**oo_parser.localcontext).render().getvalue()
except Exception, e:
tb_s = reduce(lambda x, y: x+y, traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback))
self.logger(_("Report generation error!")+'\n'+tb_s, netsvc.LOG_ERROR)
for sub_report in self.oo_subreports:
os.unlink(sub_report)
raise Exception(_("Aeroo Reports: Error while generating the report."), e, str(e), _("For more reference inspect error logs."))
def complex_report(self, docids, data, report, ctx):
""" Returns an aeroo report generated by aeroolib
"""
self.model = ctx.get('active_model', False)
# tmpl_type = 'odt'
self.record_ids = docids
self.ctx = ctx
self.company = self.env.user.company_id
self.report = report
#=======================================================================
def barcode(barcode_type,
value,
width=600,
height=100,
humanreadable=0):
# TODO check that asimage and barcode both accepts width and height
img = self.env['ir.actions.report'].barcode(
barcode_type,
value,
width=width,
height=height,
humanreadable=humanreadable)
return self._asimage(base64.b64encode(img))
self.localcontext = {
'user': self.env.user,
'user_lang': ctx.get('lang', False),
'data': data,
'time': time,
'asarray': self._asarray,
'average': self._average,
'currency_to_text': self._currency_to_text,
'asimage': self._asimage,
'get_selection_item': self._get_selection_items('item'),
'get_selection_items': self._get_selection_items(),
'get_log': self._get_log,
'asarray': self._asarray,
'__filter': self.__filter, # Don't use in the report template!
'getLang': self._get_lang,
'setLang': self._set_lang,
'formatLang': self._format_lang,
'_': self._translate_text,
'gettext': self._translate_text,
'test': self.test,
'fields': fields,
'company': self.env.user.company_id,
'barcode': barcode,
}
self.localcontext.update(ctx)
self._set_lang(self.company.partner_id.lang)
self._set_objects(self.model, docids)
file_data = None
if report.tml_source == 'database':
if not report.report_data or report.report_data == 'False':
# TODO log report ID etc.
raise MissingError(
_("Aeroo Reports could'nt find report template"))
file_data = b64decode(report.report_data)
elif report.tml_source == 'file':
if not report.report_file or report.report_file == 'False':
# TODO log report ID etc.
raise MissingError(
_("No Aeroo Reports template filename provided"))
file_data = report._read_template()
else:
rec_id = ctx.get('active_id', data.get('id')) or data.get('id')
file_data = self.get_other_template(self.model, rec_id)
if not file_data:
# TODO log report ID etc.
raise MissingError(
_("Aeroo Reports could'nt find report template"))
template_io = BytesIO(file_data)
if report.styles_mode == 'default':
serializer = OOSerializer(template_io)
else:
style_io = BytesIO(self.get_stylesheet(report))
serializer = OOSerializer(template_io, oo_styles=style_io)
basic = Template(source=template_io,
serializer=serializer,
lookup=StrictLookup)
# Add metadata
ser = basic.Serializer
model_obj = self.env.get('ir.model')
model_name = model_obj.search([('model', '=', self.model)])[0].name
ser.add_title(model_name)
user_name = self.env.user.name
ser.add_creation_user(user_name)
module_info = load_information_from_description_file('report_aeroo')
version = module_info['version']
ser.add_generator_info('Aeroo Lib/%s Aeroo Reports/%s' %
(aeroolib_version, version))
ser.add_custom_property('Aeroo Reports %s' % version, 'Generator')
ser.add_custom_property('Odoo %s' % odoo_release.version, 'Software')
ser.add_custom_property(module_info['website'], 'URL')
ser.add_creation_date(time.strftime('%Y-%m-%dT%H:%M:%S'))
file_data = basic.generate(**self.localcontext).render().getvalue()
#=======================================================================
code = mime_dict[report.in_format]
#_logger.info("End process %s (%s), elapsed time: %s" % (self.name, self.model, time.time() - aeroo_print.start_time), logging.INFO) # debug mode
return file_data, code
def extend_trans_generate(lang, modules, cr):
dbname = cr.dbname
pool = pooler.get_pool(dbname)
trans_obj = pool.get('ir.translation')
model_data_obj = pool.get('ir.model.data')
uid = 1
l = pool.models.items()
l.sort()
query = 'SELECT name, model, res_id, module' \
' FROM ir_model_data'
query_models = """SELECT m.id, m.model, imd.module
FROM ir_model AS m, ir_model_data AS imd
WHERE m.id = imd.res_id AND imd.model = 'ir.model' """
if 'all_installed' in modules:
query += ' WHERE module IN ( SELECT name FROM ir_module_module WHERE state = \'installed\') '
query_models += " AND imd.module in ( SELECT name FROM ir_module_module WHERE state = 'installed') "
query_param = None
if 'all' not in modules:
query += ' WHERE module IN %s'
query_models += ' AND imd.module in %s'
query_param = (tuple(modules), )
query += ' ORDER BY module, model, name'
query_models += ' ORDER BY module, model'
cr.execute(query, query_param)
_to_translate = []
def push_translation(module, type, name, id, source, comments=None):
tuple = (module, source, name, id, type, comments or [])
# empty and one-letter terms are ignored, they probably are not meant to be
# translated, and would be very hard to translate anyway.
if not source or len(source.strip()) <= 1:
_logger.debug("Ignoring empty or 1-letter source term: %r", tuple)
return
if tuple not in _to_translate:
_to_translate.append(tuple)
def encode(s):
if isinstance(s, unicode):
return s.encode('utf8')
return s
for (xml_name, model, res_id, module) in cr.fetchall():
module = encode(module)
model = encode(model)
xml_name = "%s.%s" % (module, encode(xml_name))
if not pool.get(model):
_logger.error("Unable to find object %r", model)
continue
exists = pool.get(model).exists(cr, uid, res_id)
if not exists:
_logger.warning("Unable to find object %r with id %d", model,
res_id)
continue
obj = pool.get(model).browse(cr, uid, res_id)
if model == 'ir.ui.view':
d = etree.XML(encode(obj.arch))
#for t in trans_parse_view(d):
# push_translation(module, 'view', encode(obj.model), 0, t)
trans_parse_view(
d, lambda t, s: push_translation(module, 'view',
encode(obj.model), 0, t))
elif model == 'ir.actions.wizard':
service_name = 'wizard.' + encode(obj.wiz_name)
import openerp.netsvc as netsvc
if netsvc.Service._services.get(service_name):
obj2 = netsvc.Service._services[service_name]
for state_name, state_def in obj2.states.iteritems():
if 'result' in state_def:
result = state_def['result']
if result['type'] != 'form':
continue
name = "%s,%s" % (encode(obj.wiz_name), state_name)
def_params = {
'string': ('wizard_field', lambda s: [encode(s)]),
'selection': ('selection', lambda s: [
encode(e[1])
for e in ((not callable(s)) and s or [])
]),
'help': ('help', lambda s: [encode(s)]),
}
# export fields
if not result.has_key('fields'):
_logger.warning("res has no fields: %r", result)
continue
for field_name, field_def in result[
'fields'].iteritems():
res_name = name + ',' + field_name
for fn in def_params:
if fn in field_def:
transtype, modifier = def_params[fn]
for val in modifier(field_def[fn]):
push_translation(
module, transtype, res_name, 0,
val)
# export arch
arch = result['arch']
if arch and not isinstance(arch, UpdateableStr):
d = etree.XML(arch)
for t in trans_parse_view(d):
push_translation(module, 'wizard_view', name,
0, t)
# export button labels
for but_args in result['state']:
button_name = but_args[0]
button_label = but_args[1]
res_name = name + ',' + button_name
push_translation(module, 'wizard_button', res_name,
0, button_label)
elif model == 'ir.model.fields':
try:
field_name = encode(obj.name)
except AttributeError, exc:
_logger.error("name error in %s: %s", xml_name, str(exc))
continue
objmodel = pool.get(obj.model)
if not objmodel or not field_name in objmodel._columns:
continue
field_def = objmodel._columns[field_name]
name = "%s,%s" % (encode(obj.model), field_name)
push_translation(module, 'field', name, 0,
encode(field_def.string))
if field_def.help:
push_translation(module, 'help', name, 0,
encode(field_def.help))
if field_def.translate:
ids = objmodel.search(cr, uid, [])
obj_values = objmodel.read(cr, uid, ids, [field_name])
for obj_value in obj_values:
res_id = obj_value['id']
if obj.name in ('ir.model', 'ir.ui.menu'):
res_id = 0
model_data_ids = model_data_obj.search(
cr, uid, [
('model', '=', model),
('res_id', '=', res_id),
])
if not model_data_ids:
push_translation(module, 'model', name, 0,
encode(obj_value[field_name]))
if hasattr(field_def, 'selection') and isinstance(
field_def.selection, (list, tuple)):
for dummy, val in field_def.selection:
push_translation(module, 'selection', name, 0, encode(val))
elif model == 'ir.actions.report.xml':
name = encode(obj.report_name)
fname = ""
##### Changes for Aeroo ######
if obj.report_type == 'aeroo':
trans_ids = trans_obj.search(cr, uid,
[('type', '=', 'report'),
('res_id', '=', obj.id)])
for t in trans_obj.read(cr, uid, trans_ids, ['name', 'src']):
push_translation(module, "report", t['name'], xml_name,
t['src'])
if obj.in_format in ['oo-odt', 'oo-ods']\
and obj.report_sxw_content:
template_io = StringIO()
template_io.write(
base64.decodestring(obj.report_sxw_content))
serializer = OOSerializer(template_io)
basic = Template(source=template_io, serializer=serializer)
def push_oo_translations(nodes):
for node in nodes:
if not isinstance(node, tuple):
continue
if node[0] == 'TEXT':
push_translation(module, obj.report_type, name,
0, node[1], [str(node[2][2])])
if node[0] == 'SUB':
for n in node[1]:
push_oo_translations(n)
push_oo_translations(basic.stream)
##############################
else:
if obj.report_rml:
fname = obj.report_rml
parse_func = trans_parse_rml
report_type = "report"
elif obj.report_xsl:
fname = obj.report_xsl
parse_func = trans_parse_xsl
report_type = "xsl"
if fname and obj.report_type in ('pdf', 'xsl'):
try:
report_file = misc.file_open(fname)
try:
d = etree.parse(report_file)
for t in parse_func(d.iter()):
push_translation(module, report_type, name, 0,
t)
finally:
report_file.close()
except (IOError, etree.XMLSyntaxError):
_logger.exception(
"couldn't export translation for report %s %s %s",
name, report_type, fname)
from io import BytesIO
from os.path import dirname, abspath
folder = dirname(abspath(__file__))
#===============================================================================
with open(folder+TEMPLATE_NAME, 'rb') as fp:
file_data = fp.read()
with open(folder+TEMPLATE_STYLE, 'rb') as fp:
style_data = fp.read()
template_io = BytesIO()
template_io.write(file_data)
style_io = BytesIO()
style_io.write(style_data)
serializer = OOSerializer(template_io, oo_styles=style_io)
basic = Template(source=template_io, serializer=serializer)
args = {'title': 'Successful test of Aeroo Reports library (aeroolib)',
'some_unusedva_lue':['x','y','z']
}
data = basic.generate(**args).render().getvalue()
with open(TEST_RESULT,"wb") as fp:
fp.write(data)
def create_aeroo_report(self, cr, uid, ids, data, report_xml, context=None, output='odt'):
""" Returns an aeroo report generated with aeroolib
"""
deferred = context.get('deferred_process')
if deferred:
deferred.set_status(_('Started'))
pool = registry(cr.dbname)
if not context:
context={}
context = context.copy()
if self.name=='report.printscreen.list':
context['model'] = data['model']
context['ids'] = ids
print_id = context.get('print_id', False)
aeroo_print = self.active_prints[print_id] # Aeroo print object
aeroo_print.subreports = []
#self.oo_subreports[print_id] = []
oo_parser = self.parser(cr, uid, self.name2, context=context)
aeroo_docs = self.aeroo_docs_enabled(cr) # Detect report_aeroo_docs module
if (aeroo_docs and not report_xml.process_sep or not aeroo_docs) and getattr(oo_parser, 'single', False):
ids = [ids[0]]
objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) or []
# Esto es un parche por error de odoo en report_sxw.py al hacer
# self.setCompany(objects[0].company_id) porque, como el registro
# tiene el campo company, solo agrega al contexto del reporte la
# compania del objeto y el usuario puede no tener permiso para dicha
# cia
objects_for_context = self.getObjects_mod(cr, 1, ids, report_xml.report_type, context) or []
oo_parser.localcontext.update(context)
oo_parser.set_context(objects_for_context, data, ids, report_xml.report_type)
# oo_parser.set_context(objects, data, ids, report_xml.report_type)
self.set_xml_data_fields(objects, oo_parser) # Get/Set XML
oo_parser.localcontext['data'] = data
oo_parser.localcontext['user_lang'] = context.get('lang', False)
if len(objects)>0:
oo_parser.localcontext['o'] = objects[0]
xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext)
oo_parser.localcontext.update(xfunc.functions)
#company_id = objects and 'company_id' in objects[0]._table._columns.keys() and \
# objects[0].company_id and objects[0].company_id.id or False # for object company usage
company_id = False
style_io=self.get_styles_file(cr, uid, report_xml, company=company_id, context=context)
if report_xml.tml_source in ('file', 'database'):
if not report_xml.report_sxw_content or report_xml.report_sxw_content=='False':
raise osv.except_osv(_('Error!'), _('No template found!'))
file_data = base64.decodestring(report_xml.report_sxw_content)
else:
model = context.get('active_model', data.get('model')) or data.get('model')
rec_id = context.get('active_id', data.get('id')) or data.get('id')
file_data = self.get_other_template(cr, uid, model, rec_id, oo_parser)
if not file_data and not report_xml.report_sxw_content:
self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode
return False, output
#elif file_data:
# template_io = StringIO()
# template_io.write(file_data or report_xml.report_sxw_content)
# basic = Template(source=template_io, styles=style_io)
else:
if report_xml.preload_mode == 'preload' and hasattr(self, 'serializer'):
serializer = copy.copy(self.serializer)
serializer.apply_style(style_io)
template_io = serializer.template
else:
template_io = StringIO()
template_io.write(file_data or base64.decodestring(report_xml.report_sxw_content) )
serializer = OOSerializer(template_io, oo_styles=style_io)
try:
basic = Template(source=template_io, serializer=serializer, lookup=DynamicLookup)
except Exception, e:
self._raise_exception(e, print_id)
def generate(self, cr, user, ids, context=None):
contract_id = ids
if isinstance(ids, (list, tuple)):
contract_id = ids[0]
contract = self.read(cr, user, contract_id, [])
service = self.pool.get('brief.services.stage').read(cr, user, contract['service_id'][0], ['template_id'])
if service['template_id']:
template = self.pool.get('ir.attachment').read(cr, user, service['template_id'][0],
['store_fname', 'parent_id'])
dbro = self.pool.get('document.directory').read(cr, user, template['parent_id'][0], ['storage_id'], context)
storage = self.pool.get('document.storage').read(cr, user, dbro['storage_id'][0], ['path'])
filepath = os.path.join(storage['path'], template['store_fname'])
file_data = open(filepath, 'rb').read()
template_io = StringIO()
template_io.write(file_data)
serializer = OOSerializer(template_io)
basic = Template(source=template_io, serializer=serializer)
d = datetime.strptime(contract['contract_date'], '%Y-%m-%d')
date_str = dt.ru_strftime(u"%d %B %Y", d, inflected=True)
if not contract['contract_number']:
raise osv.except_osv('Договор', 'Необходимо ввести номер договора')
if not contract['amount']:
raise osv.except_osv('Договор', 'Необходимо ввести сумму договора')
term = 7
if contract['term'] == 'mounth':
term = 30
elif contract['term'] == 'year':
term = 365
else:
term = 0
o = {
'name': u'-',
'contract_number': contract['contract_number'],
'contract_date': date_str,
'doc_type': contract['doc_type_id'][1] if contract['doc_type_id'] else '-',
'responsible_id': contract['responsible_id'][1] if contract['responsible_id'] else '-',
# Название баннерной или тизерной сети
'web': 'test',
# стоимость услуг цифры
'cost_num': contract['amount'],
# стоимость услуг слова
'cost_word': numeral.in_words(float(contract['amount'])),
# срок предоставления услуги в фомате 30 (тридцать)
'term': term,
# наш генеральный директор
'our_gen_dir': u'-',
# название фирмы
'our_firm_name': u'-',
# наш Юридический адрес
'our_address': u'-',
# Фактический адрес,адрес почтовой корреспонденции наш
'our_fact_address': u'-',
# ИНН / КПП наш
'our_inn': u'-',
# ОГРН наш
'our_ogrn': u'-',
# Код ОКПО наш
'our_okpo': u'-',
# банк наш
'our_bank': u'-',
# к/с наш
'our_ks': u'-',
# р/с наш
'our_rs': u'-',
# бик наш
'our_bik': u'-',
# Тел/факс наш
'our_phone': u'-',
# Web сайт почта наш
'our_site': u'-',
# заказчика e-mail
'partner_mail': u'-',
# название фирмы заказчика
'partner_firm_name': u'-',
# Юридический адрес партнера
'partner_address': u'-',
# Фактический адрес,адрес почтовой корреспонденции партнера
'partner_fact_address': u'-',
# ИНН / КПП партнера
'partner_inn': u'-',
# ОГРН партнера
'partner_ogrn': u'-',
# Код ОКПО партнера
'partner_okpo': u'-',
# банк партнера
'partner_bank': u'-',
# к/с партнера
'partner_ks': u'-',
# р/с партнера
'partner_rs': u'-',
# бик партнера
'partner_bik': u'-',
'partner_kpp': u'-',
# Тел/факс партнера
'partner_phone': u'-',
# Web сайт почта партнера
'partner_site': u'-',
}
if contract['bank_id']:
bank = self.pool.get('res.partner.bank').read(cr, 1, contract['bank_id'][0], [])
o.update({
'partner_mail': bank['email'] or u'-',
'partner_site': bank['site'] or u'-',
'partner_firm_name': bank['fullname'] or u'-',
'partner_address': self.pool.get('res.partner.bank.address').get_address(cr, contract['bank_id'][0]) or u'-',
'partner_fact_address': self.pool.get('res.partner.bank.address').get_address(cr, contract['bank_id'][0], 'fa') or u'-',
'partner_inn': bank['inn'] or u'-',
'partner_kpp': bank['kpp'] or u'-',
'partner_ogrn': bank['ogrn'] or u'-',
'partner_okpo': bank['okpo'] or u'-',
'partner_bank': bank['bank'] or u'-',
'partner_ks': bank['correspondent_account'] or u'-',
'partner_rs': bank['current_account'] or u'-',
'partner_bik': bank['bik'] or u'-',
'partner_phone': bank['phone'] or u'-',
})
if contract['account_id']:
account = self.pool.get('account.account').read(cr, 1, contract['account_id'][0], [])
o.update({
'our_gen_dir': account['responsible'] or u'-',
'our_firm_name': account['full'] or u'-',
'our_address': account['address'] or u'-',
'our_fact_address': account['address'] or u'-',
'our_inn': account['inn'] or u'-',
'our_kpp': account['kpp'] or u'-',
'our_ogrn': u'1127747081406',
'our_okpo': u'13183255',
'our_bank': account['bank'] or u'-',
'our_ks': account['bank_number'] or u'-',
'our_rs': account['account_number'] or u'-',
'our_bik': account['bik'] or u'-',
'our_phone': account['phone'] or u'-',
'our_site': u'UpSale.ru, [email protected]',
})
filename = '{0} {1} {2}'.format(
contract['contract_number'].encode('utf-8'),
contract['partner_id'][1].encode('utf-8'),
contract['service_id'][1].encode('utf-8'), )
#data = [(k, v.encode('cp1251')) for k, v in o.iteritems() if isinstance(v, unicode)]
odt_file = os.path.join(storage['path'], 'tmp.odt')
file(odt_file, 'wb').write(basic.generate(o=o).render().getvalue())
doc_id = self.pool.get('ir.attachment').create(cr, user, {
'name': '{0}.odt'.format(filename, ),
'datas': base64.b64encode(open(odt_file, 'rb').read()),
'datas_fname': '{0}.odt'.format(filename, ),
'res_model': self._name,
'res_id': contract['id']
})
self.write(cr, user, [contract['id']], {'doc_id': doc_id})
return True
from io import BytesIO
from os.path import dirname, abspath
folder = dirname(abspath(__file__))
#===============================================================================
with open(folder + TEMPLATE_NAME, 'rb') as fp:
file_data = fp.read()
with open(folder + TEMPLATE_STYLE, 'rb') as fp:
style_data = fp.read()
template_io = BytesIO()
template_io.write(file_data)
style_io = BytesIO()
style_io.write(style_data)
serializer = OOSerializer(template_io, oo_styles=style_io)
basic = Template(source=template_io, serializer=serializer)
args = {
'title': 'Successful test of Aeroo Reports library (aeroolib)',
'some_unusedva_lue': ['x', 'y', 'z']
}
data = basic.generate(**args).render().getvalue()
with open(TEST_RESULT, "wb") as fp:
fp.write(data)
def generate(self, cr, user, ids, context=None):
disposition_id = ids
if isinstance(ids, (list, tuple)):
disposition_id = ids[0]
disposition = self.read(cr, user, disposition_id, [])
category = self.pool.get('cd.disposition.category').read(cr, user, disposition['category_id'][0], ['template_id'])
if category['template_id']:
template = self.pool.get('ir.attachment').read(cr, user, category['template_id'][0],
['store_fname', 'parent_id'])
dbro = self.pool.get('document.directory').read(cr, user, template['parent_id'][0], ['storage_id'], context)
storage = self.pool.get('document.storage').read(cr, user, dbro['storage_id'][0], ['path'])
filepath = os.path.join(storage['path'], template['store_fname'])
file_data = open(filepath, 'rb').read()
template_io = StringIO()
template_io.write(file_data)
serializer = OOSerializer(template_io)
basic = Template(source=template_io, serializer=serializer)
o = {
'disposition_number': disposition['id'],
'disposition_date': dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['disposition_date'], '%Y-%m-%d'), inflected=True),
'from_date': '-',
'on_date': '-',
'from_date_second': '-',
'on_date_second': '-',
'not_later_date': '-',
'not_later_date_second': '-',
'to_date': '-',
'financier_id': '-',
'period_id': '-',
'seeing': disposition['seeing'] or '-',
'working_off_dates': disposition['working_off_dates'] or '-',
'employee_id': '-',
'job_id': '-',
'next_job_id': '-',
'teacher_job_id': '-',
'department_id': '-',
'next_department_id': '-',
'teacher_department_id': '-',
'trip': disposition['trip'] or '-',
'trip_place': disposition['trip_place'] or '-',
'grade_id': '-',
'reason': disposition['reason'] or '-',
'remark': disposition['remark'] or '-',
'direction_name': disposition['direction_name'] or '-',
'at_rate': int(disposition['at_rate']) or '-',
'date_ot': '-',
'next_attestation': '-',
'motive_rewarding': disposition['motive_rewarding'] or '-',
'promotion_type': disposition['promotion_type'] or '-',
'teacher_id': '-',
'financing_source': disposition['financing_source'] or '-',
'commission_ids': '-',
'term': disposition['term'] or '-',
'term_str': disposition['term_str'] or '-',
'amount': disposition['amount'] or '-',
'amount_str': to_grn(disposition['at_rate']),
'statement_date': '-',
'instate_date': '-',
'salary': disposition['salary'] or '-',
'salary_per': disposition['salary_per'] or '-',
'variable': disposition['variable'] or '-',
'variable_per': disposition['variable_per'] or '-',
'post_probation_grade_id': '-',
'probation_grade_id': '-',
'duration_probation': disposition['duration_probation'] or '-',
'year': disposition['year'] or '-',
'no_work': disposition['no_work'] or '-',
'work_day': disposition['work_day'] or '-',
'fio': disposition['fio'] or '-',
'schedule_date': '-',
'commission_date': '-',
'set_date': '-',
'list_date': '-',
'protocol_date': '-',
'top_date': '-',
'result_date': '-'
}
if disposition['from_date']:
o['from_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['from_date'], '%Y-%m-%d'), inflected=True)
if disposition['on_date']:
o['on_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['on_date'], '%Y-%m-%d'), inflected=True)
if disposition['from_date_second']:
o['from_date_second'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['from_date_second'], '%Y-%m-%d'), inflected=True)
if disposition['on_date_second']:
o['on_date_second'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['on_date_second'], '%Y-%m-%d'), inflected=True)
if disposition['not_later_date']:
o['not_later_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['not_later_date'], '%Y-%m-%d'), inflected=True)
if disposition['not_later_date_second']:
o['not_later_date_second'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['not_later_date_second'], '%Y-%m-%d'), inflected=True)
if disposition['to_date']:
o['to_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['to_date'], '%Y-%m-%d'), inflected=True)
if disposition['date_ot']:
o['date_ot'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['date_ot'], '%Y-%m-%d'), inflected=True)
if disposition['next_attestation']:
o['next_attestation'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['next_attestation'], '%Y-%m-%d'), inflected=True)
if disposition['statement_date']:
o['statement_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['statement_date'], '%Y-%m-%d'), inflected=True)
if disposition['instate_date']:
o['instate_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['instate_date'], '%Y-%m-%d'), inflected=True)
if disposition['schedule_date']:
o['schedule_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['schedule_date'], '%Y-%m-%d'), inflected=True)
if disposition['commission_date']:
o['commission_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['commission_date'], '%Y-%m-%d'), inflected=True)
if disposition['set_date']:
o['set_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['set_date'], '%Y-%m-%d'), inflected=True)
if disposition['list_date']:
o['list_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['list_date'], '%Y-%m-%d'), inflected=True)
if disposition['protocol_date']:
o['protocol_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['protocol_date'], '%Y-%m-%d'), inflected=True)
if disposition['top_date']:
o['top_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['top_date'], '%Y-%m-%d'), inflected=True)
if disposition['result_date']:
o['result_date'] = dt.ru_strftime(u"%d %B %Y", datetime.strptime(disposition['result_date'], '%Y-%m-%d'), inflected=True)
if disposition['financier_id']:
o['financier_id'] = disposition['financier_id'][1]
if disposition['employee_id']:
o['employee_id'] = disposition['employee_id'][1]
if disposition['job_id']:
o['job_id'] = disposition['job_id'][1]
if disposition['teacher_id']:
o['teacher_id'] = disposition['teacher_id'][1]
if disposition['next_job_id']:
o['next_job_id'] = disposition['next_job_id'][1]
if disposition['teacher_job_id']:
o['teacher_job_id'] = disposition['teacher_job_id'][1]
if disposition['department_id']:
o['department_id'] = disposition['department_id'][1]
if disposition['next_department_id']:
o['next_department_id'] = disposition['next_department_id'][1]
if disposition['teacher_department_id']:
o['teacher_department_id'] = disposition['teacher_department_id'][1]
if disposition['grade_id']:
o['grade_id'] = disposition['grade_id'][1]
if disposition['post_probation_grade_id']:
o['post_probation_grade_id'] = disposition['post_probation_grade_id'][1]
if disposition['probation_grade_id']:
o['probation_grade_id'] = disposition['probation_grade_id'][1]
if disposition['commission_ids']:
o['commission_ids'] = ', '.join([x['name'] for x in self.pool.get('res.users').read(cr, 1, disposition['commission_ids'], ['name'])])
if disposition['period_id']:
d = datetime.strptime('2013/10', '%Y/%m').strftime('%B %Y')
o['period_id'] = tools.ustr(d)
filename = 'Распоряжение № {0}'.format(disposition['id'],)
odt_file = os.path.join(storage['path'], 'tmp.odt')
file(odt_file, 'wb').write(basic.generate(o=o).render().getvalue())
doc_id = self.pool.get('ir.attachment').create(cr, user, {
'name': '{0}.odt'.format(filename, ),
'datas': base64.b64encode(open(odt_file, 'rb').read()),
'datas_fname': '{0}.odt'.format(filename, ),
'res_model': self._name,
'res_id': disposition['id']
})
#self.write(cr, user, [disposition['id']], {'doc_id': doc_id})
return doc_id
return False
def create_aeroo_report(self,
cr,
uid,
ids,
data,
report_xml,
context=None,
output='odt',
style_io=None):
""" Returns an aeroo report generated with aeroolib
"""
pool = RegistryManager.get(cr.dbname)
if context is None:
context = {}
else:
context = context.copy()
if self.name == 'report.printscreen.list':
context['model'] = data['model']
context['ids'] = ids
# create parser
oo_parser = self.parser(cr, uid, self.name2, context=context)
objects = not context.get('no_objects', False) and self.getObjects_mod(
cr, uid, ids, report_xml, context, parser=oo_parser) or []
report_obj = pool.get("ir.actions.report.xml")
# check for report forward
if hasattr(oo_parser, "_report_forward"):
report_forward = oo_parser._report_forward(objects)
if report_forward:
report_forward_inst = report_obj._lookup_report(
cr, report_forward["name"])
forward_report_data, forward_report_format = report_forward_inst.create(
cr, uid, report_forward["ids"], data, context)
return self._onResult(
cr,
uid,
objects, (forward_report_data, forward_report_format),
context=context)
# report replacement
file_data = None
if objects and len(objects) == 1:
# get replacement
repl_report_xml, style_io = report_obj._get_replacement(
cr, uid, objects[0], report_xml, context=context)
if repl_report_xml:
if isinstance(repl_report_xml, basestring):
file_data = base64.decodestring(repl_report_xml)
elif repl_report_xml.id != report_xml.id:
return self.create_aeroo_report(cr,
uid,
ids,
data,
repl_report_xml,
context=context,
output=output,
style_io=style_io)
oo_parser.objects = objects
self.set_xml_data_fields(objects, oo_parser) # Get/Set XML
oo_parser.localcontext['objects'] = objects
oo_parser.localcontext['data'] = data
oo_parser.localcontext['user_lang'] = context.get('lang', False)
if len(objects) == 1:
oo_parser.localcontext['o'] = objects[0]
xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext)
oo_parser.localcontext.update(xfunc.functions)
# get style
if not style_io:
style_io = self.get_styles_file(cr, uid, report_xml, context)
# get template
if not file_data:
if report_xml.tml_source in ('file', 'database'):
file_data = base64.decodestring(report_xml.report_sxw_content)
else:
file_data = self.get_other_template(cr, uid, data, oo_parser)
# process template
if not file_data and not report_xml.report_sxw_content:
return False, output
else:
if report_xml.preload_mode == 'preload' and hasattr(
self, 'serializer'):
serializer = copy.copy(self.serializer)
serializer.apply_style(style_io)
template_io = serializer.template
else:
template_io = StringIO()
template_io.write(
file_data
or base64.decodestring(report_xml.report_sxw_content))
serializer = OOSerializer(template_io, oo_styles=style_io)
basic = Template(source=template_io, serializer=serializer)
aeroo_ooo = context.get('aeroo_ooo', False)
oo_parser.localcontext['include_subreport'] = self._subreport(
cr, uid, output='odt', aeroo_ooo=aeroo_ooo, context=context)
oo_parser.localcontext['include_document'] = self._include_document(
aeroo_ooo)
####### Add counter functons to localcontext #######
oo_parser.localcontext.update({
'def_inc': self._def_inc,
'get_inc': self._get_inc,
'prev': self._prev,
'next': self._next
})
user_name = pool.get('res.users').browse(cr, uid, uid, {}).name
report_tile = report_xml.name
eval_model = data.get("model", context.get("active_model"))
if eval_model:
modeldef_obj = pool.get('ir.model')
modeldef_id = modeldef_obj.search(cr, uid,
[('model', '=', eval_model)])[0]
report_title = modeldef_obj.browse(cr, uid, modeldef_id).name
#basic = Template(source=None, filepath=odt_path)
basic.Serializer.add_title(report_tile)
basic.Serializer.add_creation_user(user_name)
version = addons.load_information_from_description_file(
'report_aeroo')['version']
basic.Serializer.add_generator_info('Aeroo Lib/%s Aeroo Reports/%s' %
(aeroolib.__version__, version))
basic.Serializer.add_custom_property('Aeroo Reports %s' % version,
'Generator')
basic.Serializer.add_custom_property('OpenERP %s' % release.version,
'Software')
basic.Serializer.add_custom_property('http://www.alistek.com/', 'URL')
basic.Serializer.add_creation_date(time.strftime('%Y-%m-%dT%H:%M:%S'))
try:
data = basic.generate(**oo_parser.localcontext).render().getvalue()
except Exception, e:
tb_s = reduce(
lambda x, y: x + y,
traceback.format_exception(sys.exc_type, sys.exc_value,
sys.exc_traceback))
logger.error(tb_s)
self._cleanup_subreports()
raise Exception(
_("Aeroo Reports: Error while generating the report."), e,
str(e), _("For more reference inspect error logs."))
