def test_reload_test(self):
if tools.config.options['test_enable']:
cr = self.cr
module_info = modules.load_information_from_description_file(
"l10n_pe_retest")
for dat in module_info.get('depends', []):
cr.commit()
try:
mod_info = modules.load_information_from_description_file(
dat)
for test_module in mod_info.get('test', []):
if test_module in self.test_deprecate:
continue
pathname = os.path.join(dat, test_module)
fp = tools.file_open(pathname)
_logger.info(
"Try againt Test: {} of Module: {}".format(
test_module, dat))
try:
tools.convert_yaml_import(cr,
dat,
fp,
kind="test",
idref={},
mode="init")
except BaseException:
_logger.exception(
'module %s: an exception occurred in a test',
dat)
finally:
if tools.config.options['test_commit']:
cr.commit()
else:
cr.rollback()
def get_module_info(cls, name):
info = {}
try:
info = modules.load_information_from_description_file(name)
except Exception:
_logger.debug("Error when trying to fetch information for " "module %s", name, exc_info=True)
return info
def load_information_from_zip(filepath):
""" Return module name and description """
terp = {}
with zipfile.ZipFile(filepath, mode='r') as z:
namelist = set(z.namelist())
module = os.path.commonprefix(namelist).strip('/')
if not module_name_pattern.match(module):
raise exceptions.Warning(
_('Unable to get a valid module name: %s') % module)
manifest = os.path.join(module, modules.module.MANIFEST)
if manifest in namelist:
tmpdir = tempfile.mkdtemp()
try:
z.extract(manifest, tmpdir)
module_path = os.path.join(tmpdir, module)
terp = modules.load_information_from_description_file(
module, module_path)
finally:
shutil.rmtree(tmpdir)
else:
_logger.warning("The module '%s' has no manifest file.")
return module, terp
def get_module_info(cls, name):
info = {}
try:
info = modules.load_information_from_description_file(name)
except Exception:
_logger.debug('Error when trying to fetch informations for '
'module %s', name, exc_info=True)
return info
def get_module_info(cls, name):
info = {}
try:
info = addons.load_information_from_description_file(name)
info['version'] = release.major_version + '.' + info['version']
except Exception:
_logger.debug('Error when trying to fetch informations for '
'module %s', name, exc_info=True)
return info
def get_module_info(cls, name):
info = {}
try:
info = addons.load_information_from_description_file(name)
info['version'] = release.major_version + '.' + info['version']
except Exception:
_logger.debug('Error when trying to fetch informations for '
'module %s', name, exc_info=True)
return info
def analyze_code_one(self, branch):
# Change log level to avoid warning, when parsing odoo manifests
logger1 = logging.getLogger('openerp.modules.module')
logger2 = logging.getLogger('openerp.addons.base.module.module')
currentLevel1 = logger1.level
currentLevel2 = logger2.level
logger1.setLevel(logging.ERROR)
logger2.setLevel(logging.ERROR)
try:
module_version_obj = self.env['odoo.module.version']
# Delete all associated module versions
module_versions = module_version_obj.search([
('repository_branch_id', '=', branch.id)])
module_versions.with_context(
dont_change_repository_branch_state=True).unlink()
# Compute path(s) to analyze
if branch.module_paths:
paths = []
for path in branch.module_paths.split('\n'):
if path.strip():
paths.append(os.path.join(branch.local_path, path))
else:
paths = [branch.local_path]
# Scan each path, if exists
for path in paths:
if not os.path.exists(path):
_logger.warning(
"Unable to analyse %s. Source code not found." % (
path))
else:
# Analyze folders and create module versions
_logger.info("Analyzing repository %s ..." % (path))
for module_name in self.listdir(path):
full_module_path = os.path.join(path, module_name)
module_info = load_information_from_description_file(
module_name, full_module_path)
# Create module version, if the module is installable
# in the serie
if module_info.get('installable', False):
module_info['technical_name'] = module_name
module_version_obj.create_or_update_from_manifest(
module_info, branch, full_module_path)
finally:
# Reset Original level for module logger
logger1.setLevel(currentLevel1)
logger2.setLevel(currentLevel2)
return super(GithubRepositoryBranch, self).analyze_code_one(branch)
def _analyze_code(self):
module_version_obj = self.env['oca.module.version']
for repository_branch in self:
# Delete all associated module versions
module_versions = module_version_obj.search([
('repository_branch_id', '=', repository_branch.id)
])
module_versions.with_context(
dont_change_repository_branch_state=True).unlink()
# Compute path(s) to analyze
if repository_branch.module_paths:
paths = []
for path in repository_branch.module_paths.split('\n'):
if path.strip():
paths.append(
self._get_local_path(
repository_branch.complete_name) + '/' + path)
else:
paths = [self._get_local_path(repository_branch.complete_name)]
# Scan each path, if exists
for path in paths:
if not os.path.exists(path):
_logger.warning(
"Unable to analyse %s. Source code not found." %
(path))
else:
# Scan folder
_logger.info("Analyzing repository %s ..." % (path))
for module_name in self.listdir(path):
module_info = load_information_from_description_file(
module_name, path + '/' + module_name)
# Create module version, if the module is installable
# in the serie
if module_info.get('installable', False):
module_info['name'] = module_name
module_version_obj.create_or_update_from_manifest(
module_info, repository_branch)
self._cr.commit()
repository_branch.write({
'last_analyze_date':
datetime.today(),
'state':
'analyzed',
})
self._cr.commit()
import time
import psycopg2
from datetime import datetime
from dateutil.relativedelta import relativedelta
import openerp
from openerp import netsvc
from openerp.osv import fields, osv
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
from openerp.tools.safe_eval import safe_eval as eval
from openerp.tools.translate import _
from openerp.modules import load_information_from_description_file
_logger = logging.getLogger(__name__)
BASE_VERSION = load_information_from_description_file('base')['version']
def str2tuple(s):
return eval('tuple(%s)' % (s or ''))
_intervalTypes = {
'work_days': lambda interval: relativedelta(days=interval),
'days': lambda interval: relativedelta(days=interval),
'hours': lambda interval: relativedelta(hours=interval),
'weeks': lambda interval: relativedelta(days=7 * interval),
'months': lambda interval: relativedelta(months=interval),
'minutes': lambda interval: relativedelta(minutes=interval),
}
import time
import psycopg2
from datetime import datetime
from dateutil.relativedelta import relativedelta
import openerp
from openerp import SUPERUSER_ID, netsvc, api
from openerp.osv import fields, osv
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
from openerp.tools.safe_eval import safe_eval as eval
from openerp.tools.translate import _
from openerp.modules import load_information_from_description_file
_logger = logging.getLogger(__name__)
BASE_VERSION = load_information_from_description_file('base')['version']
def str2tuple(s):
return eval('tuple(%s)' % (s or ''))
_intervalTypes = {
'work_days': lambda interval: relativedelta(days=interval),
'days': lambda interval: relativedelta(days=interval),
'hours': lambda interval: relativedelta(hours=interval),
'weeks': lambda interval: relativedelta(days=7*interval),
'months': lambda interval: relativedelta(months=interval),
'minutes': lambda interval: relativedelta(minutes=interval),
}
class ir_cron(osv.osv):
""" Model describing cron jobs (also called actions or tasks).
'get_inc': self._get_inc(aeroo_print),
'prev': self._prev(aeroo_print),
'next': self._next(aeroo_print)
})
user_name = pool.get('res.users').browse(cr, uid, uid, {}).name
model_id = pool.get('ir.model').search(
cr, uid, [('model', '=', context.get('active_model', data['model'])
or data['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('Odoo %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:
if deferred:
deferred.set_status(_('Generate document'))
data = basic.generate(**oo_parser.localcontext).render().getvalue()
except osv.except_osv, e:
oo_parser.localcontext['progress_update'] = deferred and deferred.progress_update or (lambda:True)
####### Add counter functons to localcontext #######
oo_parser.localcontext.update({'def_inc':self._def_inc(aeroo_print),
'get_inc':self._get_inc(aeroo_print),
'prev':self._prev(aeroo_print),
'next':self._next(aeroo_print)})
user_name = pool.get('res.users').browse(cr, uid, uid, {}).name
model_id = pool.get('ir.model').search(cr, uid, [('model','=',context.get('active_model', data['model']) or data['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('Odoo %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:
if deferred:
deferred.set_status(_('Generate document'))
data = basic.generate(**oo_parser.localcontext).render().getvalue()
except osv.except_osv, e:
raise
except Exception, e:
self._raise_exception(e, print_id)
import time
import psycopg2
from datetime import datetime
from dateutil.relativedelta import relativedelta
import openerp
from openerp import SUPERUSER_ID, netsvc, api
from openerp.osv import fields, osv
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
from openerp.tools.safe_eval import safe_eval as eval
from openerp.tools.translate import _
from openerp.modules import load_information_from_description_file
_logger = logging.getLogger(__name__)
BASE_VERSION = load_information_from_description_file("base")["version"]
def str2tuple(s):
return eval("tuple(%s)" % (s or ""))
_intervalTypes = {
"work_days": lambda interval: relativedelta(days=interval),
"days": lambda interval: relativedelta(days=interval),
"hours": lambda interval: relativedelta(hours=interval),
"weeks": lambda interval: relativedelta(days=7 * interval),
"months": lambda interval: relativedelta(months=interval),
"minutes": lambda interval: relativedelta(minutes=interval),
}
def skipIfModule(module_name, reason):
try:
modules.load_information_from_description_file(module_name)
return unittest.skip(reason)
except Exception:
return lambda func: func
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."))
