Techsystech
/
server-tools
mirror of https://github.com/OCA/server-tools.git
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[IMP] base_exception: black, isort

pull/2463/head
Jared Kipe 2020-03-13 09:16:47 -07:00 committed by matiasperalta1
parent 5a4d2aefc0
commit 1100cd5dbc
10 changed files with 192 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
base_exception/__manifest__.py
View File

@ -3,24 +3,21 @@
# Mourad EL HADJ MIMOUNE <mourad.elhadj.mimoune@akretion.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
'name': 'Exception Rule',
'version': '12.0.3.0.1',
'category': 'Generic Modules',
'summary': """
"name": "Exception Rule",
"version": "12.0.3.0.1",
"category": "Generic Modules",
"summary": """
This module provide an abstract model to manage customizable
exceptions to be applied on different models (sale order, invoice, ...)""",
'author':
"Akretion, Sodexis, Camptocamp, Odoo Community Association (OCA)",
'website': 'https://github.com/OCA/server-tools',
'depends': [
'base_setup',
"author": "Akretion, Sodexis, Camptocamp, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-tools",
"depends": ["base_setup"],
"license": "AGPL-3",
"data": [
"security/base_exception_security.xml",
"security/ir.model.access.csv",
"wizard/base_exception_confirm_view.xml",
"views/base_exception_view.xml",
],
'license': 'AGPL-3',
'data': [
'security/base_exception_security.xml',
'security/ir.model.access.csv',
'wizard/base_exception_confirm_view.xml',
'views/base_exception_view.xml',
],
'installable': True,
"installable": True,
}

1
base_exception/models/__init__.py
View File

@ -1,2 +1 @@
from . import base_exception

154
base_exception/models/base_exception.py
View File

@ -3,52 +3,56 @@
# Mourad EL HADJ MIMOUNE <mourad.elhadj.mimoune@akretion.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import time
import html
from odoo import api, fields, models, _
import time
from odoo import _, api, fields, models, osv
from odoo.exceptions import UserError, ValidationError
from odoo.tools.safe_eval import safe_eval
from odoo import osv
class ExceptionRule(models.Model):
_name = 'exception.rule'
_description = 'Exception Rule'
_order = 'active desc, sequence asc'
_name = "exception.rule"
_description = "Exception Rule"
_order = "active desc, sequence asc"
name = fields.Char('Exception Name', required=True, translate=True)
description = fields.Text('Description', translate=True)
name = fields.Char("Exception Name", required=True, translate=True)
description = fields.Text("Description", translate=True)
sequence = fields.Integer(
string='Sequence',
help="Gives the sequence order when applying the test",
string="Sequence", help="Gives the sequence order when applying the test"
)
model = fields.Selection(selection=[], string='Apply on', required=True)
model = fields.Selection(selection=[], string="Apply on", required=True)
exception_type = fields.Selection(
selection=[('by_domain', 'By domain'),
('by_py_code', 'By python code')],
string='Exception Type', required=True, default='by_py_code',
selection=[("by_domain", "By domain"), ("by_py_code", "By python code")],
string="Exception Type",
required=True,
default="by_py_code",
help="By python code: allow to define any arbitrary check\n"
"By domain: limited to a selection by an odoo domain:\n"
" performance can be better when exceptions "
" are evaluated with several records")
domain = fields.Char('Domain')
" are evaluated with several records",
)
domain = fields.Char("Domain")
active = fields.Boolean('Active', default=True)
active = fields.Boolean("Active", default=True)
code = fields.Text(
'Python Code',
"Python Code",
help="Python code executed to check if the exception apply or "
"not. Use failed = True to block the exception",
)
@api.constrains('exception_type', 'domain', 'code')
@api.constrains("exception_type", "domain", "code")
def check_exception_type_consistency(self):
for rule in self:
if ((rule.exception_type == 'by_py_code' and not rule.code) or
(rule.exception_type == 'by_domain' and not rule.domain)):
if (rule.exception_type == "by_py_code" and not rule.code) or (
rule.exception_type == "by_domain" and not rule.domain
):
raise ValidationError(
_("There is a problem of configuration, python code or "
"domain is missing to match the exception type.")
_(
"There is a problem of configuration, python code or "
"domain is missing to match the exception type."
)
)
@api.multi
@ -59,8 +63,8 @@ class ExceptionRule(models.Model):
class BaseExceptionMethod(models.AbstractModel):
_name = 'base.exception.method'
_description = 'Exception Rule Methods'
_name = "base.exception.method"
_description = "Exception Rule Methods"
@api.multi
def _get_main_records(self):
@ -81,15 +85,14 @@ class BaseExceptionMethod(models.AbstractModel):
By default, only the rules with the correct model
will be used.
"""
return [('model', '=', self._name)]
return [("model", "=", self._name)]
@api.multi
def detect_exceptions(self):
"""List all exception_ids applied on self
Exception ids are also written on records
"""
rules = self.env['exception.rule'].sudo().search(
self._rule_domain())
rules = self.env["exception.rule"].sudo().search(self._rule_domain())
all_exception_ids = []
rules_to_remove = {}
rules_to_add = {}
@ -123,23 +126,23 @@ class BaseExceptionMethod(models.AbstractModel):
# table
# and the "to add" part generates one INSERT (with unnest) per rule.
for rule_id, records in rules_to_remove.items():
records.write({'exception_ids': [(3, rule_id,)]})
records.write({"exception_ids": [(3, rule_id)]})
for rule_id, records in rules_to_add.items():
records.write(({'exception_ids': [(4, rule_id,)]}))
records.write({"exception_ids": [(4, rule_id)]})
return all_exception_ids
@api.model
def _exception_rule_eval_context(self, rec):
return {
'time': time,
'self': rec,
"time": time,
"self": rec,
# object, obj: deprecated.
# should be removed in future migrations
'object': rec,
'obj': rec,
"object": rec,
"obj": rec,
# copy context to prevent side-effects of eval
# should be deprecated too, accesible through self.
'context': self.env.context.copy()
"context": self.env.context.copy(),
}
@api.model
@ -147,26 +150,26 @@ class BaseExceptionMethod(models.AbstractModel):
expr = rule.code
space = self._exception_rule_eval_context(rec)
try:
safe_eval(expr,
space,
mode='exec',
nocopy=True) # nocopy allows to return 'result'
safe_eval(
expr, space, mode="exec", nocopy=True
) # nocopy allows to return 'result'
except Exception as e:
raise UserError(
_('Error when evaluating the exception.rule '
'rule:\n %s \n(%s)') % (rule.name, e))
return space.get('failed', False)
_("Error when evaluating the exception.rule " "rule:\n %s \n(%s)")
% (rule.name, e)
)
return space.get("failed", False)
@api.multi
def _detect_exceptions(self, rule):
if rule.exception_type == 'by_py_code':
if rule.exception_type == "by_py_code":
return self._detect_exceptions_by_py_code(rule)
elif rule.exception_type == 'by_domain':
elif rule.exception_type == "by_domain":
return self._detect_exceptions_by_domain(rule)
@api.multi
def _get_base_domain(self):
return [('ignore_exception', '=', False), ('id', 'in', self.ids)]
return [("ignore_exception", "=", False), ("id", "in", self.ids)]
@api.multi
def _detect_exceptions_by_py_code(self, rule):
@ -193,34 +196,29 @@ class BaseExceptionMethod(models.AbstractModel):
class BaseException(models.AbstractModel):
_inherit = 'base.exception.method'
_name = 'base.exception'
_order = 'main_exception_id asc'
_description = 'Exception'
_inherit = "base.exception.method"
_name = "base.exception"
_order = "main_exception_id asc"
_description = "Exception"
main_exception_id = fields.Many2one(
'exception.rule',
compute='_compute_main_error',
string='Main Exception',
"exception.rule",
compute="_compute_main_error",
string="Main Exception",
store=True,
)
exceptions_summary = fields.Html(
'Exceptions Summary',
compute='_compute_exceptions_summary',
"Exceptions Summary", compute="_compute_exceptions_summary"
)
exception_ids = fields.Many2many(
'exception.rule',
string='Exceptions',
copy=False,
)
ignore_exception = fields.Boolean('Ignore Exceptions', copy=False)
exception_ids = fields.Many2many("exception.rule", string="Exceptions", copy=False)
ignore_exception = fields.Boolean("Ignore Exceptions", copy=False)
@api.multi
def action_ignore_exceptions(self):
self.write({'ignore_exception': True})
self.write({"ignore_exception": True})
return True
@api.depends('exception_ids', 'ignore_exception')
@api.depends("exception_ids", "ignore_exception")
def _compute_main_error(self):
for rec in self:
if not rec.ignore_exception and rec.exception_ids:
@ -228,29 +226,35 @@ class BaseException(models.AbstractModel):
else:
rec.main_exception_id = False
@api.depends('exception_ids', 'ignore_exception')
@api.depends("exception_ids", "ignore_exception")
def _compute_exceptions_summary(self):
for rec in self:
if rec.exception_ids and not rec.ignore_exception:
rec.exceptions_summary = '<ul>%s</ul>' % ''.join([
'<li>%s: <i>%s</i></li>' % tuple(map(html.escape, (
e.name, e.description))) for e in rec.exception_ids])
rec.exceptions_summary = "<ul>%s</ul>" % "".join(
[
"<li>%s: <i>%s</i></li>"
% tuple(map(html.escape, (e.name, e.description)))
for e in rec.exception_ids
]
)
@api.multi
def _popup_exceptions(self):
action = self._get_popup_action().read()[0]
action.update({
'context': {
'active_id': self.ids[0],
'active_ids': self.ids,
'active_model': self._name,
action.update(
{
"context": {
"active_id": self.ids[0],
"active_ids": self.ids,
"active_model": self._name,
}
})
}
)
return action
@api.model
def _get_popup_action(self):
return self.env.ref('base_exception.action_exception_rule_confirm')
return self.env.ref("base_exception.action_exception_rule_confirm")
@api.multi
def _check_exception(self):
@ -266,5 +270,5 @@ class BaseException(models.AbstractModel):
"""
exception_ids = self.detect_exceptions()
if exception_ids:
exceptions = self.env['exception.rule'].browse(exception_ids)
raise ValidationError('\n'.join(exceptions.mapped('name')))
exceptions = self.env["exception.rule"].browse(exception_ids)
raise ValidationError("\n".join(exceptions.mapped("name")))

1
base_exception/tests/__init__.py
View File

@ -1,4 +1,3 @@
from . import common
from . import purchase_test
from . import test_base_exception

5
base_exception/tests/common.py
View File

@ -8,6 +8,7 @@ def setup_test_model(env, model_clses):
env.registry.setup_models(env.cr)
env.registry.init_models(
env.cr, [model_cls._name for model_cls in model_clses],
dict(env.context, update_custom_fields=True)
env.cr,
[model_cls._name for model_cls in model_clses],
dict(env.context, update_custom_fields=True),
)

46
base_exception/tests/purchase_test.py
View File

@ -4,58 +4,63 @@ from odoo import api, fields, models
class PurchaseTest(models.Model):
_inherit = 'base.exception'
_inherit = "base.exception"
_name = "base.exception.test.purchase"
_description = "Base Ecxeption Test Model"
name = fields.Char(required=True)
user_id = fields.Many2one('res.users', string='Responsible')
user_id = fields.Many2one("res.users", string="Responsible")
state = fields.Selection(
[('draft', 'New'), ('cancel', 'Cancelled'),
('purchase', 'Purchase'),
('to approve', 'To approve'), ('done', 'Done')],
string="Status", readonly=True, default='draft')
[
("draft", "New"),
("cancel", "Cancelled"),
("purchase", "Purchase"),
("to approve", "To approve"),
("done", "Done"),
],
string="Status",
readonly=True,
default="draft",
)
active = fields.Boolean(default=True)
partner_id = fields.Many2one('res.partner', string='Partner')
line_ids = fields.One2many(
'base.exception.test.purchase.line', 'lead_id')
amount_total = fields.Float(
compute='_compute_amount_total', store=True)
partner_id = fields.Many2one("res.partner", string="Partner")
line_ids = fields.One2many("base.exception.test.purchase.line", "lead_id")
amount_total = fields.Float(compute="_compute_amount_total", store=True)
@api.depends('line_ids')
@api.depends("line_ids")
def _compute_amount_total(cls):
for record in cls:
for line in record.line_ids:
record.amount_total += line.amount * line.qty
@api.constrains('ignore_exception', 'line_ids', 'state')
@api.constrains("ignore_exception", "line_ids", "state")
def test_purchase_check_exception(cls):
orders = cls.filtered(lambda s: s.state == 'purchase')
orders = cls.filtered(lambda s: s.state == "purchase")
if orders:
orders._check_exception()
@api.multi
def button_approve(cls, force=False):
cls.write({'state': 'to approve'})
cls.write({"state": "to approve"})
return {}
@api.multi
def button_draft(cls):
cls.write({'state': 'draft'})
cls.write({"state": "draft"})
return {}
@api.multi
def button_confirm(cls):
cls.write({'state': 'purchase'})
cls.write({"state": "purchase"})
return True
@api.multi
def button_cancel(cls):
cls.write({'state': 'cancel'})
cls.write({"state": "cancel"})
@api.multi
def _reverse_field(self):
return 'test_purchase_ids'
return "test_purchase_ids"
class LineTest(models.Model):
@ -63,7 +68,6 @@ class LineTest(models.Model):
_description = "Base Exception Test Model Line"
name = fields.Char()
lead_id = fields.Many2one('base.exception.test.purchase',
ondelete='cascade')
lead_id = fields.Many2one("base.exception.test.purchase", ondelete="cascade")
qty = fields.Float()
amount = fields.Float()

99
base_exception/tests/test_base_exception.py
View File

@ -1,70 +1,79 @@
# Copyright 2016 Akretion Mourad EL HADJ MIMOUNE
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
from odoo.exceptions import ValidationError
from odoo import fields
from .common import setup_test_model
from .purchase_test import PurchaseTest, LineTest
import logging
from odoo import fields
from odoo.exceptions import ValidationError
from odoo.tests import common
from .common import setup_test_model
from .purchase_test import LineTest, PurchaseTest
_logger = logging.getLogger(__name__)
@common.at_install(False)
@common.post_install(True)
class TestBaseException(common.SavepointCase):
@classmethod
def setUpClass(cls):
super(TestBaseException, cls).setUpClass()
setup_test_model(cls.env, [PurchaseTest, LineTest])
cls.base_exception = cls.env['base.exception']
cls.exception_rule = cls.env['exception.rule']
if 'test_purchase_ids' not in cls.exception_rule._fields:
field = fields.Many2many('base.exception.test.purchase')
cls.exception_rule._add_field('test_purchase_ids', field)
cls.exception_confirm = cls.env['exception.rule.confirm']
cls.exception_rule._fields['model'].selection.append(
('base.exception.test.purchase', 'Purchase Order'))
cls.base_exception = cls.env["base.exception"]
cls.exception_rule = cls.env["exception.rule"]
if "test_purchase_ids" not in cls.exception_rule._fields:
field = fields.Many2many("base.exception.test.purchase")
cls.exception_rule._add_field("test_purchase_ids", field)
cls.exception_confirm = cls.env["exception.rule.confirm"]
cls.exception_rule._fields["model"].selection.append(
("base.exception.test.purchase", "Purchase Order")
)
cls.exception_rule._fields['model'].selection.append(
('base.exception.test.purchase.line', 'Purchase Order Line'))
cls.exception_rule._fields["model"].selection.append(
("base.exception.test.purchase.line", "Purchase Order Line")
)
cls.exceptionnozip = cls.env['exception.rule'].create({
'name': "No ZIP code on destination",
'sequence': 10,
'model': "base.exception.test.purchase",
'code': "if not obj.partner_id.zip: failed=True",
})
cls.exceptionnozip = cls.env["exception.rule"].create(
{
"name": "No ZIP code on destination",
"sequence": 10,
"model": "base.exception.test.purchase",
"code": "if not obj.partner_id.zip: failed=True",
}
)
cls.exceptionno_minorder = cls.env['exception.rule'].create({
'name': "Min order except",
'sequence': 10,
'model': "base.exception.test.purchase",
'code': "if obj.amount_total <= 200.0: failed=True",
})
cls.exceptionno_minorder = cls.env["exception.rule"].create(
{
"name": "Min order except",
"sequence": 10,
"model": "base.exception.test.purchase",
"code": "if obj.amount_total <= 200.0: failed=True",
}
)
cls.exceptionno_lineqty = cls.env['exception.rule'].create({
'name': "Qty > 0",
'sequence': 10,
'model': "base.exception.test.purchase.line",
'code': "if obj.qty <= 0: failed=True"
})
cls.exceptionno_lineqty = cls.env["exception.rule"].create(
{
"name": "Qty > 0",
"sequence": 10,
"model": "base.exception.test.purchase.line",
"code": "if obj.qty <= 0: failed=True",
}
)
def test_purchase_order_exception(self):
partner = self.env.ref('base.res_partner_1')
partner = self.env.ref("base.res_partner_1")
partner.zip = False
potest1 = self.env['base.exception.test.purchase'].create({
'name': 'Test base exception to basic purchase',
'partner_id': partner.id,
'line_ids': [(0, 0, {
'name': "line test",
'amount': 120.0,
'qty': 1.5,
})],
})
potest1 = self.env["base.exception.test.purchase"].create(
{
"name": "Test base exception to basic purchase",
"partner_id": partner.id,
"line_ids": [
(0, 0, {"name": "line test", "amount": 120.0, "qty": 1.5})
],
}
)
# Block because of exception during validation
with self.assertRaises(ValidationError):
potest1.button_confirm()
@ -73,4 +82,4 @@ class TestBaseException(common.SavepointCase):
# Test ignore exeception make possible for the po to validate
potest1.ignore_exception = True
potest1.button_confirm()
self.assertTrue(potest1.state == 'purchase')
self.assertTrue(potest1.state == "purchase")

1
base_exception/wizard/__init__.py
View File

@ -1,2 +1 @@
from . import base_exception_confirm

27
base_exception/wizard/base_exception_confirm.py
View File

@ -2,39 +2,36 @@
# Copyright 2017 Akretion (http://www.akretion.com)
# Mourad EL HADJ MIMOUNE <mourad.elhadj.mimoune@akretion.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models, _
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class ExceptionRuleConfirm(models.AbstractModel):
_name = 'exception.rule.confirm'
_description = 'Exception Rule Confirm Wizard'
_name = "exception.rule.confirm"
_description = "Exception Rule Confirm Wizard"
related_model_id = fields.Many2one('base.exception',)
related_model_id = fields.Many2one("base.exception")
exception_ids = fields.Many2many(
'exception.rule',
string='Exceptions to resolve',
readonly=True,
"exception.rule", string="Exceptions to resolve", readonly=True
)
ignore = fields.Boolean('Ignore Exceptions')
ignore = fields.Boolean("Ignore Exceptions")
@api.model
def default_get(self, field_list):
res = super(ExceptionRuleConfirm, self).default_get(field_list)
current_model = self.env.context.get('active_model')
current_model = self.env.context.get("active_model")
model_except_obj = self.env[current_model]
active_ids = self.env.context.get('active_ids')
active_ids = self.env.context.get("active_ids")
if len(active_ids) > 1:
raise ValidationError(
_('Only 1 ID accepted, got %r.') % active_ids)
raise ValidationError(_("Only 1 ID accepted, got %r.") % active_ids)
active_id = active_ids[0]
related_model_except = model_except_obj.browse(active_id)
exception_ids = related_model_except.exception_ids.ids
res.update({'exception_ids': [(6, 0, exception_ids)]})
res.update({'related_model_id': active_id})
res.update({"exception_ids": [(6, 0, exception_ids)]})
res.update({"related_model_id": active_id})
return res
@api.multi
def action_confirm(self):
self.ensure_one()
return {'type': 'ir.actions.act_window_close'}
return {"type": "ir.actions.act_window_close"}