size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
|---|---|---|---|---|---|---|
6,737 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from datetime import date, datetime
from lxml import etree
from odoo import _, api, models
from odoo.exceptions import UserError
from odoo.tools.safe_eval import safe_eval
class ChainedSwapperWizard(models.TransientModel):
_name = "chained.swapper.wizard"
_description = "Wizard chained swapper"
@api.model
def default_get(self, fields):
context = self.env.context
if context.get("chained_swapper_id"):
records = self.env[context.get("active_model")].browse(
context.get("active_ids")
)
exp_dict = {
"records": records,
"env": self.env,
"date": date,
"datetime": datetime,
}
chained_swapper = self.env["chained.swapper"].browse(
context.get("chained_swapper_id")
)
for constraint in chained_swapper.constraint_ids:
if safe_eval(constraint.expression, exp_dict):
raise UserError(
_("Not possible to swap the field due to the constraint")
+ ": "
+ constraint.name
)
return super().default_get(fields)
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""As we don't have any field in this model, result['fields']
and result['arch'] are modified to add dynamically the
corresponding field.
"""
res = super().fields_view_get(
view_id=view_id,
view_type=view_type,
toolbar=toolbar,
submenu=submenu,
)
if not self.env.context.get("chained_swapper_id"):
return res
chained_swapper = self.env["chained.swapper"].browse(
self.env.context.get("chained_swapper_id")
)
model_obj = self.env[self.env.context.get("active_model")]
field_info = model_obj.fields_get()
field = chained_swapper.field_id
# Fields dict
all_fields = {
field.name: {
"type": field.ttype,
"string": field.field_description,
"views": {},
}
}
if field.ttype in ["many2many", "many2one"]:
all_fields[field.name]["relation"] = field.relation
elif field.ttype == "selection":
field_selection = field_info[field.name]["selection"]
all_fields[field.name]["selection"] = field_selection
# XML view definition
doc = etree.XML(res["arch"])
group_node = doc.xpath("//group[@name='swap_field_group']")[0]
etree.SubElement(group_node, "field", {"name": field.name, "colspan": "4"})
if field.ttype in ["one2many", "many2many", "text"]:
group_node.set("string", field.field_description)
group_node.set("nolabel", "1")
res.update(arch=etree.tostring(doc, encoding="unicode"), fields=all_fields)
return res
@api.model
def create(self, vals):
"""As we don't have any field in this model, the key-value pair
received in vals dict are only used to change the value in the active
models.
"""
model_obj = self.env[self.env.context.get("active_model")]
context = self.env.context
field_name, new_value = list(vals.items())[0]
# write the active model
model = model_obj.browse(self.env.context.get("active_ids"))
original_values = {m.id: m[field_name] for m in model}
model.write(vals)
if hasattr(model, "message_post"):
self.post_chained_swap(model, field_name, original_values, new_value)
# write chained models
chained_swapper_obj = self.env["chained.swapper"]
chained_swapper = chained_swapper_obj.browse(context.get("chained_swapper_id"))
for sub_field in chained_swapper.sub_field_ids:
chain_fields = sub_field.sub_field_chain.split(".")
field_name = chain_fields.pop()
chain_model = model
for chain_field in chain_fields:
chain_model = chain_model.mapped(chain_field)
original_values = {cm.id: cm[field_name] for cm in chain_model}
chain_model.write({field_name: new_value})
# post swap
if hasattr(chain_model, "message_post"):
self.post_chained_swap(
chain_model, field_name, original_values, new_value
)
return super().create({})
def change_action(self):
return {"type": "ir.actions.act_window_close"}
@api.model
def post_chained_swap(self, model, field_name, original_values, new_value):
def human_readable_field(value):
result = value
field_def = model._fields[field_name]
if field_def.type == "selection":
if type(field_def.selection) == list:
selection = field_def.selection
else:
selection = field_def.selection(self)
for selection_item in selection:
if selection_item[0] == value:
result = selection_item[1]
break
elif field_def.type == "many2one":
if type(value) == int:
result = self.env[field_def.comodel_name].browse(value)
result = result.display_name
elif field_def.type == "many2many":
if type(value) == list:
ids = value[0][2]
value = self.env[field_def.comodel_name].browse(ids)
result = str(value.mapped("display_name"))
return result
field_desc = model._fields[field_name].string
new_value = human_readable_field(new_value)
for m in model:
original_value = human_readable_field(original_values[m.id])
m.message_post(
body=_("<b>Chained swap done</b>:")
+ "<br/>{}: {} ⇒ {}".format(field_desc, original_value, new_value)
)
def read(self, fields, load="_classic_read"):
"""Without this call, dynamic fields build by fields_view_get()
generate a crash and warning, i.e.: read() with unknown field 'myfield'
"""
real_fields = set(fields) & set(self._fields)
result = super().read(list(real_fields), load=load)
result[0].update({x: False for x in set(fields) - real_fields})
return result
| 41.067073 | 6,735 |
7,463 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Ernesto Tejeda
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, exceptions, fields, models
from odoo.exceptions import ValidationError
from odoo.tools.safe_eval import safe_eval
class ChainedSwapper(models.Model):
_name = "chained.swapper"
_description = "Chained Swapper"
name = fields.Char(required=True, translate=True, index=1)
model_id = fields.Many2one(
comodel_name="ir.model",
required=True,
ondelete="cascade",
help="Model is used for Selecting Field. This is editable "
"until Contextual Action is not created.",
)
allowed_field_ids = fields.Many2many(
comodel_name="ir.model.fields", compute="_compute_allowed_field_ids"
)
field_id = fields.Many2one(
comodel_name="ir.model.fields",
required=True,
ondelete="cascade",
domain="[('id', 'in', allowed_field_ids)]",
)
sub_field_ids = fields.One2many(
comodel_name="chained.swapper.sub.field",
inverse_name="chained_swapper_id",
string="Sub-fields",
)
constraint_ids = fields.One2many(
comodel_name="chained.swapper.constraint",
inverse_name="chained_swapper_id",
string="Constraints",
)
ref_ir_act_window_id = fields.Many2one(
comodel_name="ir.actions.act_window",
string="Action",
readonly=True,
help="Action to make this template available on records "
"of the related document model.",
)
group_ids = fields.Many2many(
comodel_name="res.groups",
relation="mass_group_rel",
column1="mass_id",
column2="group_id",
string="Groups",
)
_sql_constraints = [
(
"model_id_field_id_unique",
"unique (model_id, field_id)",
"Model and Field must be unique!",
),
]
@api.depends("model_id")
def _compute_allowed_field_ids(self):
model_obj = self.env["ir.model"]
field_obj = self.env["ir.model.fields"]
for record in self:
allowed_field_ids = False
if record.model_id:
all_models = record.model_id
active_model_obj = self.env[record.model_id.model]
if active_model_obj._inherits:
keys = list(active_model_obj._inherits.keys())
all_models |= model_obj.search([("model", "in", keys)])
allowed_field_ids = field_obj.search(
[
("ttype", "not in", ["reference", "function", "one2many"]),
("model_id", "in", all_models.ids),
]
)
record.allowed_field_ids = allowed_field_ids
@api.constrains("model_id", "field_id")
def _check_sub_field_ids(self):
self.mapped("sub_field_ids")._check_sub_field_chain()
@api.onchange("model_id")
def _onchange_model_id(self):
self.field_id = False
def write(self, vals):
res = super().write(vals)
if "name" in vals:
self.mapped("ref_ir_act_window_id").write({"name": vals["name"]})
return res
def unlink(self):
self.unlink_action()
return super().unlink()
def add_action(self):
self.ensure_one()
action = self.env["ir.actions.act_window"].create(
{
"name": _("Chained swap") + ": " + self.name,
"type": "ir.actions.act_window",
"res_model": "chained.swapper.wizard",
"groups_id": [(4, x.id) for x in self.group_ids],
"context": "{'chained_swapper_id': %d}" % (self.id),
"view_mode": "form",
"target": "new",
"binding_model_id": self.model_id.id,
"binding_type": "action",
}
)
self.write({"ref_ir_act_window_id": action.id})
return True
def unlink_action(self):
self.mapped("ref_ir_act_window_id").unlink()
return True
class ChainedSwapperSubField(models.Model):
_name = "chained.swapper.sub.field"
_description = "Chained Swapper Sub-field"
chained_swapper_id = fields.Many2one(
comodel_name="chained.swapper", ondelete="cascade"
)
sub_field_chain = fields.Char(
required=True,
help="You can specify here a field of related fields as "
"dotted names. Ex.: 'child_ids.lang'.",
)
@api.constrains("chained_swapper_id", "sub_field_chain")
def _check_sub_field_chain(self):
for rec in self:
# Check sub-field exist
try:
chain_list = rec.sub_field_chain.split(".")
chain_field_name = chain_list.pop()
chain_model = self.env[rec.chained_swapper_id.model_id.model]
for name in chain_list:
chain_model = chain_model[name]
chain_model[chain_field_name] # pylint: disable=W0104
except KeyError as err:
raise exceptions.ValidationError(
_("Incorrect sub-field expression: %(sub_field_chain)s. %(error)s")
% {"sub_field_chain": rec.sub_field_chain, "error": err}
) from err
except Exception as err:
raise ValidationError(
_("Invalid value for %(sub_field_chain)s. %(error)s")
% {"sub_field_chain": rec.sub_field_chain, "error": err}
) from err
# Check sub-field and original field are the same type
swap_field = rec.chained_swapper_id.field_id
chain_field = self.env["ir.model.fields"].search(
[
("model_id.model", "=", chain_model._name),
("name", "=", chain_field_name),
]
)
if (
chain_field.ttype != swap_field.ttype
or chain_field.relation != swap_field.relation
):
raise exceptions.ValidationError(
_("The sub-field '%s' is not compatible with the main" " field.")
% rec.sub_field_chain
)
class ChainedSwapperConstraint(models.Model):
_name = "chained.swapper.constraint"
_description = "Chained Swapper Constraint"
chained_swapper_id = fields.Many2one(
comodel_name="chained.swapper", ondelete="cascade"
)
name = fields.Char(required=True, translate=True)
expression = fields.Text(
string="Constraint expression",
required=True,
help="Boolean python expression. You can use the keyword "
"'records' as the records selected to execute the "
"contextual action. Ex.: bool(records.mapped('parent_id'))",
default="True",
)
@api.constrains("expression")
def _check_expression(self):
for record in self:
model = self.env[record.chained_swapper_id.model_id.model]
try:
safe_eval(record.expression, {"records": model})
except Exception as err:
raise exceptions.ValidationError(
_("Invalid constraint expression: %(expression)s. %(error)s.")
% {"expression": record.expression, "error": err}
) from err
| 36.583333 | 7,463 |
1,164 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from odoo import api, tools
from odoo.addons.base.models.ir_default import IrDefault
def post_load_hook():
@api.model
@tools.ormcache("self.env.uid", "model_name", "condition")
def new_get_model_defaults(self, model_name, condition=False):
if not hasattr(self, "_get_model_defaults_query_and_params"):
return self.get_model_defaults_original(model_name, condition=condition)
cr = self.env.cr
# START OF CHANGES
query, params = self._get_model_defaults_query_and_params(model_name, condition)
# END OF CHANGES
cr.execute(query, params)
result = {}
for row in cr.fetchall():
# keep the highest priority default for each field
if row[0] not in result:
result[row[0]] = json.loads(row[1])
return result
if not hasattr(IrDefault, "get_model_defaults_original"):
IrDefault.get_model_defaults_original = IrDefault.get_model_defaults
IrDefault._patch_method("get_model_defaults", new_get_model_defaults)
| 36.375 | 1,164 |
604 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Default Multi User",
"summary": "Allows to share user-defined defaults among several users.",
"version": "15.0.1.0.0",
"development_status": "Beta",
"maintainers": ["LoisRForgeFlow"],
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"author": "ForgeFlow, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["base"],
"data": ["views/ir_default_view.xml"],
"post_load": "post_load_hook",
}
| 35.529412 | 604 |
6,345 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from odoo.tests import common, tagged
@tagged("post_install", "-at_install")
class TestDefaultMultiUser(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.env = cls.env(
context=dict(cls.env.context, tracking_disable=True, no_reset_password=True)
)
cls.default_model = cls.env["ir.default"]
cls.user_model = cls.env["res.users"]
cls.partner_model = cls.env["res.partner"]
cls.company_model = cls.env["res.company"]
cls.main_company = cls.env.ref("base.main_company")
cls.other_company = cls.company_model.create({"name": "Test Company"})
cls.field = cls.env.ref("base.field_res_partner__phone")
cls.group_user = cls.env.ref("base.group_user")
cls.group_partner = cls.env.ref("base.group_partner_manager")
cls.group_private = cls.env["res.groups"].create({"name": "Test Group"})
cls.user_1 = cls._create_user(
"user_1", [cls.group_user, cls.group_partner, cls.group_private]
)
cls.user_2 = cls._create_user("user_2", [cls.group_user, cls.group_partner])
cls.user_3 = cls._create_user(
"user_3", [cls.group_user, cls.group_partner, cls.group_private]
)
cls.user_4 = cls._create_user(
"user_4",
[cls.group_user, cls.group_partner, cls.group_private],
cls.other_company,
)
cls.test_value = "+34 666 777 888"
@classmethod
def _create_user(cls, login, groups, company=False):
if not company:
company = cls.main_company
group_ids = [group.id for group in groups]
user = cls.user_model.create(
{
"name": "Test User",
"login": login,
"password": "demo",
"email": "%[email protected]" % login,
"groups_id": [(6, 0, group_ids)],
"company_id": company.id,
"company_ids": [(6, 0, [cls.main_company.id, cls.other_company.id])],
}
)
return user
def test_01_no_multi_user(self):
self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(self.test_value, ensure_ascii=False),
"user_id": self.user_1.id,
}
)
rec_1 = self.partner_model.with_user(self.user_1).create({"name": "Test"})
self.assertEqual(rec_1.phone, self.test_value)
rec_2 = self.partner_model.with_user(self.user_2).create({"name": "Test"})
self.assertNotEqual(rec_2.phone, self.test_value)
def test_02_multi_user(self):
test_default = self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(self.test_value, ensure_ascii=False),
"user_id": self.user_1.id,
"manual_user_ids": [(6, 0, (self.user_1 + self.user_2).ids)],
}
)
self.assertIn(self.user_1, test_default.user_ids)
self.assertIn(self.user_2, test_default.user_ids)
rec_1 = self.partner_model.with_user(self.user_1).create({"name": "Test"})
self.assertEqual(rec_1.phone, self.test_value)
rec_2 = self.partner_model.with_user(self.user_2).create({"name": "Test"})
self.assertEqual(rec_2.phone, self.test_value)
def test_03_group_default(self):
# Global default - expected for user 2
global_value = "+01 564 879 123"
self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(global_value, ensure_ascii=False),
}
)
# Group specific default - expected for user 1 and 3
test_default = self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(self.test_value, ensure_ascii=False),
"group_ids": [(6, 0, self.group_private.ids)],
}
)
self.assertIn(self.user_1, test_default.user_ids)
self.assertIn(self.user_3, test_default.user_ids)
rec_1 = self.partner_model.with_user(self.user_1).create({"name": "Test"})
self.assertEqual(rec_1.phone, self.test_value)
rec_2 = self.partner_model.with_user(self.user_2).create({"name": "Test"})
self.assertEqual(rec_2.phone, global_value)
rec_3 = self.partner_model.with_user(self.user_3).create({"name": "Test"})
self.assertEqual(rec_3.phone, self.test_value)
def test_04_multi_user_no_alternative(self):
test_default = self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(self.test_value, ensure_ascii=False),
"manual_user_ids": [(6, 0, self.user_2.ids)],
}
)
self.assertNotIn(self.user_1, test_default.user_ids)
self.assertIn(self.user_2, test_default.user_ids)
rec_1 = self.partner_model.with_user(self.user_1).create({"name": "Test"})
self.assertNotEqual(rec_1.phone, self.test_value)
rec_2 = self.partner_model.with_user(self.user_2).create({"name": "Test"})
self.assertEqual(rec_2.phone, self.test_value)
def test_05_multi_company(self):
# Global for main company
self.default_model.create(
{
"field_id": self.field.id,
"json_value": json.dumps(self.test_value, ensure_ascii=False),
"company_id": self.main_company.id,
}
)
rec_1 = self.partner_model.with_user(self.user_2).create({"name": "Test"})
self.assertEqual(rec_1.phone, self.test_value)
# User in other company does not get the default.
rec_2 = self.partner_model.with_user(self.user_4).create({"name": "Test"})
self.assertNotEqual(rec_2.phone, self.test_value)
# User 1 switch company. Does not get the default.
self.user_1.company_id = self.other_company
rec_3 = self.partner_model.with_user(self.user_1).create({"name": "Test"})
self.assertNotEqual(rec_3.phone, self.test_value)
| 42.3 | 6,345 |
1,891 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class IrDefaultgard(models.Model):
_inherit = "ir.default"
user_ids = fields.Many2many(
comodel_name="res.users",
string="Users",
relation="ir_default_res_users_rel",
column1="ir_default_id",
column2="res_users_id",
compute="_compute_user_ids",
store=True,
)
manual_user_ids = fields.Many2many(
comodel_name="res.users",
string="Available for Users",
relation="ir_default_res_users_manual_rel",
)
group_ids = fields.Many2many(
comodel_name="res.groups",
string="Available for Groups",
)
@api.constrains("manual_user_ids", "group_ids")
def _compute_user_ids(self):
for rec in self:
rec.user_ids = rec.manual_user_ids + rec.group_ids.users
@api.model
def _get_model_defaults_query_and_params(self, model_name, condition):
query = """
SELECT f.name, d.json_value FROM ir_default d
JOIN ir_model_fields f ON d.field_id=f.id
JOIN res_users u ON u.id=%s
LEFT JOIN ir_default_res_users_rel m
ON m.ir_default_id = d.id
WHERE f.model=%s
AND ((d.user_id IS NULL AND m.res_users_id IS NULL)
OR d.user_id=u.id OR m.res_users_id = u.id)
AND (d.company_id IS NULL OR d.company_id=%s)
AND {}
ORDER BY d.user_id, m.res_users_id, d.company_id, d.id
"""
params = [self.env.uid, model_name, self.env.company.id or None]
if condition:
query = query.format("d.condition=%s")
params.append(condition)
else:
query = query.format("d.condition IS NULL")
return query, params
| 34.381818 | 1,891 |
542 |
py
|
PYTHON
|
15.0
|
# © 2016 Opener B.V. (<https://opener.am>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Technical features group",
"summary": "Access to technical features without activating debug mode",
"version": "15.0.1.1.0",
"category": "Usability",
"website": "https://github.com/OCA/server-ux",
"author": "Opener B.V., Odoo Community Association (OCA)",
"data": ["security/res_groups.xml", "views/res_users.xml", "data/res_users.xml"],
"license": "AGPL-3",
"installable": True,
}
| 41.615385 | 541 |
2,601 |
py
|
PYTHON
|
15.0
|
from lxml import etree
from odoo.exceptions import AccessError
from odoo.tests import common
class TestBaseTechnicalFeatures(common.TransactionCase):
def test_01_visible_menus(self):
""" A technical feature is visible to the user with the technical \
features group """
menu_obj = self.env["ir.ui.menu"].with_context(**{"ir.ui.menu.full_list": True})
menu_id = menu_obj.search(
[("groups_id", "=", self.env.ref("base.group_no_one").id)], limit=1
).id
self.env.user.write({"technical_features": False})
self.env.user._compute_show_technical_features()
self.assertNotIn(menu_id, menu_obj._visible_menu_ids())
self.env.user.write({"technical_features": True})
self.env.user._compute_show_technical_features()
self.assertIn(menu_id, menu_obj._visible_menu_ids())
def test02_visible_fields(self):
""" A technical field is visible when its form is loaded by a user \
with the technical features group """
def get_partner_field_invisible():
xml = etree.fromstring(
self.env["res.users"]
.fields_view_get(view_id=self.env.ref("base.view_users_form").id)[
"arch"
]
.encode("utf-8")
)
return xml.xpath('//div/group/field[@name="partner_id"]')[0].get(
"invisible"
)
self.env.user.write({"technical_features": False})
self.assertEqual(get_partner_field_invisible(), "1")
self.env.user.write({"technical_features": True})
self.assertEqual(get_partner_field_invisible(), None)
def test03_user_access(self):
""" Setting the user pref raises an access error if the user is not \
in group_no_one """
user = self.env["res.users"].create(
{
"name": "Test user technical features",
"login": "testusertechnicalfeatures",
"groups_id": [(6, 0, [])],
}
)
self.env.user._compute_show_technical_features()
self.env.user._compute_technical_features()
with self.assertRaises(AccessError):
self.env["res.users"].browse(user.id).sudo().write(
{"technical_features": True}
)
with self.assertRaises(AccessError):
user.write({"technical_features": True})
user.write({"groups_id": [(4, self.env.ref("base.group_no_one").id)]})
self.env["res.users"].browse(user.id).sudo().write({"technical_features": True})
| 41.951613 | 2,601 |
568 |
py
|
PYTHON
|
15.0
|
# © 2016 Opener B.V. (<https://opener.am>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models
class IrUiMenu(models.Model):
_inherit = "ir.ui.menu"
@api.model
def _visible_menu_ids(self, debug=False):
"""Set debug = True, so that group_no_one is not filtered out of the
user's groups"""
if not debug:
debug = self.env.user.has_group(
"base_technical_features.group_technical_features"
)
return super()._visible_menu_ids(debug=debug)
| 33.352941 | 567 |
2,255 |
py
|
PYTHON
|
15.0
|
# © 2016 Opener B.V. (<https://opener.am>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
from odoo.exceptions import AccessError
from odoo.tools.translate import _
class ResUsers(models.Model):
_inherit = "res.users"
technical_features = fields.Boolean(
compute="_compute_technical_features", inverse="_inverse_technical_features"
)
show_technical_features = fields.Boolean(
string="Show field Technical Features",
compute="_compute_show_technical_features",
help=(
"Whether to display the technical features field in the user "
"preferences."
),
)
@api.depends("groups_id")
def _compute_show_technical_features(self):
"""Only display the technical features checkbox in the user
preferences if the user has access to them"""
users = self.env.ref("base.group_no_one").users
for user in self:
user.show_technical_features = user in users
@api.depends("groups_id")
def _compute_technical_features(self):
"""Map user membership to boolean field value"""
users = self.env.ref("base_technical_features.group_technical_features").users
for user in self:
user.technical_features = user in users
def _inverse_technical_features(self):
"""Map boolean field value to group membership, but checking
access"""
group = self.env.ref("base_technical_features.group_technical_features")
for user in self:
if self.env.ref("base.group_no_one") not in user.groups_id:
raise AccessError(
_("The user does not have access to technical " "features.")
)
if user.technical_features:
self.sudo().write({"groups_id": [(4, group.id)]})
else:
self.sudo().write({"groups_id": [(3, group.id)]})
@property
def SELF_READABLE_FIELDS(self):
return super().SELF_READABLE_FIELDS + [
"technical_features",
"show_technical_features",
]
@property
def SELF_WRITEABLE_FIELDS(self):
return super().SELF_WRITEABLE_FIELDS + ["technical_features"]
| 36.95082 | 2,254 |
639 |
py
|
PYTHON
|
15.0
|
# © 2016 Opener B.V. (<https://opener.am>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class Base(models.AbstractModel):
_inherit = "base"
def user_has_groups(self, groups):
"""Return True for users in the technical features group when
membership of the original group is checked, even if debug mode
is not enabled.
"""
if "base.group_no_one" in groups.split(",") and self.env.user.has_group(
"base_technical_features.group_technical_features"
):
return True
return super().user_has_groups(groups)
| 35.444444 | 638 |
562 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2017 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
{
"name": "Reset Sequences on selected period ranges",
"version": "15.0.1.0.0",
"category": "Reporting",
"website": "https://github.com/OCA/server-ux",
"author": "Creu Blanca, Odoo Community Association (OCA)",
"license": "LGPL-3",
"installable": True,
"application": False,
"summary": "Auto-generate yearly/monthly/weekly/daily sequence period ranges",
"depends": ["base"],
"data": ["views/sequence_views.xml"],
}
| 35.125 | 562 |
3,468 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Creu Blanca <https://creublanca.es/>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from datetime import date
from odoo.tests import common
class TestSequence(common.TransactionCase):
def setUp(self):
super().setUp()
self.date = date(2018, 3, 14)
def get_sequence(self, method):
return self.env["ir.sequence"].create(
{
"name": "Test sequence",
"implementation": "standard",
"use_date_range": True,
"range_reset": method,
"padding": "5",
}
)
def test_none(self):
sequence = self.get_sequence(False)
self.assertFalse(sequence.date_range_ids)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
xrange = sequence.date_range_ids
self.assertTrue(xrange)
self.assertEqual(date(2018, 1, 1), xrange.date_from)
self.assertEqual(date(2018, 12, 31), xrange.date_to)
def test_daily(self):
sequence = self.get_sequence("daily")
self.assertFalse(sequence.date_range_ids)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
xrange = sequence.date_range_ids
self.assertTrue(xrange)
self.assertEqual(self.date, xrange.date_from)
self.assertEqual(self.date, xrange.date_to)
def test_weekly(self):
sequence = self.get_sequence("weekly")
self.assertFalse(sequence.date_range_ids)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
xrange = sequence.date_range_ids
self.assertTrue(xrange)
self.assertEqual(date(2018, 3, 12), xrange.date_from)
self.assertEqual(date(2018, 3, 18), xrange.date_to)
def test_monthly(self):
sequence = self.get_sequence("monthly")
self.assertFalse(sequence.date_range_ids)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
xrange = sequence.date_range_ids
self.assertTrue(xrange)
self.assertEqual(date(2018, 3, 1), xrange.date_from)
self.assertEqual(date(2018, 3, 31), xrange.date_to)
def test_yearly(self):
sequence = self.get_sequence("yearly")
self.assertFalse(sequence.date_range_ids)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
xrange = sequence.date_range_ids
self.assertTrue(xrange)
self.assertEqual(date(2018, 1, 1), xrange.date_from)
self.assertEqual(date(2018, 12, 31), xrange.date_to)
def test_monthly_existing(self):
sequence = self.get_sequence("monthly")
self.env["ir.sequence.date_range"].create(
{
"date_from": date(2018, 3, 1),
"date_to": date(2018, 3, 10),
"sequence_id": sequence.id,
}
)
self.env["ir.sequence.date_range"].create(
{
"date_from": date(2018, 3, 20),
"date_to": date(2018, 3, 25),
"sequence_id": sequence.id,
}
)
self.assertEqual(
"00001", sequence.with_context(ir_sequence_date=self.date).next_by_id()
)
| 35.030303 | 3,468 |
2,428 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2017 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from datetime import date as datetime_date, timedelta
from dateutil.relativedelta import relativedelta
from odoo import fields, models
class IrSequence(models.Model):
_inherit = "ir.sequence"
range_reset = fields.Selection(
[
("daily", "Daily"),
("weekly", "Weekly"),
("monthly", "Monthly"),
("yearly", "Yearly"),
]
)
def _compute_date_from_to(self, date):
self.ensure_one()
date_from = date_to = date
if self.range_reset == "weekly":
date_from = date_from - timedelta(days=date_from.weekday())
date_to = date_from + timedelta(days=6)
elif self.range_reset == "monthly":
date_from = datetime_date(date_from.year, date_from.month, 1)
date_to = date_from + relativedelta(months=1)
date_to += relativedelta(days=-1)
elif self.range_reset == "yearly":
date_from = datetime_date(date_from.year, 1, 1)
date_to = datetime_date(date_from.year, 12, 31)
return date_from, date_to
def _create_date_range_seq(self, date):
self.ensure_one()
if not self.range_reset:
return super()._create_date_range_seq(date)
date_from, date_to = self._compute_date_from_to(date)
date_range = self.env["ir.sequence.date_range"].search(
[
("sequence_id", "=", self.id),
("date_from", ">=", date),
("date_from", "<=", date_to),
],
order="date_from desc",
limit=1,
)
if date_range:
date_to = date_range.date_from + timedelta(days=-1)
date_range = self.env["ir.sequence.date_range"].search(
[
("sequence_id", "=", self.id),
("date_to", ">=", date_from),
("date_to", "<=", date),
],
order="date_to desc",
limit=1,
)
if date_range:
date_from = date_range.date_to + timedelta(days=1)
seq_date_range = (
self.env["ir.sequence.date_range"]
.sudo()
.create(
{"date_from": date_from, "date_to": date_to, "sequence_id": self.id}
)
)
return seq_date_range
| 33.722222 | 2,428 |
614 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Base Cancel Confirm",
"version": "15.0.1.0.0",
"author": "Ecosoft,Odoo Community Association (OCA)",
"category": "Usability",
"license": "AGPL-3",
"website": "https://github.com/OCA/server-ux",
"depends": ["base"],
"data": [
"wizard/cancel_confirm.xml",
"security/ir.model.access.csv",
"templates/cancel_confirm_template.xml",
],
"auto_install": False,
"installable": True,
"maintainers": ["kittiu"],
}
| 30.7 | 614 |
932 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class CancelConfirmTester(models.Model):
_name = "cancel.confirm.tester"
_description = "Cancel Confirm Tester"
_inherit = ["base.cancel.confirm"]
_has_cancel_reason = "optional"
name = fields.Char()
state = fields.Selection(
selection=[
("draft", "Draft"),
("confirmed", "Confirmed"),
("cancel", "Cancel"),
],
default="draft",
)
def action_confirm(self):
self.write({"state": "confirmed"})
def action_cancel(self):
if not self.filtered("cancel_confirm"):
return self.open_cancel_confirm_wizard()
self.write({"state": "cancel"})
def action_draft(self):
self.clear_cancel_confirm_data()
self.write({"state": "draft"})
| 27.411765 | 932 |
4,011 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from lxml import etree
from odoo_test_helper import FakeModelLoader
from odoo.tests import Form, common
class TestCancelConfirm(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .cancel_confirm_tester import CancelConfirmTester
cls.loader.update_registry((CancelConfirmTester,))
cls.test_model = cls.env[CancelConfirmTester._name]
cls.tester_model = cls.env["ir.model"].search(
[("model", "=", "cancel.confirm.tester")]
)
cls.env["ir.config_parameter"].create(
{"key": "cancel.confirm.tester.cancel_confirm_disable", "value": "False"}
)
# Access record:
cls.env["ir.model.access"].create(
{
"name": "access.cancel.confirm.tester",
"model_id": cls.tester_model.id,
"perm_read": 1,
"perm_write": 1,
"perm_create": 1,
"perm_unlink": 1,
}
)
cls.test_record = cls.test_model.create({"name": "DOC-001"})
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super().tearDownClass()
def test_01_cancel_confirm_tester(self):
"""Cancel a document, I expect cancel_reason.
Then, set to draft, I expect cancel_reason is deleted.
"""
self.test_record.action_confirm()
# Click cance, cancel confirm wizard will open. Type in cancel_reason
res = self.test_record.action_cancel()
ctx = res.get("context")
self.assertEqual(ctx["cancel_method"], "action_cancel")
self.assertEqual(ctx["default_has_cancel_reason"], "optional")
wizard = Form(self.env["cancel.confirm"].with_context(**ctx))
wizard.cancel_reason = "Wrong information"
wiz = wizard.save()
# Confirm cancel on wizard
wiz.confirm_cancel()
self.assertEqual(self.test_record.cancel_reason, wizard.cancel_reason)
self.assertEqual(self.test_record.state, "cancel")
# Set to draft
self.test_record.action_draft()
self.assertEqual(self.test_record.cancel_reason, False)
self.assertEqual(self.test_record.state, "draft")
# Check set no cancel reason, reason should be False
wizard.has_cancel_reason = "no"
wiz = wizard.save()
# Confirm cancel on wizard
wiz.confirm_cancel()
self.assertFalse(self.test_record.cancel_reason)
def test_view_automatic(self):
# We need to add a view in order to test fields_view_get()
self.env["ir.ui.view"].create(
{
"model": self.test_record._name,
"name": "Demo view",
"arch": """<form>
<sheet>
<group>
<field name="name" />
</group>
</sheet>
</form>""",
}
)
with Form(self.test_record) as f:
form = etree.fromstring(f._view["arch"])
self.assertTrue(form.xpath("//field[@name='cancel_confirm']"))
self.assertTrue(form.xpath("//field[@name='cancel_reason']"))
# Check view difference, it should change base_model from view_id
wizard_lang_export = self.env.ref("base.wizard_lang_export")
res = self.test_record.fields_view_get(
view_id=wizard_lang_export.id,
view_type="form",
)
self.assertEqual(res.get("base_model"), wizard_lang_export.model)
# Check view type is tree.
wizard_lang_export = self.env.ref("base.wizard_lang_export")
self.test_record.fields_view_get(
view_id=wizard_lang_export.id,
view_type="tree",
)
| 37.839623 | 4,011 |
1,070 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class CancelConfirm(models.TransientModel):
_name = "cancel.confirm"
_description = "Cancel Confirm"
cancel_reason = fields.Text()
has_cancel_reason = fields.Selection(
selection=[
("no", "None"),
("optional", "Optional"),
("required", "Required"),
],
default="no",
required=True,
)
def confirm_cancel(self):
self.ensure_one()
res_model = self._context.get("cancel_res_model")
res_ids = self._context.get("cancel_res_ids")
cancel_method = self._context.get("cancel_method")
docs = self.env[res_model].browse(res_ids)
docs.write({"cancel_confirm": True})
# Cancel Reason
if self.has_cancel_reason in ["optional", "required"]:
docs.write({"cancel_reason": self.cancel_reason})
res = getattr(docs, cancel_method)()
return res
| 33.4375 | 1,070 |
3,050 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import inspect
from lxml import etree
from odoo import _, fields, models, tools
from odoo.exceptions import ValidationError
class BaseCancelConfirm(models.AbstractModel):
_name = "base.cancel.confirm"
_description = "Cancel Confirmation"
_has_cancel_reason = "no" # ["no", "optional", "required"]
_cancel_reason_xpath = "/form/sheet/group[last()]"
cancel_confirm = fields.Boolean(
string="Cancel Confirmed",
default=lambda self: self._cancel_confirm_disabled(),
copy=False,
help="A flag signify that this document is confirmed for cancellation",
)
cancel_reason = fields.Text(
copy=False,
help="An optional cancel reason",
)
def _cancel_confirm_disabled(self):
key = "%s.cancel_confirm_disable" % self._name
res = self.env["ir.config_parameter"].sudo().get_param(key)
if not res:
return True
if res not in ("True", "False"):
raise ValidationError(
_("Configuration Error (%s), should be 'True' or 'False'") % key
)
return tools.str2bool(res)
def open_cancel_confirm_wizard(self):
xmlid = "base_cancel_confirm.action_cancel_confirm_wizard"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["context"] = {
"cancel_res_model": self._name,
"cancel_res_ids": self.ids,
"cancel_method": inspect.stack()[1][3],
"default_has_cancel_reason": self._has_cancel_reason,
}
return action
def clear_cancel_confirm_data(self):
self.write({"cancel_confirm": False, "cancel_reason": False})
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "form":
doc = etree.XML(res["arch"])
for node in doc.xpath(self._cancel_reason_xpath):
str_element = self.env["ir.qweb"]._render(
"base_cancel_confirm.cancel_reason_template"
)
new_node = etree.fromstring(str_element)
for new_element in new_node:
node.addnext(new_element)
# Override context for postprocessing
View = self.env["ir.ui.view"]
if view_id and res.get("base_model", self._name) != self._name:
View = View.with_context(base_model_name=res["base_model"])
new_arch, new_fields = View.postprocess_and_fields(doc, self._name)
res["arch"] = new_arch
# We don't want to loose previous configuration, so, we only want to add
# the new fields
new_fields.update(res["fields"])
res["fields"] = new_fields
return res
| 38.607595 | 3,050 |
666 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Base Tier Validation - Reports",
"summary": "Reports related to tier validation",
"version": "15.0.1.0.1",
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"author": "Ecosoft, Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["base_tier_validation"],
"data": [
"security/groups.xml",
"reports/tier_review_report.xml",
],
"application": False,
"installable": True,
"development_status": "Beta",
"maintainers": ["kittiu"],
}
| 33.3 | 666 |
1,666 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class TierReview(models.Model):
_inherit = "tier.review"
resource_ref = fields.Reference(
selection="_selection_resource_ref",
compute="_compute_resource_ref",
store=True,
readonly=True,
compute_sudo=True,
)
resource_type = fields.Selection(
selection="_selection_resource_ref",
compute_sudo=True,
)
resource_name = fields.Char(
compute="_compute_resource_ref",
compute_sudo=True,
)
next_review = fields.Char(
compute="_compute_resource_ref",
compute_sudo=True,
)
def _selection_resource_ref(self):
models = self.env["tier.definition"]._get_tier_validation_model_names()
res = [(m, self.env[m]._description) for m in models]
return res
@api.depends("model", "res_id")
def _compute_resource_ref(self):
for rec in self:
rec.resource_ref = (
"%s,%s" % (rec.model, rec.res_id) if rec.res_id else False
)
rec.resource_name = rec.resource_ref.display_name
rec.resource_type = rec.model
rec.next_review = rec.resource_ref.next_review
def action_open_resource_ref(self):
self.ensure_one()
return {
"name": self.resource_ref.display_name,
"type": "ir.actions.act_window",
"view_type": "form",
"view_mode": "form",
"res_model": self.model,
"res_id": self.res_id,
}
| 30.851852 | 1,666 |
736 |
py
|
PYTHON
|
15.0
|
# Migrated to v14.0 by Ashish Hirpara (https://www.ashish-hirpara.com)
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Add custom filters in standard filters and group by dropdowns",
"version": "15.0.1.0.0",
"category": "Usability",
"website": "https://github.com/OCA/server-ux",
"author": "Ashish Hirpara, ForgeFlow, Odoo Community Association (OCA)",
"data": [
"security/ir.model.access.csv",
"views/ir_filters_views.xml",
"views/ir_filters_group_views.xml",
],
"depends": ["web"],
"license": "AGPL-3",
"installable": True,
"maintainers": ["AshishHirapara", "ForgeFlow"],
}
| 38.736842 | 736 |
2,783 |
py
|
PYTHON
|
15.0
|
from odoo.tests.common import Form, TransactionCase, tagged
@tagged("post_install", "-at_install")
class Test(TransactionCase):
@classmethod
def setUpClass(cls, chart_template_ref=None):
super().setUpClass()
filters_obj = cls.env["ir.filters"]
filters_group = Form(filters_obj)
filters_group.name = "Test No groupby group"
filters_group.type = "groupby"
filters_group.model_id = "ir.filters.group"
filters_group.groupby_field = cls.env.ref(
"base_custom_filter.field_ir_filters_group__name"
)
cls.filters_groupby = filters_group.save()
filters_group = Form(filters_obj)
filters_group.name = "Test No filters group"
filters_group.type = "filter"
filters_group.model_id = "ir.filters.group"
filters_group.domain = '[["id","=",1]]'
cls.filters_filter = filters_group.save()
filters_group = Form(filters_obj)
filters_group.name = "Test favorite"
filters_group.type = "favorite"
filters_group.model_id = "ir.filters.group"
filters_group.domain = '[["id","=",1]]'
cls.filters_favorite = filters_group.save()
def test_filters_favorite(self):
res = self.env["ir.filters"].get_filters("ir.filters.group")
res_ids = [item["id"] for item in res]
self.assertNotIn(self.filters_groupby.id, res_ids)
self.assertNotIn(self.filters_filter.id, res_ids)
self.assertIn(self.filters_favorite.id, res_ids)
def test_sale_order_line(self):
filters_group_obj = self.env["ir.filters.group"]
filters_obj = self.env["ir.filters"]
filters_obj.unlink()
filters_group_obj.unlink()
with Form(filters_group_obj) as filters_group:
filters_group.name = "Test filters group"
filters_group.type = "filter"
filters_group.model_id = "ir.filters.group"
with filters_group.filter_ids.new() as line:
line.name = "Test filter line"
line.domain = '[["id","=",1]]'
filter_group = filters_group_obj.search([("name", "=", "Test filters group")])
self.assertEqual(filter_group.name, "Test filters group")
with Form(filters_group_obj) as filters_group:
filters_group.name = "Test groupby group"
filters_group.type = "groupby"
filters_group.model_id = "ir.filters.group"
with filters_group.filter_ids.new() as line:
line.name = "Test groupby line"
line.groupby_field = self.env.ref(
"base_custom_filter.field_ir_filters_group__name"
)
filters_group_obj.fields_view_get(view_type="search")
filter_group.unlink()
| 41.537313 | 2,783 |
1,599 |
py
|
PYTHON
|
15.0
|
# Migrated to v14.0 by Ashish Hirpara (https://www.ashish-hirpara.com)
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
from odoo.osv import expression
class IrFilters(models.Model):
_inherit = "ir.filters"
_order = "model_id, sequence, name, id desc"
def _selection_type(self):
return [
("favorite", "Favorite"),
("filter", "Standard Filter"),
("groupby", "Standard Group By"),
]
sequence = fields.Integer()
type = fields.Selection(
selection="_selection_type",
required=True,
default="favorite",
)
groupby_field = fields.Many2one(
comodel_name="ir.model.fields",
string="Group By Field",
ondelete="cascade",
)
group_id = fields.Many2one(comodel_name="ir.filters.group", string="Filter Group")
@api.model
def get_filters(self, model, action_id=None):
"""We need to inject a context to obtain only the records of favorite type."""
self = self.with_context(filter_type="favorite")
return super().get_filters(model, action_id=action_id)
@api.model
def search(self, args, offset=0, limit=None, order=None, count=False):
if self.env.context.get("filter_type"):
args = expression.AND(
(args, [("type", "=", self.env.context["filter_type"])])
)
return super().search(
args, offset=offset, limit=limit, order=order, count=count
)
| 34.021277 | 1,599 |
1,169 |
py
|
PYTHON
|
15.0
|
# Migrated to v14.0 by Ashish Hirpara (https://www.ashish-hirpara.com)
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class IrFiltersGroup(models.Model):
_name = "ir.filters.group"
_description = "Filters Group"
_order = "sequence, name, id"
def _selection_type(self):
return [("filter", "Filter"), ("groupby", "Group By")]
sequence = fields.Integer()
model_id = fields.Selection(
selection="_list_all_models", string="Model", required=True
)
name = fields.Char(required=True, translate=True)
type = fields.Selection(
selection="_selection_type",
required=True,
default="filter",
)
filter_ids = fields.One2many(
comodel_name="ir.filters", inverse_name="group_id", string="Filters"
)
def unlink(self):
self.filter_ids.unlink()
return super(IrFiltersGroup, self).unlink()
@api.model
def _list_all_models(self):
self._cr.execute("SELECT model, name FROM ir_model ORDER BY name")
return self._cr.fetchall()
| 31.594595 | 1,169 |
4,428 |
py
|
PYTHON
|
15.0
|
# Migrated to v14.0 by Ashish Hirpara (https://www.ashish-hirpara.com)
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from lxml import etree
from odoo import api, models
class Base(models.AbstractModel):
_inherit = "base"
@api.model
def _add_grouped_filters(self, res, custom_filters):
arch = etree.fromstring(res["arch"])
node = arch.xpath("//search/filter[last()]")
if node:
node[0].addnext(etree.Element("separator"))
for custom_filter in custom_filters:
node = arch.xpath("//search/separator[last()]")
if node:
elem = etree.Element(
"filter",
{
"name": "ir_custom_filter_%s" % custom_filter.id,
"string": custom_filter.name,
"domain": custom_filter.domain,
},
)
node[0].addnext(elem)
res["arch"] = etree.tostring(arch)
return res
@api.model
def _add_grouped_groupby(self, res, custom_groupbys):
arch = etree.fromstring(res["arch"])
node = arch.xpath("//group/filter[last()]")
if node:
node[0].addnext(etree.Element("separator"))
for custom_groupby in custom_groupbys:
node = arch.xpath("//group/separator[last()]")
if node:
elem = etree.Element(
"filter",
{
"name": "ir_custom_filter_%s" % custom_groupby.id,
"string": custom_groupby.name,
"context": str(
{"group_by": custom_groupby.groupby_field.name}
),
},
)
node[0].addnext(elem)
res["arch"] = etree.tostring(arch)
return res
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""Add filters in search views."""
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "search":
filter_groups = self.env["ir.filters.group"].search(
[
("model_id", "=", res.get("model")),
("filter_ids", "!=", False),
("type", "=", "filter"),
]
)
filters_no_group = self.env["ir.filters"].search(
[
("model_id", "=", res.get("model")),
("group_id", "=", False),
("type", "=", "filter"),
],
order="sequence desc",
)
groupby_groups = self.env["ir.filters.group"].search(
[
("model_id", "=", res.get("model")),
("filter_ids", "!=", False),
("type", "=", "groupby"),
]
)
groupbys_no_group = self.env["ir.filters"].search(
[
("model_id", "=", res.get("model")),
("group_id", "=", False),
("type", "=", "groupby"),
],
order="sequence desc",
)
# Add filter type
if filter_groups:
for filter_group in filter_groups:
res = self._add_grouped_filters(
res, filter_group.filter_ids.sorted("sequence", True)
)
if filters_no_group:
for filter_no_group in filters_no_group:
res = self._add_grouped_filters(res, filter_no_group)
# Add groupby type
if groupby_groups:
for groupby_group in groupby_groups:
res = self._add_grouped_groupby(
res, groupby_group.filter_ids.sorted("sequence", True)
)
if groupbys_no_group:
for groupby_no_group in groupbys_no_group:
res = self._add_grouped_groupby(res, groupby_no_group)
return res
| 38.842105 | 4,428 |
657 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Base Menu Visibility Restriction",
"version": "15.0.1.0.0",
"category": "Extra Tools",
"development_status": "Production/Stable",
"author": "Tecnativa, Odoo Community Association (OCA)",
"summary": "Restrict (with groups) menu visibilty",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"depends": ["web_tour"],
"maintainers": ["victoralmau"],
"data": ["views/ir_ui_menu.xml"],
"demo": ["demo/res_group.xml", "demo/ir_ui_menu.xml"],
"installable": True,
}
| 36.388889 | 655 |
1,075 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
class TestIrUiMenuCase(TransactionCase):
def setUp(self):
super(TestIrUiMenuCase, self).setUp()
self.user_admin = self.browse_ref("base.user_admin").id
self.group_hide_menu = self.env["res.groups"].create(
{"name": "Hide menu items custom", "users": [(4, self.user_admin)]}
)
self.model_ir_uir_menu = self.env["ir.ui.menu"]
self.ir_ui_menu = self.browse_ref("base.menu_management")
def test_ir_ui_menu_admin(self):
items = self.model_ir_uir_menu.with_user(self.user_admin)._visible_menu_ids()
self.assertTrue(self.ir_ui_menu.id in items)
# Update ir_ui_menu to assign excluded_group_ids
self.ir_ui_menu.write({"excluded_group_ids": [(4, self.group_hide_menu.id)]})
items = self.model_ir_uir_menu.with_user(self.user_admin)._visible_menu_ids()
self.assertTrue(self.ir_ui_menu.id not in items)
| 46.652174 | 1,073 |
970 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models, tools
class IrUiMenu(models.Model):
_inherit = "ir.ui.menu"
excluded_group_ids = fields.Many2many(
comodel_name="res.groups",
relation="ir_ui_menu_excluded_group_rel",
column1="menu_id",
column2="gid",
string="Excluded Groups",
)
@api.model
@tools.ormcache("frozenset(self.env.user.groups_id.ids)", "debug")
def _visible_menu_ids(self, debug=False):
"""Return the ids of the menu items visible to the user."""
visible = super()._visible_menu_ids(debug=debug)
context = {"ir.ui.menu.full_list": True}
menus = self.with_context(**context).browse(visible)
groups = self.env.user.groups_id
visible = menus - menus.filtered(lambda menu: menu.excluded_group_ids & groups)
return set(visible.ids)
| 35.851852 | 968 |
1,012 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Date Range",
"summary": "Manage all kind of date range",
"version": "15.0.1.1.0",
"category": "Uncategorized",
"website": "https://github.com/OCA/server-ux",
"author": "ACSONE SA/NV, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": [
"web",
],
# odoo_test_helper is needed for the tests
"data": [
"data/ir_cron_data.xml",
"security/ir.model.access.csv",
"security/date_range_security.xml",
"views/date_range_view.xml",
"wizard/date_range_generator.xml",
],
"assets": {
"web.assets_backend": [
"date_range/static/src/js/date_range.esm.js",
],
"web.assets_qweb": [
"date_range/static/src/xml/date_range.xml",
],
},
"development_status": "Mature",
"maintainers": ["lmignon"],
}
| 30.666667 | 1,012 |
265 |
py
|
PYTHON
|
15.0
|
from odoo import fields, models
class TestDateRangeSearchMixin(models.Model):
_name = "test.date.range.search.mixin"
_inherit = ["date.range.search.mixin"]
_date_range_search_field = "test_date"
name = fields.Char()
test_date = fields.Date()
| 26.5 | 265 |
5,842 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# Copyright 2021 Opener B.V. <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from dateutil.rrule import MONTHLY
from odoo_test_helper import FakeModelLoader
from odoo.tests.common import TransactionCase
class TestDateRangeearchMixin(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# Load a test model using odoo_test_helper
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .models import TestDateRangeSearchMixin
cls.loader.update_registry((TestDateRangeSearchMixin,))
cls.env.user.lang = "en_US"
rtype = cls.env["date.range.type"].create(
{"name": __name__, "company_id": False, "allow_overlap": False}
)
cls.env["date.range.generator"].create(
{
"date_start": "1943-01-01",
"name_prefix": "1943-",
"type_id": rtype.id,
"duration_count": 3,
"unit_of_time": str(MONTHLY),
"count": 4,
}
).action_apply()
cls.ranges = cls.env["date.range"].search([("type_id", "=", rtype.id)])
cls.model = cls.env[TestDateRangeSearchMixin._name]
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super().tearDownClass()
def test_01_search_view(self):
"""The search field is injected in the model's search view"""
self.assertIn(
'<separator/><field name="date_range_search_id" string="Period"/>',
self.model.fields_view_get(view_type="search")["arch"],
)
self.assertNotIn(
'<separator/><field name="date_range_search_id" string="Period"/>',
self.model.fields_view_get(view_type="form")["arch"],
)
# Having a view with a group element in it
view = self.env["ir.ui.view"].create(
{
"name": __name__,
"model": self.model._name,
"arch": """
<search>
<field name="name"/>
<group string="Group by">
<filter name="name" context="{'group_by': 'name'}"/>
</group>
</search>
""",
}
)
self.assertIn(
'<separator/><field name="date_range_search_id" string="Period"/>',
self.model.fields_view_get(view_type="search")["arch"],
)
# Having a view in which the field is added explicitely
view.arch = """
<search>
<field name="name"/>
<field name="date_range_search_id"/>
<group string="Group by">
<filter name="name" context="{'group_by': 'name'}"/>
</group>
</search>
"""
self.assertNotIn(
'<separator/><field name="date_range_search_id" string="Period"/>',
self.model.fields_view_get(view_type="search")["arch"],
)
def test_02_search_result(self):
"""Using the search field leads to expected results"""
record = self.model.create({"test_date": "1943-04-05"})
self.assertFalse(record.date_range_search_id)
self.assertIn(
record,
self.model.search([("date_range_search_id", "=", self.ranges[1].id)]),
)
self.assertNotIn(
record,
self.model.search([("date_range_search_id", "!=", self.ranges[1].id)]),
)
self.assertIn(
record,
self.model.search([("date_range_search_id", "!=", self.ranges[0].id)]),
)
self.assertNotIn(
record,
self.model.search([("date_range_search_id", "=", self.ranges[0].id)]),
)
self.assertIn(
record, self.model.search([("date_range_search_id", "in", self.ranges.ids)])
)
self.assertNotIn(
record,
self.model.search([("date_range_search_id", "not in", self.ranges.ids)]),
)
self.assertIn(
record,
self.model.search([("date_range_search_id", "not in", self.ranges[3].ids)]),
)
self.assertNotIn(
record,
self.model.search([("date_range_search_id", "in", self.ranges[3].ids)]),
)
self.assertIn(
record, self.model.search([("date_range_search_id", "ilike", "1943")])
)
self.assertNotIn(
record, self.model.search([("date_range_search_id", "not ilike", "1943")])
)
self.assertIn(
record, self.model.search([("date_range_search_id", "not ilike", "2021")])
)
self.assertNotIn(
record, self.model.search([("date_range_search_id", "ilike", "2021")])
)
self.assertIn(record, self.model.search([("date_range_search_id", "=", True)]))
self.assertNotIn(
record, self.model.search([("date_range_search_id", "=", False)])
)
self.assertIn(
record, self.model.search([("date_range_search_id", "!=", False)])
)
self.assertNotIn(
record, self.model.search([("date_range_search_id", "!=", True)])
)
def test_03_read(self):
"""Read returns a falsy value"""
record = self.model.create({"test_date": "1943-04-05"})
self.assertFalse(record.date_range_search_id)
def test_04_load_views(self):
"""Technical field label is replaced in `load_views`"""
field = self.model.load_views([(None, "form")])["fields"][
"date_range_search_id"
]
self.assertNotIn("technical", field["string"])
| 37.690323 | 5,842 |
4,585 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import datetime
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
class DateRangeTest(TransactionCase):
def setUp(self):
super(DateRangeTest, self).setUp()
self.date_range = self.env["date.range"]
self.type = self.env["date.range.type"].create(
{"name": "Fiscal year", "company_id": False, "allow_overlap": False}
)
self.company = self.env["res.company"].create({"name": "Test company"})
self.company_2 = self.env["res.company"].create(
{"name": "Test company 2", "parent_id": self.company.id}
)
self.typeB = self.env["date.range.type"].create(
{
"name": "Fiscal year B",
"company_id": self.company.id,
"allow_overlap": False,
}
)
def test_default_company(self):
dr = self.date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.type.id,
}
)
self.assertTrue(dr.company_id)
# you can specify company_id to False
dr = self.date_range.create(
{
"name": "FS2016_NO_COMPANY",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.type.id,
"company_id": False,
}
)
self.assertFalse(dr.company_id)
def test_empty_company(self):
dr = self.date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.type.id,
"company_id": None,
}
)
self.assertEqual(dr.name, "FS2016")
def test_invalid(self):
with self.assertRaises(ValidationError) as cm:
self.date_range.create(
{
"name": "FS2016",
"date_end": "2015-01-01",
"date_start": "2016-12-31",
"type_id": self.type.id,
}
)
message = str(cm.exception.args[0])
self.assertEqual(
message, "FS2016 is not a valid range (2016-12-31 > 2015-01-01)"
)
def test_overlap(self):
self.date_range.create(
{
"name": "FS2015",
"date_start": "2015-01-01",
"date_end": "2015-12-31",
"type_id": self.type.id,
}
)
with self.assertRaises(ValidationError) as cm, self.env.cr.savepoint():
self.date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.type.id,
}
)
message = str(cm.exception.args[0])
self.assertEqual(message, "FS2016 overlaps FS2015")
# check it's possible to overlap if it's allowed by the date range type
self.type.allow_overlap = True
dr = self.date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.type.id,
}
)
self.assertEqual(dr.name, "FS2016")
def test_domain(self):
dr = self.date_range.create(
{
"name": "FS2015",
"date_start": "2015-01-01",
"date_end": "2015-12-31",
"type_id": self.type.id,
}
)
domain = dr.get_domain("my_field")
# By default the domain include limits
self.assertEqual(
domain,
[
("my_field", ">=", datetime.date(2015, 1, 1)),
("my_field", "<=", datetime.date(2015, 12, 31)),
],
)
def test_date_range_multicompany_1(self):
with self.assertRaises(ValidationError):
self.date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": self.typeB.id,
"company_id": self.company_2.id,
}
)
| 32.75 | 4,585 |
6,324 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
from dateutil.relativedelta import relativedelta
from dateutil.rrule import MONTHLY, YEARLY
from psycopg2 import IntegrityError
from odoo import fields
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
from odoo.tools import mute_logger
class DateRangeTypeTest(TransactionCase):
def setUp(self):
super(DateRangeTypeTest, self).setUp()
self.type = self.env["date.range.type"]
self.company = self.env["res.company"].create({"name": "Test company"})
self.company_2 = self.env["res.company"].create(
{"name": "Test company 2", "parent_id": self.company.id}
)
def test_default_company(self):
drt = self.type.create({"name": "Fiscal year", "allow_overlap": False})
self.assertTrue(drt.company_id)
# you can specify company_id to False
drt = self.type.create(
{"name": "Fiscal year", "company_id": False, "allow_overlap": False}
)
self.assertFalse(drt.company_id)
def test_unlink(self):
date_range = self.env["date.range"]
drt = self.env["date.range.type"].create(
{"name": "Fiscal year", "allow_overlap": False}
)
date_range.create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": drt.id,
}
)
with self.assertRaises(IntegrityError), mute_logger("odoo.sql_db"):
drt.unlink()
def test_type_multicompany(self):
drt = self.type.create(
{"name": "Fiscal year", "company_id": False, "allow_overlap": False}
)
dr = self.env["date.range"].create(
{
"name": "FS2016",
"date_start": "2015-01-01",
"date_end": "2016-12-31",
"type_id": drt.id,
"company_id": self.company.id,
}
)
drt.company_id = self.company.id
with self.assertRaises(ValidationError):
dr.company_id = self.company_2
def test_autogeneration(self):
"""Ranges are autogenerated for types configured for that"""
today = fields.Date.context_today(self.env.user)
year_start = today.replace(day=1, month=1)
dr_type = self.env["date.range.type"].create(
{
"name": __name__,
"name_expr": "'>%s<' % date_start.strftime('%d%m%Y')",
"unit_of_time": str(MONTHLY),
"duration_count": 1,
"autogeneration_count": 1,
"autogeneration_unit": str(YEARLY),
}
)
self.assertEqual(
dr_type.range_name_preview, ">%s<" % year_start.strftime("%d%m%Y")
)
self.env["date.range.type"].autogenerate_ranges()
ranges = self.env["date.range"].search(
[("type_id", "=", dr_type.id)], order="date_start asc"
)
# For new types, ranges are autogenerated from the start of the year
year_start = today.replace(day=1, month=1)
self.assertEqual(ranges[0].date_start, year_start)
# Ranges are autogenerated upto the range in which the computed end
# date falls, c.q. the first of the month a year from now.
next_year_month_start = today.replace(day=1) + relativedelta(years=1)
self.assertEqual(ranges[-1].date_start, next_year_month_start)
self.assertEqual(
ranges[-1].name, ">%s<" % next_year_month_start.strftime("%d%m%Y")
)
# No new ranges get generated anymore this month
self.env["date.range.type"].autogenerate_ranges()
self.assertEqual(
len(ranges),
len(
self.env["date.range"].search(
[("type_id", "=", dr_type.id)], order="date_start asc"
)
),
)
def test_autogeneration_with_start_date(self):
today = fields.Date.context_today(self.env.user)
start_date = today.replace(year=2019, day=6, month=1)
dr_type = self.env["date.range.type"].create(
{
"name": __name__,
"name_expr": "'>%s<' % date_start.strftime('%d%m%Y')",
"unit_of_time": str(MONTHLY),
"duration_count": 1,
"autogeneration_date_start": start_date,
"autogeneration_count": 1,
"autogeneration_unit": str(YEARLY),
}
)
self.assertFalse(dr_type.date_ranges_exist)
self.env["date.range.type"].autogenerate_ranges()
self.assertTrue(dr_type.date_ranges_exist)
ranges = self.env["date.range"].search(
[("type_id", "=", dr_type.id)], order="date_start asc"
)
self.assertEqual(ranges[0].date_start, start_date)
# No new ranges get generated anymore this month
self.env["date.range.type"].autogenerate_ranges()
self.assertEqual(
len(ranges),
len(
self.env["date.range"].search(
[("type_id", "=", dr_type.id)], order="date_start asc"
)
),
)
def test_autogeneration_invalid_config(self):
"""The cron method does not raise when an invalid config exists"""
today = fields.Date.context_today(self.env.user)
start_date = today.replace(year=2019, day=6, month=1)
dr_type = self.env["date.range.type"].create(
{
"name": __name__,
"name_expr": "index",
"unit_of_time": str(MONTHLY),
"duration_count": 1,
"autogeneration_date_start": start_date,
"autogeneration_count": 1,
"autogeneration_unit": str(YEARLY),
}
)
# Inject invalid value
self.env.cr.execute("UPDATE date_range_type SET name_expr = 'invalid'")
dr_type.refresh()
with mute_logger("odoo.addons.date_range.models.date_range_type"):
self.env["date.range.type"].autogenerate_ranges()
self.assertFalse(dr_type.date_ranges_exist)
| 39.279503 | 6,324 |
4,909 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# Copyright 2022 XCG Consulting (<https://xcg-consulting.fr>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)nses/agpl).
import datetime
from dateutil.rrule import MONTHLY
from odoo.exceptions import ValidationError
from odoo.tests.common import Form, TransactionCase
class DateRangeGeneratorTest(TransactionCase):
def setUp(self):
super(DateRangeGeneratorTest, self).setUp()
self.generator = self.env["date.range.generator"]
self.type = self.env["date.range.type"].create(
{"name": "Fiscal year", "company_id": False, "allow_overlap": False}
)
self.company = self.env["res.company"].create({"name": "Test company"})
self.company_2 = self.env["res.company"].create(
{"name": "Test company 2", "parent_id": self.company.id}
)
self.typeB = self.env["date.range.type"].create(
{
"name": "Fiscal year B",
"company_id": self.company.id,
"allow_overlap": False,
}
)
def test_generate(self):
generator = self.generator.create(
{
"date_start": "1943-01-01",
"name_prefix": "1943-",
"type_id": self.type.id,
"duration_count": 3,
"unit_of_time": str(MONTHLY),
"count": 4,
}
)
generator.action_apply()
ranges = self.env["date.range"].search([("type_id", "=", self.type.id)])
self.assertEqual(len(ranges), 4)
range4 = ranges[3]
self.assertEqual(range4.date_start, datetime.date(1943, 10, 1))
self.assertEqual(range4.date_end, datetime.date(1943, 12, 31))
self.assertEqual(range4.type_id, self.type)
def test_generate_name_expr(self):
"""Test generation when using babel in name_expr"""
self.type.write(
{
"name_expr": "babel.dates.format_date(date_start, format='MMMM yyyy', "
"locale='fr_FR')",
"duration_count": 1,
"unit_of_time": str(MONTHLY),
}
)
with Form(self.generator) as generator_form:
generator_form.count = 12
generator_form.type_id = self.type
generator_form.date_start = "2000-01-01"
generator = generator_form.save()
generator.action_apply()
ranges = self.env["date.range"].search([("type_id", "=", self.type.id)])
self.assertEqual(len(ranges), 12)
self.assertEqual(ranges[0].date_start, datetime.date(2000, 1, 1))
self.assertEqual(ranges[-1].date_end, datetime.date(2000, 12, 31))
self.assertEqual(ranges[0].name, "janvier 2000")
self.assertEqual(ranges[7].name, "août 2000")
self.assertEqual(ranges[11].name, "décembre 2000")
def test_generator_multicompany_1(self):
with self.assertRaises(ValidationError):
self.generator.create(
{
"date_start": "1943-01-01",
"name_prefix": "1943-",
"type_id": self.typeB.id,
"duration_count": 3,
"unit_of_time": str(MONTHLY),
"count": 4,
"company_id": self.company_2.id,
}
)
def test_generator_form(self):
"""Test validation and onchange functionality"""
form = Form(self.env["date.range.generator"])
form.type_id = self.type
form.unit_of_time = str(MONTHLY)
form.duration_count = 10
form.date_end = "2021-01-01"
# Setting count clears date_end
form.count = 10
self.assertFalse(form.date_end)
# Setting date_end clears count
form.date_end = "2021-01-01"
self.assertFalse(form.count)
form.count = 10
form.name_prefix = "PREFIX"
# Cannot generate ranges with an invalid name_expr
with self.assertRaisesRegex(ValidationError, "Invalid name expression"):
form.name_expr = "'not valid"
# Setting name_expr clears name_prefix
form.name_expr = "'PREFIX%s' % index"
self.assertFalse(form.name_prefix)
self.assertEqual(form.range_name_preview, "PREFIX01")
wizard = form.save()
# Cannot generate ranges without count and without date_end
wizard.date_end = False
wizard.count = False
with self.assertRaisesRegex(ValidationError, "end date.*number of ranges"):
wizard.action_apply()
wizard.count = 10
# Cannot generate ranges without a prefix and without an expression
wizard.name_expr = False
wizard.name_prefix = False
with self.assertRaisesRegex(ValidationError, "prefix.*expression"):
wizard.action_apply()
| 38.944444 | 4,907 |
11,602 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# Copyright 2021 Opener B.V. (<https://opener.amsterdam>)
# Copyright 2022 XCG Consulting (<https://xcg-consulting.fr>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from typing import Any
from dateutil.relativedelta import relativedelta
from dateutil.rrule import DAILY, MONTHLY, WEEKLY, YEARLY, rrule
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
from odoo.tools.safe_eval import safe_eval, wrap_module
_logger = logging.getLogger(__name__)
class DateRangeGenerator(models.TransientModel):
_name = "date.range.generator"
_description = "Date Range Generator"
name_expr = fields.Text(
"Range name expression",
compute="_compute_name_expr",
readonly=False,
store=True,
help=(
"Evaluated expression. E.g. "
"\"'FY%s' % date_start.strftime('%Y%m%d')\"\nYou can "
"use the Date types 'date_end' and 'date_start', as well as "
"the 'index' variable, and also babel.dates.format_date method."
),
)
name_prefix = fields.Char(
"Range name prefix",
compute="_compute_name_prefix",
readonly=False,
store=True,
)
range_name_preview = fields.Char(compute="_compute_range_name_preview")
date_start = fields.Date(
"Start date",
compute="_compute_date_start",
readonly=False,
store=True,
required=True,
)
date_end = fields.Date("End date", compute="_compute_date_end", readonly=False)
type_id = fields.Many2one(
comodel_name="date.range.type",
string="Type",
required=True,
domain="['|', ('company_id', '=', company_id), " "('company_id', '=', False)]",
ondelete="cascade",
store=True,
compute="_compute_type_id",
readonly=False,
)
company_id = fields.Many2one(
comodel_name="res.company",
string="Company",
compute="_compute_company_id",
readonly=False,
store=True,
)
unit_of_time = fields.Selection(
[
(str(YEARLY), "years"),
(str(MONTHLY), "months"),
(str(WEEKLY), "weeks"),
(str(DAILY), "days"),
],
compute="_compute_unit_of_time",
readonly=False,
store=True,
required=True,
)
duration_count = fields.Integer(
"Duration",
compute="_compute_duration_count",
readonly=False,
store=True,
required=True,
)
count = fields.Integer(
string="Number of ranges to generate",
)
@api.onchange("date_end")
def onchange_date_end(self):
if self.date_end and self.count:
self.count = 0
@api.onchange("count")
def onchange_count(self):
if self.count and self.date_end:
self.date_end = False
@api.onchange("name_expr")
def onchange_name_expr(self):
"""Wipe the prefix if an expression is entered.
The reverse is not implemented because we don't want to wipe the
users' painstakingly crafted expressions by accident.
"""
if self.name_expr and self.name_prefix:
self.name_prefix = False
@api.depends("company_id", "type_id.company_id")
def _compute_type_id(self):
if (
self.company_id
and self.type_id.company_id
and self.type_id.company_id != self.company_id
):
self.type_id = self.env["date.range.type"]
def _generate_intervals(self, batch=False):
"""Generate a list of dates representing the intervals.
The last date only serves to compute the end date of the last interval.
:param batch: When true, don't raise when there are no ranges to
generate.
"""
if not self.date_end and not self.count:
if batch:
return []
raise ValidationError(
_("Please enter an end date, or the number of ranges to " "generate.")
)
kwargs = dict(
freq=int(self.unit_of_time),
interval=self.duration_count,
dtstart=self.date_start,
)
if self.date_end:
kwargs["until"] = self.date_end
else:
kwargs["count"] = self.count
vals = list(rrule(**kwargs))
if not vals:
raise UserError(_("No ranges to generate with these settings"))
# Generate another interval to fetch the last end date from
vals.append(
list(
rrule(
freq=int(self.unit_of_time),
interval=self.duration_count,
dtstart=vals[-1].date(),
count=2,
)
)[-1]
)
return vals
def generate_names(self, vals):
"""Generate the names for the given intervals"""
self.ensure_one()
return self._generate_names(vals, self.name_expr, self.name_prefix)
@classmethod
def _generate_names(cls, vals, name_expr, name_prefix):
"""Generate the names for the given intervals and naming parameters"""
base_dict: dict[str, Any] = cls._generate_name_safe_eval_dict()
names = []
count_digits = len(str(len(vals) - 1))
for idx, dt_start in enumerate(vals[:-1]):
date_start = dt_start.date()
# always remove 1 day for the date_end since range limits are
# inclusive
date_end = vals[idx + 1].date() - relativedelta(days=1)
index = "%0*d" % (count_digits, idx + 1)
if name_expr:
try:
names.append(
safe_eval(
name_expr,
dict(
**base_dict,
date_end=date_end,
date_start=date_start,
index=index,
),
)
)
except (SyntaxError, ValueError) as e:
raise ValidationError(_("Invalid name expression: %s") % e) from e
elif name_prefix:
names.append(name_prefix + index)
else:
raise ValidationError(
_(
"Please set a prefix or an expression to generate "
"the range names."
)
)
return names
@classmethod
def _generate_name_safe_eval_dict(cls):
"""Return globals dict that will be used when generating the range names."""
return {
"babel": wrap_module(__import__("babel"), {"dates": ["format_date"]}),
}
@api.depends("name_expr", "name_prefix")
def _compute_range_name_preview(self):
for wiz in self:
preview = False
if wiz.name_expr or wiz.name_prefix:
vals = False
try:
vals = wiz._generate_intervals()
except Exception:
_logger.exception("Something happened generating intervals")
if vals:
names = wiz.generate_names(vals)
if names:
preview = names[0]
wiz.range_name_preview = preview
def _generate_date_ranges(self, batch=False):
"""Actually generate the date ranges."""
self.ensure_one()
vals = self._generate_intervals(batch=batch)
if not vals:
return []
date_ranges = []
names = self.generate_names(vals)
for idx, dt_start in enumerate(vals[:-1]):
date_start = dt_start.date()
date_end = vals[idx + 1].date() - relativedelta(days=1)
date_ranges.append(
{
"name": names[idx],
"date_start": date_start,
"date_end": date_end,
"type_id": self.type_id.id,
"company_id": self.company_id.id,
}
)
return date_ranges
@api.depends("type_id")
def _compute_company_id(self):
if self.type_id:
self.company_id = self.type_id.company_id
else:
self.company_id = self.env.company
@api.depends("type_id")
def _compute_name_expr(self):
if self.type_id.name_expr:
self.name_expr = self.type_id.name_expr
@api.depends("type_id")
def _compute_name_prefix(self):
if self.type_id.name_prefix:
self.name_prefix = self.type_id.name_prefix
@api.depends("type_id")
def _compute_duration_count(self):
if self.type_id.duration_count:
self.duration_count = self.type_id.duration_count
@api.depends("type_id")
def _compute_unit_of_time(self):
if self.type_id.unit_of_time:
self.unit_of_time = self.type_id.unit_of_time
@api.depends("type_id")
def _compute_date_start(self):
if not self.type_id:
return
last = self.env["date.range"].search(
[("type_id", "=", self.type_id.id)], order="date_end desc", limit=1
)
today = fields.Date.context_today(self)
if last:
self.date_start = last.date_end + relativedelta(days=1)
elif self.type_id.autogeneration_date_start:
self.date_start = self.type_id.autogeneration_date_start
else: # default to the beginning of the current year
self.date_start = today.replace(day=1, month=1)
@api.depends("date_start")
def _compute_date_end(self):
if not self.type_id or not self.date_start:
return
if self.type_id.autogeneration_unit and self.type_id.autogeneration_count:
key = {
str(YEARLY): "years",
str(MONTHLY): "months",
str(WEEKLY): "weeks",
str(DAILY): "days",
}[self.type_id.autogeneration_unit]
today = fields.Date.context_today(self)
date_end = today + relativedelta(**{key: self.type_id.autogeneration_count})
if date_end > self.date_start:
self.date_end = date_end
@api.onchange("company_id")
def _onchange_company_id(self):
if (
self.company_id
and self.type_id.company_id
and self.type_id.company_id != self.company_id
):
self._cache.update(self._convert_to_cache({"type_id": False}, update=True))
@api.constrains("company_id", "type_id")
def _check_company_id_type_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.type_id.company_id
and rec.company_id != rec.type_id.company_id
):
raise ValidationError(
_(
"The Company in the Date Range Generator and in "
"Date Range Type must be the same."
)
)
def action_apply(self, batch=False):
date_ranges = self._generate_date_ranges(batch=batch)
if date_ranges:
for dr in date_ranges:
self.env["date.range"].create(dr)
return self.env["ir.actions.actions"]._for_xml_id(
"date_range.date_range_action"
)
| 34.736527 | 11,602 |
5,434 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from dateutil.relativedelta import relativedelta
from dateutil.rrule import DAILY, MONTHLY, WEEKLY, YEARLY
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class DateRangeType(models.Model):
_name = "date.range.type"
_description = "Date Range Type"
@api.model
def _default_company(self):
return self.env.company
name = fields.Char(required=True, translate=True)
allow_overlap = fields.Boolean(
help="If sets date range of same type must not overlap.", default=False
)
active = fields.Boolean(
help="The active field allows you to hide the date range type "
"without removing it.",
default=True,
)
company_id = fields.Many2one(
comodel_name="res.company", string="Company", index=1, default=_default_company
)
date_range_ids = fields.One2many("date.range", "type_id", string="Ranges")
date_ranges_exist = fields.Boolean(compute="_compute_date_ranges_exist")
# Defaults for generating date ranges
name_expr = fields.Text(
"Range name expression",
help=(
"Evaluated expression. E.g. "
"\"'FY%s' % date_start.strftime('%Y%m%d')\"\nYou can "
"use the Date types 'date_end' and 'date_start', as well as "
"the 'index' variable, and also babel.dates.format_date method."
),
)
range_name_preview = fields.Char(compute="_compute_range_name_preview", store=True)
name_prefix = fields.Char("Range name prefix")
duration_count = fields.Integer("Duration")
unit_of_time = fields.Selection(
[
(str(YEARLY), "years"),
(str(MONTHLY), "months"),
(str(WEEKLY), "weeks"),
(str(DAILY), "days"),
]
)
autogeneration_date_start = fields.Date(
string="Autogeneration Start Date",
help="Only applies when there are no date ranges of this type yet",
)
autogeneration_count = fields.Integer()
autogeneration_unit = fields.Selection(
[
(str(YEARLY), "years"),
(str(MONTHLY), "months"),
(str(WEEKLY), "weeks"),
(str(DAILY), "days"),
]
)
_sql_constraints = [
(
"date_range_type_uniq",
"unique (name,company_id)",
"A date range type must be unique per company !",
)
]
@api.constrains("company_id")
def _check_company_id(self):
if not self.env.context.get("bypass_company_validation", False):
for rec in self.sudo():
if not rec.company_id:
continue
if bool(
rec.date_range_ids.filtered(
lambda r: r.company_id and r.company_id != rec.company_id
)
):
raise ValidationError(
_(
"You cannot change the company, as this "
"Date Range Type is assigned to Date Range "
"(%s)."
)
% (rec.date_range_ids.name_get()[0][1])
)
@api.depends("name_expr", "name_prefix")
def _compute_range_name_preview(self):
year_start = fields.Datetime.now().replace(day=1, month=1)
next_year = year_start + relativedelta(years=1)
for dr_type in self:
if dr_type.name_expr or dr_type.name_prefix:
names = self.env["date.range.generator"]._generate_names(
[year_start, next_year], dr_type.name_expr, dr_type.name_prefix
)
dr_type.range_name_preview = names[0]
else:
dr_type.range_name_preview = False
@api.depends("date_range_ids")
def _compute_date_ranges_exist(self):
for dr_type in self:
dr_type.date_ranges_exist = bool(dr_type.date_range_ids)
@api.onchange("name_expr")
def onchange_name_expr(self):
"""Wipe the prefix if an expression is entered.
The reverse is not implemented because we don't want to wipe the
users' painstakingly crafted expressions by accident.
"""
if self.name_expr and self.name_prefix:
self.name_prefix = False
@api.model
def autogenerate_ranges(self):
"""Generate ranges for types with autogeneration settings"""
logger = logging.getLogger(__name__)
for dr_type in self.search(
[
("autogeneration_count", "!=", False),
("autogeneration_unit", "!=", False),
("duration_count", "!=", False),
("unit_of_time", "!=", False),
]
):
try:
wizard = self.env["date.range.generator"].new({"type_id": dr_type.id})
if not wizard.date_end:
# Nothing to generate
continue
with self.env.cr.savepoint():
wizard.action_apply(batch=True)
except Exception as e:
logger.warning(
"Error autogenerating ranges for date range type "
"%s: %s" % (dr_type.name, e)
)
| 36.469799 | 5,434 |
3,943 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Opener B.V. <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from lxml import etree
from odoo import _, api, fields, models
from odoo.osv.expression import FALSE_DOMAIN, NEGATIVE_TERM_OPERATORS, TRUE_DOMAIN
class DateRangeSearchMixin(models.AbstractModel):
_name = "date.range.search.mixin"
_description = "Mixin class to add a Many2one style period search field"
_date_range_search_field = "date"
date_range_search_id = fields.Many2one(
comodel_name="date.range",
string="Filter by period (technical field)",
compute="_compute_date_range_search_id",
search="_search_date_range_search_id",
)
def _compute_date_range_search_id(self):
"""Assign a dummy value for this search field"""
for record in self:
record.date_range_search_id = False
@api.model
def _search_date_range_search_id(self, operator, value):
"""Map the selected date ranges to the model's date field"""
# Deal with some bogus values
if not value:
if operator in NEGATIVE_TERM_OPERATORS:
return TRUE_DOMAIN
return FALSE_DOMAIN
if value is True:
if operator in NEGATIVE_TERM_OPERATORS:
return FALSE_DOMAIN
return TRUE_DOMAIN
# Assume from here on that the value is a string,
# a single id or a list of ids
ranges = self.env["date.range"]
if isinstance(value, str):
ranges = self.env["date.range"].search([("name", operator, value)])
else:
if isinstance(value, int):
value = [value]
sub_op = "not in" if operator in NEGATIVE_TERM_OPERATORS else "in"
ranges = self.env["date.range"].search([("id", sub_op, value)])
if not ranges:
return FALSE_DOMAIN
domain = (len(ranges) - 1) * ["|"] + sum(
(
[
"&",
(self._date_range_search_field, ">=", date_range.date_start),
(self._date_range_search_field, "<=", date_range.date_end),
]
for date_range in ranges
),
[],
)
return domain
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""Inject the dummy Many2one field in the search view"""
result = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type != "search":
return result
root = etree.fromstring(result["arch"])
if root.xpath("//field[@name='date_range_search_id']"):
# Field was inserted explicitely
return result
separator = etree.Element("separator")
field = etree.Element(
"field",
attrib={
"name": "date_range_search_id",
"string": _("Period"),
},
)
groups = root.xpath("/search/group")
if groups:
groups[0].addprevious(separator)
groups[0].addprevious(field)
else:
search = root.xpath("/search")
search[0].append(separator)
search[0].append(field)
result["arch"] = etree.tostring(root, encoding="unicode")
return result
@api.model
def load_views(self, views, options=None):
"""Adapt the label of the dummy search field
Ensure the technical name does not show up in the Custom Filter
fields list (while still showing up in the Export widget)
"""
result = super().load_views(views, options=options)
if "date_range_search_id" in result["fields"]:
result["fields"]["date_range_search_id"]["string"] = _("Period")
return result
| 37.198113 | 3,943 |
4,342 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# Copyright 2022 XCG Consulting (<https://xcg-consulting.fr>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class DateRange(models.Model):
_name = "date.range"
_description = "Date Range"
_order = "type_name,date_start"
@api.model
def _default_company(self):
return self.env.company
name = fields.Char(required=True, translate=True)
date_start = fields.Date(string="Start date", required=True)
date_end = fields.Date(string="End date", required=True)
type_id = fields.Many2one(
comodel_name="date.range.type",
string="Type",
index=1,
required=True,
ondelete="restrict",
domain="['|', ('company_id', '=', company_id), " "('company_id', '=', False)]",
store=True,
compute="_compute_type_id",
readonly=False,
)
type_name = fields.Char(related="type_id.name", store=True, string="Type Name")
company_id = fields.Many2one(
comodel_name="res.company", string="Company", index=1, default=_default_company
)
active = fields.Boolean(
help="The active field allows you to hide the date range without "
"removing it.",
default=True,
)
_sql_constraints = [
(
"date_range_uniq",
"unique (name,type_id, company_id)",
"A date range must be unique per company !",
)
]
@api.depends("company_id", "type_id.company_id")
def _compute_type_id(self):
"""Enforce check of company consistency when changing company, here
or in the type.
"""
self._check_company_id_type_id()
@api.constrains("company_id", "type_id")
def _check_company_id_type_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.type_id.company_id
and rec.company_id != rec.type_id.company_id
):
raise ValidationError(
_("%(name)s is not a valid range (%(date_start)s > %(date_end)s)")
% {
"name": rec.name,
"date_start": rec.date_start,
"date_end": rec.date_end,
}
)
@api.constrains("type_id", "date_start", "date_end", "company_id")
def _validate_range(self):
for this in self:
if this.date_start > this.date_end:
raise ValidationError(
_("%(name)s is not a valid range (%(date_start)s > %(date_end)s)")
% {
"name": this.name,
"date_start": this.date_start,
"date_end": this.date_end,
}
)
if this.type_id.allow_overlap:
continue
# here we use a plain SQL query to benefit of the daterange
# function available in PostgresSQL
# (http://www.postgresql.org/docs/current/static/rangetypes.html)
SQL = """
SELECT
id
FROM
date_range dt
WHERE
DATERANGE(dt.date_start, dt.date_end, '[]') &&
DATERANGE(%s::date, %s::date, '[]')
AND dt.id != %s
AND dt.active
AND dt.company_id = %s
AND dt.type_id=%s;"""
self.env.cr.execute(
SQL,
(
this.date_start,
this.date_end,
this.id,
this.company_id.id or None,
this.type_id.id,
),
)
res = self.env.cr.fetchall()
if res:
dt = self.browse(res[0][0])
raise ValidationError(
_("%(thisname)s overlaps %(dtname)s")
% {"thisname": this.name, "dtname": dt.name}
)
def get_domain(self, field_name):
self.ensure_one()
return [(field_name, ">=", self.date_start), (field_name, "<=", self.date_end)]
| 35.300813 | 4,342 |
882 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Document Quick Access",
"summary": """
Document quick access""",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"maintainers": ["etobella"],
"depends": ["web", "barcode_action"],
"external_dependencies": {"python": ["pyzbar", "pdf2image"]},
"data": [
"security/ir.model.access.csv",
"views/document_quick_access_rule.xml",
],
"assets": {
"web.assets_backend": [
"document_quick_access/static/src/js/document_quick_access_launcher.js",
],
"web.assets_qweb": [
"document_quick_access/static/src/xml/document_quick_access_launcher.xml"
],
},
}
| 32.666667 | 882 |
1,949 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase, tagged
@tagged("post_install", "-at_install")
class TestDocumentQuickAccess(TransactionCase):
def setUp(self):
super().setUp()
self.model = "res.partner"
self.model_id = self.env.ref("base.model_res_partner")
self.rule = self.env["document.quick.access.rule"].create(
{
"model_id": self.model_id.id,
"name": "PARTNER",
"priority": 1,
"barcode_format": "standard",
}
)
self.partner = self.env["res.partner"].create({"name": "Partner test"})
def test_generation(self):
code = self.partner.get_quick_access_code()
self.assertTrue(code)
partner = self.env["document.quick.access.rule"].read_code(code)
self.assertEqual(partner, self.partner)
action = self.env["document.quick.access.rule"].read_code_action(code)
self.assertEqual(action["res_model"], partner._name)
self.assertEqual(action["res_id"], partner.id)
def test_not_found(self):
code = self.partner.get_quick_access_code()
self.assertTrue(code)
self.rule.toggle_active()
with self.assertRaises(UserError):
self.env["document.quick.access.rule"].read_code(code)
action = self.env["document.quick.access.rule"].read_code_action(code)
self.assertEqual(action["res_model"], "barcode.action")
def test_no_code(self):
self.rule.toggle_active()
self.assertFalse(self.partner.get_quick_access_code())
def test_generation_b64(self):
self.rule.barcode_format = "b64_standard"
self.test_generation()
def test_not_found_b64(self):
self.rule.barcode_format = "b64_standard"
self.test_not_found()
| 37.480769 | 1,949 |
3,628 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import base64
import binascii
import json
import re
from odoo import _, api, fields, models
from odoo.exceptions import UserError
class DocumentQuickAccessRule(models.Model):
_name = "document.quick.access.rule"
_description = "Document Quick Access Rule"
_order = "priority,model_id"
name = fields.Char(required=True)
priority = fields.Integer(default=16, required=True)
barcode_format = fields.Selection(
[("standard", "Standard"), ("b64_standard", "Base64")],
required=True,
default="standard",
)
# All formats must have a function to determine the code from a record and
# get the record from the code
model_id = fields.Many2one("ir.model", required=True, ondelete="cascade")
active = fields.Boolean(default=True)
def get_code(self, record):
self.ensure_one()
return getattr(self, "_get_code_%s" % self.barcode_format)(record)
def _get_code_b64_standard(self, record):
return base64.b64encode(self._get_code_standard(record).encode("utf-8")).decode(
"utf-8"
)
def _get_code_standard(self, record):
return "{},{}".format(record._name, record.id)
def _check_code_b64_standard(self, code):
try:
aux_code = base64.b64decode(code.encode("utf-8"), validate=True)
except binascii.Error:
return False
return self._check_code_standard(aux_code.decode("utf-8"))
def _check_code_standard(self, code):
return re.match("^[a-zA-Z0-9\\.]*,[0-9]*$", code)
def _read_code_b64_standard(self, code):
aux_code = base64.b64decode(code.encode("utf-8")).decode("utf-8")
return self._read_code_standard(aux_code)
def _read_code_standard(self, code):
params = code.split(",")
return self.env[params[0]].browse(int(params[1])).exists()
def read_code_action(self, code):
try:
record = self.read_code(code)
except UserError:
return {
"type": "ir.actions.act_window",
"name": "Search QR",
"res_model": "barcode.action",
"views": [[False, "form"]],
"target": "new",
"context": json.dumps(
{
"default_model": "document.quick.access.rule",
"default_method": "read_code_action",
"default_state": "warning",
"default_status": _("Document cannot be found"),
}
),
}
record.check_access_rights("read")
result = {
"type": "ir.actions.act_window",
"res_model": record._name,
"views": [[record.get_formview_id(), "form"]],
"res_id": record.id,
"target": "main",
}
return result
@api.model
def read_code(self, code):
formats = self._fields["barcode_format"].selection
for barcode_format, _format_name in formats:
if getattr(self, "_check_code_%s" % barcode_format)(code):
record = getattr(self, "_read_code_%s" % barcode_format)(code)
if record and self.search(
[
("model_id.model", "=", record._name),
("barcode_format", "=", barcode_format),
]
):
return record
raise UserError(_("No format has been found for this record"))
| 35.568627 | 3,628 |
452 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import models
class Base(models.AbstractModel):
_inherit = "base"
def get_quick_access_code(self):
self.ensure_one()
rule = self.env["document.quick.access.rule"].search(
[("model_id.model", "=", self._name)], limit=1
)
if not rule:
return False
return rule.get_code(self)
| 26.588235 | 452 |
871 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Creu Blanca
# Copyright 2020 ForgeFlow S.L.
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
{
"name": "Barcode action launcher",
"version": "15.0.1.0.0",
"category": "Extra Tools",
"website": "https://github.com/OCA/server-ux",
"author": "Creu Blanca, ForgeFlow, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": "Allows to use barcodes as a launcher",
"depends": ["barcodes"],
"data": [
"security/ir.model.access.csv",
"wizard/barcode_action_view.xml",
],
"assets": {
"web.assets_backend": [
"barcode_action/static/src/js/action_barcode_form.js",
"barcode_action/static/src/js/action_barcode_widget.js",
],
},
"demo": ["demo/barcode_action_demo.xml"],
}
| 32.259259 | 871 |
874 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Creu Blanca
# Copyright 2020 ForgeFlow S.L.
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
from odoo.tests.common import TransactionCase
class TestPartnerFind(TransactionCase):
def test_partner(self):
partner_obj = self.env["res.partner"]
ref = "testing_partner_internal_reference"
partner = partner_obj.create({"name": "Testing partner", "ref": ref})
# We should find the partner when the ref is found
self.assertEqual(
partner.id,
partner_obj.find_res_partner_by_ref_using_barcode(ref).get("res_id", False),
)
# No partner is found, then there is no res_id on the result
self.assertFalse(
partner_obj.find_res_partner_by_ref_using_barcode(
"{}-{}".format(ref, ref)
).get("res_id", False)
)
| 39.727273 | 874 |
540 |
py
|
PYTHON
|
15.0
|
from odoo import fields, models
class BarcodeAction(models.TransientModel):
_name = "barcode.action"
_inherit = "barcodes.barcode_events_mixin"
_description = "Barcode Action"
model = fields.Char(required=True, readonly=True)
res_id = fields.Integer()
method = fields.Char(required=True, readonly=True)
state = fields.Selection(
[("waiting", "Waiting"), ("warning", "Warning")],
default="waiting",
readonly=True,
)
status = fields.Text(readonly=True, default="Start scanning")
| 31.764706 | 540 |
1,280 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Creu Blanca
# Copyright 2020 ForgeFlow S.L.
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
import json
from odoo import _, models
from odoo.tools.safe_eval import safe_eval
class ResPartner(models.Model):
_inherit = "res.partner"
def find_res_partner_by_ref_using_barcode(self, barcode):
partner = self.search([("ref", "=", barcode)], limit=1)
if not partner:
xmlid = "barcode_action.res_partner_find"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
context = safe_eval(action["context"])
context.update(
{
"default_state": "warning",
"default_status": _(
"Partner with Internal Reference " "%s cannot be found"
)
% barcode,
}
)
action["context"] = json.dumps(context)
return action
xmlid = "base.action_partner_form"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
res = self.env.ref("base.view_partner_form", False)
action["views"] = [(res and res.id or False, "form")]
action["res_id"] = partner.id
return action
| 36.571429 | 1,280 |
783 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Announcement",
"version": "15.0.1.1.0",
"summary": "Notify internal users about relevant organization stuff",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"category": "Server UX",
"website": "https://github.com/OCA/server-ux",
"depends": ["mail"],
"data": [
"security/announcement_security.xml",
"security/ir.model.access.csv",
"views/announcement_views.xml",
"wizards/read_announcement_wizard.xml",
],
"assets": {
"web.assets_backend": ["announcement/static/src/**/*.js"],
"web.assets_qweb": ["announcement/static/src/**/*.xml"],
},
}
| 34.043478 | 783 |
324 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, models
class IrConfigParameter(models.Model):
_inherit = "ir.config_parameter"
@api.model
def announcement_full_size(self):
return self.sudo().get_param("announcement.full_size")
| 29.454545 | 324 |
2,483 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class ResUsers(models.Model):
_inherit = "res.users"
unread_announcement_ids = fields.Many2many(
comodel_name="announcement",
relation="unread_announcement_user_rel",
)
read_announcement_ids = fields.Many2many(
comodel_name="announcement",
relation="read_announcement_user_rel",
)
@api.model
def announcement_user_count(self):
"""The js widget gathers the announcements from this method"""
# It would be better to rely on record rules, but then announcement managers
# would see every announcement, which would be annoying.
group_announcements = self.env["announcement"].search_read(
[
("announcement_type", "=", "user_group"),
("in_date", "=", True),
("id", "not in", self.env.user.read_announcement_ids.ids),
],
["user_group_ids"],
)
announcements = self.env["announcement"].browse(
{
x["id"]
for x in group_announcements
if any(
[g for g in x["user_group_ids"] if g in self.env.user.groups_id.ids]
)
}
)
# Unread announcements are directly linked to the user. Normally, only a
# handful of records will be evaluated at best.
announcements |= self.env.user.unread_announcement_ids.filtered("in_date")
return [
{
"id": announcement.id,
"name": announcement.name,
"content": announcement.content,
}
for announcement in announcements.sorted(lambda k: k.sequence)
]
@api.model
def mark_announcement_as_read(self, announcement_id):
"""Used as a controller for the widget"""
announcement = self.env["announcement"].browse(int(announcement_id))
self.env.user.unread_announcement_ids -= announcement
# Log only the first time. Users with the announcement in multiple windows would
# log multiple reads. We're only interested in the first one.
if announcement not in self.env.user.read_announcement_ids:
self.env.user.read_announcement_ids += announcement
self.env["announcement.log"].create({"announcement_id": announcement.id})
| 40.704918 | 2,483 |
6,775 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
class AnnouncementLog(models.Model):
_name = "announcement.log"
_description = "Log user reads"
_order = "create_date desc"
announcement_id = fields.Many2one(comodel_name="announcement")
class Announcement(models.Model):
_name = "announcement"
_description = "User announcements"
_order = "notification_date, sequence asc, id"
active = fields.Boolean(copy=False)
sequence = fields.Integer()
name = fields.Char(string="Title", required=True)
content = fields.Html()
is_general_announcement = fields.Boolean("General Announcement")
announcement_type = fields.Selection(
selection=[
("specific_users", "Specific users"),
("user_group", "User groups"),
],
default="specific_users",
required=True,
)
specific_user_ids = fields.Many2many(
comodel_name="res.users",
domain=[("share", "=", False)],
inverse="_inverse_specific_user_ids",
)
user_group_ids = fields.Many2many(
comodel_name="res.groups",
compute="_compute_user_group_ids",
store=True,
readonly=False,
)
allowed_user_ids = fields.Many2many(
comodel_name="res.users",
relation="announcement_res_users_allowed_rel",
compute="_compute_allowed_user_ids",
compute_sudo=True,
store=True,
)
allowed_users_count = fields.Integer(
compute="_compute_allowed_user_ids",
compute_sudo=True,
store=True,
)
read_announcement_count = fields.Integer(
compute="_compute_read_announcement_count",
store=True,
)
notification_date = fields.Datetime()
notification_expiry_date = fields.Datetime()
in_date = fields.Boolean(
compute="_compute_in_date", search="_search_in_date", compute_sudo=True
)
announcement_log_ids = fields.One2many(
comodel_name="announcement.log",
inverse_name="announcement_id",
)
def _inverse_specific_user_ids(self):
"""Used to set users unread announcements when they're set in the announcement
itself"""
for announcement in self:
for user in announcement.specific_user_ids.filtered(
lambda x: announcement
not in (x.read_announcement_ids + x.unread_announcement_ids)
):
user.unread_announcement_ids |= announcement
@api.depends("specific_user_ids", "user_group_ids")
def _compute_allowed_user_ids(self):
self.allowed_user_ids = False
self.allowed_users_count = False
specific_user_announcements = self.filtered(
lambda x: x.announcement_type == "specific_users"
)
for announcement in specific_user_announcements:
announcement.allowed_user_ids = announcement.specific_user_ids
announcement.allowed_users_count = len(announcement.specific_user_ids)
for announcement in self - specific_user_announcements:
announcement.allowed_user_ids = announcement.user_group_ids.users
announcement.allowed_users_count = len(announcement.user_group_ids.users)
@api.depends("is_general_announcement")
def _compute_user_group_ids(self):
for announcement in self:
if announcement.is_general_announcement:
announcement.announcement_type = "user_group"
announcement.user_group_ids = self.env.ref("base.group_user")
else:
announcement.specific_user_ids = False
announcement.user_group_ids = False
@api.depends("announcement_log_ids")
def _compute_read_announcement_count(self):
logs = self.env["announcement.log"].read_group(
[("announcement_id", "in", self.ids)],
["announcement_id"],
["announcement_id"],
)
result = {
data["announcement_id"][0]: (data["announcement_id_count"]) for data in logs
}
for announcement in self:
announcement.read_announcement_count = result.get(announcement.id, 0)
def _compute_in_date(self):
"""The announcement is publishable according to date criterias"""
self.in_date = False
now = fields.Datetime.now()
for record in self:
date_passed = (
not record.notification_date or record.notification_date <= now
)
date_unexpired = (
not record.notification_expiry_date
or record.notification_expiry_date >= now
)
record.in_date = date_passed and date_unexpired
def _search_in_date(self, operator, value):
"""Used mainly for record rules as time module values will be cached"""
now = fields.Datetime.now()
return [
"|",
("notification_date", "=", False),
("notification_date", "<=", now),
"|",
("notification_expiry_date", "=", False),
("notification_expiry_date", ">=", now),
]
@api.onchange("announcement_type")
def _onchange_announcement_type(self):
"""We want to reset the values on screen"""
if self.announcement_type == "specific_users":
self.user_group_ids = False
elif self.announcement_type == "user_group":
self.specific_user_ids = False
def action_announcement_log(self):
"""See altogether read logs and unread users"""
self.ensure_one()
read_logs = self.env["announcement.log"].search(
[("announcement_id", "in", self.ids)]
)
unread_users = self.allowed_user_ids.filtered(
lambda x: x not in read_logs.create_uid
)
read_unread_log = self.env["read.announcement.wizard"].create(
[
{
"user_id": log.create_uid.id,
"date": log.create_date,
"announcement_id": self.id,
"read_state": "read",
}
for log in read_logs
]
)
read_unread_log += self.env["read.announcement.wizard"].create(
[{"user_id": user.id, "read_state": "unread"} for user in unread_users]
)
return {
"type": "ir.actions.act_window",
"res_model": "read.announcement.wizard",
"views": [[False, "tree"]],
"domain": [("id", "in", read_unread_log.ids)],
"context": dict(self.env.context, create=False, group_by=["read_state"]),
"name": _("Read Logs"),
}
| 37.638889 | 6,775 |
587 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ReadAnnouncementWizard(models.TransientModel):
_name = "read.announcement.wizard"
_description = "Show altogether users who read and users who didn't"
_order = "date desc"
date = fields.Datetime(string="Read Date")
user_id = fields.Many2one(comodel_name="res.users")
announcement_id = fields.Many2one(comodel_name="announcement")
read_state = fields.Selection(selection=[("read", "Read"), ("unread", "Unread")])
| 41.928571 | 587 |
1,446 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Base Tier Validation",
"summary": "Implement a validation process based on tiers.",
"version": "15.0.1.2.4",
"development_status": "Mature",
"maintainers": ["LoisRForgeFlow"],
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"author": "ForgeFlow, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["mail"],
"data": [
"data/mail_data.xml",
"security/ir.model.access.csv",
"security/tier_validation_security.xml",
"views/res_config_settings_views.xml",
"views/tier_definition_view.xml",
"views/tier_review_view.xml",
"wizard/comment_wizard_view.xml",
"templates/tier_validation_templates.xml",
],
"assets": {
"web.assets_backend": [
"/base_tier_validation/static/src/js/systray.js",
"/base_tier_validation/static/src/js/tier_review_widget.js",
"/base_tier_validation/static/src/scss/systray.scss",
"/base_tier_validation/static/src/scss/review.scss",
],
"web.assets_qweb": [
"base_tier_validation/static/src/xml/systray.xml",
"base_tier_validation/static/src/xml/tier_review_template.xml",
],
},
}
| 38.052632 | 1,446 |
1,338 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class TierValidationTester(models.Model):
_name = "tier.validation.tester"
_description = "Tier Validation Tester"
_inherit = ["tier.validation"]
_tier_validation_manual_config = True
state = fields.Selection(
selection=[
("draft", "Draft"),
("confirmed", "Confirmed"),
("cancel", "Cancel"),
],
default="draft",
)
test_field = fields.Float()
user_id = fields.Many2one(string="Assigned to:", comodel_name="res.users")
def action_confirm(self):
self.write({"state": "confirmed"})
class TierValidationTester2(models.Model):
_name = "tier.validation.tester2"
_description = "Tier Validation Tester 2"
_inherit = ["tier.validation"]
_tier_validation_manual_config = False
state = fields.Selection(
selection=[
("draft", "Draft"),
("confirmed", "Confirmed"),
("cancel", "Cancel"),
],
default="draft",
)
test_field = fields.Float()
user_id = fields.Many2one(string="Assigned to:", comodel_name="res.users")
def action_confirm(self):
self.write({"state": "confirmed"})
| 29.086957 | 1,338 |
20,311 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from lxml import etree
from odoo.exceptions import ValidationError
from odoo.tests.common import Form, tagged
from .common import CommonTierValidation
@tagged("post_install", "-at_install")
class TierTierValidation(CommonTierValidation):
def test_01_auto_validation(self):
"""When the user can validate all future reviews, it is not needed
to request a validation, the action can be done straight forward."""
self.test_record.with_user(self.test_user_1.id).action_confirm()
self.assertEqual(self.test_record.state, "confirmed")
def test_02_no_auto_validation(self):
"""User with no right to validate future reviews must request a
validation."""
with self.assertRaises(ValidationError):
self.test_record.with_user(self.test_user_2.id).action_confirm()
def test_03_request_validation_approved(self):
"""User 2 request a validation and user 1 approves it."""
self.assertFalse(self.test_record.review_ids)
reviews = self.test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
record.validate_tier()
self.assertTrue(record.validated)
def test_04_request_validation_rejected(self):
"""Request validation, rejection and reset."""
self.assertFalse(self.test_record.review_ids)
reviews = self.test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
record.reject_tier()
self.assertTrue(record.review_ids)
self.assertTrue(record.rejected)
record.restart_validation()
self.assertFalse(record.review_ids)
def test_05_under_validation(self):
"""Write is forbidden in a record under validation."""
self.assertFalse(self.test_record.review_ids)
reviews = self.test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
with self.assertRaises(ValidationError):
record.write({"test_field": 0.5})
def test_06_validation_process_open(self):
"""Operation forbidden while a validation process is open."""
self.assertFalse(self.test_record.review_ids)
reviews = self.test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
with self.assertRaises(ValidationError):
record.action_confirm()
def test_07_search_reviewers(self):
"""Test search methods."""
reviews = self.test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
self.assertIn(self.test_user_1, record.reviewer_ids)
res = self.test_model.search([("reviewer_ids", "in", self.test_user_1.id)])
self.assertTrue(res)
def test_08_search_validated(self):
"""Test for the validated search method."""
self.test_record.with_user(self.test_user_2.id).request_validation()
self.test_record.invalidate_cache()
res = self.test_model.with_user(self.test_user_1.id).search(
[("validated", "=", False)]
)
self.assertTrue(res)
def test_09_search_rejected(self):
"""Test for the rejected search method."""
self.test_record.with_user(self.test_user_2.id).request_validation()
self.test_record.invalidate_cache()
res = self.test_model.with_user(self.test_user_1.id).search(
[("rejected", "=", False)]
)
self.assertTrue(res)
def test_10_systray_counter(self):
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions for both tester models
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
}
)
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
}
)
self.tier_def_obj.create(
{
"model_id": self.tester_model_2.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
}
)
# Request validation
self.test_record.with_user(self.test_user_2.id).request_validation()
self.test_record.invalidate_cache()
test_record.with_user(self.test_user_2.id).request_validation()
test_record.invalidate_cache()
self.test_record_2.with_user(self.test_user_2.id).request_validation()
self.test_record_2.invalidate_cache()
# Get review user count as systray icon would do and check count value
docs = self.test_user_1.with_user(self.test_user_1).review_user_count()
for doc in docs:
if doc.get("name") == "tier.validation.tester2":
self.assertEqual(doc.get("pending_count"), 1)
else:
self.assertEqual(doc.get("pending_count"), 2)
def test_11_add_comment(self):
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"has_comment": True,
}
)
# Request validation
review = test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(review)
record = test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
res = record.validate_tier()
ctx = res.get("context")
wizard = Form(self.env["comment.wizard"].with_context(**ctx))
wizard.comment = "Test Comment"
wiz = wizard.save()
wiz.add_comment()
self.assertTrue(test_record.review_ids.mapped("comment"))
# Check notify
comment = test_record.with_user(
self.test_user_1.id
)._notify_accepted_reviews_body()
self.assertEqual(comment, "A review was accepted. (Test Comment)")
comment = test_record.with_user(
self.test_user_1.id
)._notify_rejected_review_body()
self.assertEqual(comment, "A review was rejected by John. (Test Comment)")
def test_11_add_comment_rejection(self):
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"has_comment": True,
}
)
# Request validation
review = test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(review)
record = test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
res = record.reject_tier() # Rejection
ctx = res.get("context")
wizard = Form(self.env["comment.wizard"].with_context(**ctx))
wizard.comment = "Test Comment"
wiz = wizard.save()
wiz.add_comment()
self.assertTrue(test_record.review_ids.mapped("comment"))
# Check notify
comment = test_record.with_user(
self.test_user_1.id
)._notify_accepted_reviews_body()
self.assertEqual(comment, "A review was accepted. (Test Comment)")
comment = test_record.with_user(
self.test_user_1.id
)._notify_rejected_review_body()
self.assertEqual(comment, "A review was rejected by John. (Test Comment)")
def test_12_approve_sequence(self):
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
"sequence": 30,
}
)
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_2.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
"sequence": 10,
}
)
# Request validation
self.assertFalse(self.test_record.review_ids)
reviews = test_record.with_user(self.test_user_2.id).request_validation()
self.assertTrue(reviews)
docs1 = self.test_user_2.with_user(self.test_user_1).review_user_count()
for doc in docs1:
self.assertEqual(doc.get("pending_count"), 1)
docs2 = self.test_user_2.with_user(self.test_user_2).review_user_count()
for doc in docs2:
self.assertEqual(doc.get("pending_count"), 0)
record1 = test_record.with_user(self.test_user_1.id)
record1.invalidate_cache()
self.assertTrue(record1.can_review)
record2 = test_record.with_user(self.test_user_2.id)
record2.invalidate_cache()
self.assertFalse(record2.can_review)
# User 1 validates the record, 2 review should be approved.
self.assertFalse(any(r.status == "approved" for r in record1.review_ids))
record1.validate_tier()
self.assertTrue(any(r.status == "approved" for r in record1.review_ids))
def test_12_approve_sequence_same_user(self):
"""Similar to test_12_approve_sequence, but all same users,
the approve_sequence still apply correctly"""
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
"sequence": 20,
}
)
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
"sequence": 10,
}
)
# Request validation
self.assertFalse(self.test_record.review_ids)
reviews = test_record.with_user(self.test_user_1.id).request_validation()
self.assertTrue(reviews)
record1 = test_record.with_user(self.test_user_1.id)
record1.invalidate_cache()
self.assertTrue(record1.can_review)
# Validation will be all by sequence
self.assertEqual(
3, len(record1.review_ids.filtered(lambda l: l.status == "pending"))
)
record1.validate_tier()
self.assertEqual(
2, len(record1.review_ids.filtered(lambda l: l.status == "pending"))
)
record1.validate_tier()
self.assertEqual(
1, len(record1.review_ids.filtered(lambda l: l.status == "pending"))
)
record1.validate_tier()
self.assertEqual(
0, len(record1.review_ids.filtered(lambda l: l.status == "pending"))
)
def test_13_onchange_review_type(self):
tier_def_id = self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
}
)
self.assertTrue(tier_def_id.reviewer_id)
tier_def_id.review_type = "group"
tier_def_id.onchange_review_type()
self.assertFalse(tier_def_id.reviewer_id)
def test_14_onchange_review_type(self):
tier_def_id = self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
}
)
self.assertTrue(tier_def_id.reviewer_id)
tier_def_id.review_type = "group"
tier_def_id.onchange_review_type()
self.assertFalse(tier_def_id.reviewer_id)
def test_15_review_user_count(self):
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"has_comment": True,
}
)
# Request validation
review = test_record.with_user(self.test_user_2).request_validation()
self.assertTrue(review)
self.assertTrue(self.test_user_1.get_reviews({"res_ids": review.ids}))
self.assertTrue(self.test_user_1.review_ids)
test_record.invalidate_cache()
self.assertTrue(test_record.review_ids)
# Used by front-end
count = self.test_user_1.with_user(self.test_user_1).review_user_count()
self.assertEqual(len(count), 1)
# False Review
self.assertFalse(self.test_record._calc_reviews_validated(False))
self.assertIn("requested", self.test_record._notify_requested_review_body())
self.assertIn("rejected", self.test_record._notify_rejected_review_body())
self.assertIn("accepted", self.test_record._notify_accepted_reviews_body())
def test_16_review_user_count_on_rejected(self):
"""If document is rejected, it should always removed from tray"""
# Create new test record
test_record = self.test_model.create({"test_field": 2.5})
# Create tier definitions
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_2.id,
"definition_domain": "[('test_field', '>', 1.0)]",
}
)
test_record.with_user(self.test_user_2).request_validation()
record1 = test_record.with_user(self.test_user_1)
record1.invalidate_cache()
self.assertTrue(record1.can_review)
self.assertTrue(
self.test_user_1.with_user(self.test_user_1).review_user_count()
)
self.assertTrue(
self.test_user_2.with_user(self.test_user_2).review_user_count()
)
# user 1 reject first tier
record1.reject_tier()
record1.invalidate_cache()
self.assertFalse(record1.can_review)
# both user 1 and 2 has nothing left in tray
self.assertFalse(
self.test_user_1.with_user(self.test_user_1).review_user_count()
)
self.assertFalse(
self.test_user_2.with_user(self.test_user_2).review_user_count()
)
def test_17_search_records_no_validation(self):
"""Search for records that have no validation process started"""
records = self.env["tier.validation.tester"].search(
[("reviewer_ids", "=", False)]
)
self.assertEqual(len(records), 1)
self.test_record.with_user(self.test_user_2.id).request_validation()
record = self.test_record.with_user(self.test_user_1.id)
record.invalidate_cache()
records = self.env["tier.validation.tester"].search(
[("reviewer_ids", "=", False)]
)
self.assertEqual(len(records), 0)
def test_18_test_review_by_res_users_field(self):
selected_field = self.env["ir.model.fields"].search(
[("model", "=", self.test_model._name), ("name", "=", "user_id")]
)
test_record = self.test_model.create(
{"test_field": 2.5, "user_id": self.test_user_2.id}
)
definition = self.env["tier.definition"].create(
{
"model_id": self.tester_model.id,
"review_type": "field",
"reviewer_field_id": selected_field.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
}
)
reviews = test_record.request_validation()
review = reviews.filtered(lambda r: r.definition_id == definition)
self.assertTrue(review)
self.assertEqual(review.reviewer_ids, self.test_user_2)
@tagged("at_install")
class TierTierValidationView(CommonTierValidation):
def test_view_manual(self):
# We need to add a view in order to ensure that an automatic view with all
# fields is not created
self.env["ir.ui.view"].create(
{
"model": self.test_record._name,
"name": "Demo view",
"arch": """<form>
<header>
<button name="action_confirm" type="object" string="Confirm" />
<field name="state" widget="statusbar" />
</header>
<sheet>
<field name="test_field" />
</sheet>
</form>""",
}
)
with Form(self.test_record) as f:
self.assertNotIn("review_ids", f._values)
form = etree.fromstring(f._view["arch"])
self.assertFalse(form.xpath("//field[@name='review_ids']"))
self.assertFalse(form.xpath("//field[@name='can_review']"))
self.assertFalse(form.xpath("//button[@name='request_validation']"))
def test_view_automatic(self):
# We need to add a view in order to ensure that an automatic view with all
# fields is not created
self.env["ir.ui.view"].create(
{
"model": self.test_record_2._name,
"name": "Demo view",
"arch": """<form>
<header>
<button name="action_confirm" type="object" string="Confirm" />
<field name="state" widget="statusbar" />
</header>
<sheet>
<field name="test_field" />
</sheet>
</form>""",
}
)
with Form(self.test_record_2) as f:
self.assertIn("review_ids", f._values)
form = etree.fromstring(f._view["arch"])
self.assertTrue(form.xpath("//field[@name='review_ids']"))
self.assertTrue(form.xpath("//field[@name='can_review']"))
self.assertTrue(form.xpath("//button[@name='request_validation']"))
| 41.45102 | 20,311 |
2,673 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo_test_helper import FakeModelLoader
from odoo.tests import common
class CommonTierValidation(common.TransactionCase):
@classmethod
def setUpClass(cls):
super(CommonTierValidation, cls).setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .tier_validation_tester import TierValidationTester, TierValidationTester2
cls.loader.update_registry((TierValidationTester, TierValidationTester2))
cls.test_model = cls.env[TierValidationTester._name]
cls.test_model_2 = cls.env[TierValidationTester2._name]
cls.tester_model = cls.env["ir.model"].search(
[("model", "=", "tier.validation.tester")]
)
cls.tester_model_2 = cls.env["ir.model"].search(
[("model", "=", "tier.validation.tester2")]
)
# Access record:
cls.env["ir.model.access"].create(
{
"name": "access.tester",
"model_id": cls.tester_model.id,
"perm_read": 1,
"perm_write": 1,
"perm_create": 1,
"perm_unlink": 1,
}
)
cls.env["ir.model.access"].create(
{
"name": "access.tester2",
"model_id": cls.tester_model_2.id,
"perm_read": 1,
"perm_write": 1,
"perm_create": 1,
"perm_unlink": 1,
}
)
# Create users:
group_ids = cls.env.ref("base.group_system").ids
cls.test_user_1 = cls.env["res.users"].create(
{"name": "John", "login": "test1", "groups_id": [(6, 0, group_ids)]}
)
cls.test_user_2 = cls.env["res.users"].create(
{"name": "Mike", "login": "test2"}
)
# Create tier definitions:
cls.tier_def_obj = cls.env["tier.definition"]
cls.tier_def_obj.create(
{
"model_id": cls.tester_model.id,
"review_type": "individual",
"reviewer_id": cls.test_user_1.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"sequence": 30,
}
)
cls.test_record = cls.test_model.create({"test_field": 2.5})
cls.test_record_2 = cls.test_model_2.create({"test_field": 2.5})
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super(CommonTierValidation, cls).tearDownClass()
| 33.835443 | 2,673 |
855 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class CommentWizard(models.TransientModel):
_name = "comment.wizard"
_description = "Comment Wizard"
validate_reject = fields.Char()
res_model = fields.Char()
res_id = fields.Integer()
review_ids = fields.Many2many(comodel_name="tier.review")
comment = fields.Char(required=True)
def add_comment(self):
self.ensure_one()
rec = self.env[self.res_model].browse(self.res_id)
self.review_ids.write({"comment": self.comment})
if self.validate_reject == "validate":
rec._validate_tier(self.review_ids)
if self.validate_reject == "reject":
rec._rejected_tier(self.review_ids)
rec._update_counter()
| 34.2 | 855 |
2,952 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
class TierDefinition(models.Model):
_name = "tier.definition"
_description = "Tier Definition"
@api.model
def _get_default_name(self):
return _("New Tier Validation")
@api.model
def _get_tier_validation_model_names(self):
res = []
return res
name = fields.Char(
string="Description",
required=True,
default=lambda self: self._get_default_name(),
translate=True,
)
model_id = fields.Many2one(
comodel_name="ir.model",
string="Referenced Model",
domain=lambda self: [("model", "in", self._get_tier_validation_model_names())],
)
model = fields.Char(related="model_id.model", index=True, store=True)
review_type = fields.Selection(
string="Validated by",
default="individual",
selection=[
("individual", "Specific user"),
("group", "Any user in a specific group"),
("field", "Field in related record"),
],
)
reviewer_id = fields.Many2one(comodel_name="res.users", string="Reviewer")
reviewer_group_id = fields.Many2one(
comodel_name="res.groups", string="Reviewer group"
)
reviewer_field_id = fields.Many2one(
comodel_name="ir.model.fields",
string="Reviewer field",
domain="[('id', 'in', valid_reviewer_field_ids)]",
)
valid_reviewer_field_ids = fields.One2many(
comodel_name="ir.model.fields",
compute="_compute_domain_reviewer_field",
)
definition_type = fields.Selection(
string="Definition", selection=[("domain", "Domain")], default="domain"
)
definition_domain = fields.Char()
active = fields.Boolean(default=True)
sequence = fields.Integer(default=30)
company_id = fields.Many2one(
comodel_name="res.company",
string="Company",
default=lambda self: self.env.company,
)
notify_on_create = fields.Boolean(
string="Notify Reviewers on Creation",
help="If set, all possible reviewers will be notified by email when "
"this definition is triggered.",
)
has_comment = fields.Boolean(string="Comment", default=False)
approve_sequence = fields.Boolean(
string="Approve by sequence",
default=False,
help="Approval order by the specified sequence number",
)
@api.onchange("review_type")
def onchange_review_type(self):
self.reviewer_id = None
self.reviewer_group_id = None
@api.depends("review_type", "model_id")
def _compute_domain_reviewer_field(self):
for rec in self:
rec.valid_reviewer_field_ids = self.env["ir.model.fields"].search(
[("model", "=", rec.model), ("relation", "=", "res.users")]
)
| 33.931034 | 2,952 |
2,245 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models, modules
class Users(models.Model):
_inherit = "res.users"
review_ids = fields.Many2many(string="Reviews", comodel_name="tier.review")
@api.model
def review_user_count(self):
user_reviews = {}
domain = [
("status", "=", "pending"),
("can_review", "=", True),
("id", "in", self.env.user.review_ids.ids),
]
review_groups = self.env["tier.review"].read_group(domain, ["model"], ["model"])
for review_group in review_groups:
model = review_group["model"]
reviews = self.env["tier.review"].search(review_group.get("__domain"))
if reviews:
records = (
self.env[model]
.with_user(self.env.user)
.search([("id", "in", reviews.mapped("res_id"))])
.filtered(lambda x: not x.rejected and x.can_review)
)
if len(records):
record = self.env[model]
user_reviews[model] = {
"name": record._description,
"model": model,
"active_field": "active" in record._fields,
"icon": modules.module.get_module_icon(record._original_module),
"pending_count": len(records),
}
return list(user_reviews.values())
@api.model
def get_reviews(self, data):
review_obj = self.env["tier.review"].with_context(lang=self.env.user.lang)
res = review_obj.search_read([("id", "in", data.get("res_ids"))])
for r in res:
# Get the translated status value.
r["display_status"] = dict(
review_obj.fields_get("status")["status"]["selection"]
).get(r.get("status"))
# Convert to datetime timezone
if r["reviewed_date"]:
r["reviewed_date"] = fields.Datetime.context_timestamp(
self, r["reviewed_date"]
)
return res
| 40.089286 | 2,245 |
563 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Ecosoft Co., Ltd. (http://ecosoft.co.th)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
module_base_tier_validation_formula = fields.Boolean(string="Tier Formula")
module_base_tier_validation_forward = fields.Boolean("Tier Forward & Backward")
module_base_tier_validation_server_action = fields.Boolean("Tier Server Action")
module_base_tier_validation_report = fields.Boolean("Tier Reports")
| 46.916667 | 563 |
20,296 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from ast import literal_eval
from lxml import etree
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class TierValidation(models.AbstractModel):
_name = "tier.validation"
_description = "Tier Validation (abstract)"
_tier_validation_buttons_xpath = "/form/header/button[last()]"
_tier_validation_manual_config = True
_state_field = "state"
_state_from = ["draft"]
_state_to = ["confirmed"]
_cancel_state = "cancel"
# TODO: step by step validation?
review_ids = fields.One2many(
comodel_name="tier.review",
inverse_name="res_id",
string="Validations",
domain=lambda self: [("model", "=", self._name)],
auto_join=True,
)
to_validate_message = fields.Html(compute="_compute_validated_rejected")
validated = fields.Boolean(
compute="_compute_validated_rejected", search="_search_validated"
)
validated_message = fields.Html(compute="_compute_validated_rejected")
need_validation = fields.Boolean(compute="_compute_need_validation")
rejected = fields.Boolean(
compute="_compute_validated_rejected", search="_search_rejected"
)
rejected_message = fields.Html(compute="_compute_validated_rejected")
reviewer_ids = fields.Many2many(
string="Reviewers",
comodel_name="res.users",
compute="_compute_reviewer_ids",
search="_search_reviewer_ids",
)
can_review = fields.Boolean(
compute="_compute_can_review", search="_search_can_review"
)
has_comment = fields.Boolean(compute="_compute_has_comment")
next_review = fields.Char(compute="_compute_next_review")
def _compute_has_comment(self):
for rec in self:
has_comment = rec.review_ids.filtered(
lambda r: r.status == "pending" and (self.env.user in r.reviewer_ids)
).mapped("has_comment")
rec.has_comment = True in has_comment
def _get_sequences_to_approve(self, user):
all_reviews = self.review_ids.filtered(lambda r: r.status == "pending")
my_reviews = all_reviews.filtered(lambda r: user in r.reviewer_ids)
# Include all my_reviews with approve_sequence = False
sequences = my_reviews.filtered(lambda r: not r.approve_sequence).mapped(
"sequence"
)
# Include only my_reviews with approve_sequence = True
approve_sequences = my_reviews.filtered("approve_sequence").mapped("sequence")
if approve_sequences:
my_sequence = min(approve_sequences)
min_sequence = min(all_reviews.mapped("sequence"))
if my_sequence <= min_sequence:
sequences.append(my_sequence)
return sequences
def _compute_can_review(self):
for rec in self:
rec.can_review = rec._get_sequences_to_approve(self.env.user)
@api.model
def _search_can_review(self, operator, value):
domain = [
("review_ids.reviewer_ids", "=", self.env.user.id),
("review_ids.status", "=", "pending"),
("review_ids.can_review", "=", True),
("rejected", "=", False),
]
if "active" in self._fields:
domain.append(("active", "in", [True, False]))
res_ids = self.search(domain).filtered("can_review").ids
return [("id", "in", res_ids)]
@api.depends("review_ids")
def _compute_reviewer_ids(self):
for rec in self:
rec.reviewer_ids = rec.review_ids.filtered(
lambda r: r.status == "pending"
).mapped("reviewer_ids")
@api.model
def _search_validated(self, operator, value):
assert operator in ("=", "!="), "Invalid domain operator"
assert value in (True, False), "Invalid domain value"
pos = self.search([(self._state_field, "in", self._state_from)]).filtered(
lambda r: r.review_ids and r.validated == value
)
return [("id", "in", pos.ids)]
@api.model
def _search_rejected(self, operator, value):
assert operator in ("=", "!="), "Invalid domain operator"
assert value in (True, False), "Invalid domain value"
pos = self.search([(self._state_field, "in", self._state_from)]).filtered(
lambda r: r.review_ids and r.rejected == value
)
return [("id", "in", pos.ids)]
@api.model
def _search_reviewer_ids(self, operator, value):
model_operator = "in"
if operator == "=" and value in ("[]", False):
# Search for records that have not yet been through a validation
# process.
operator = "!="
model_operator = "not in"
reviews = self.env["tier.review"].search(
[
("model", "=", self._name),
("reviewer_ids", operator, value),
("can_review", "=", True),
("status", "=", "pending"),
]
)
return [("id", model_operator, list(set(reviews.mapped("res_id"))))]
def _get_to_validate_message_name(self):
return self._description
def _get_to_validate_message(self):
return (
"""<i class="fa fa-info-circle" /> %s"""
% _("This %s needs to be validated")
% self._get_to_validate_message_name()
)
def _get_validated_message(self):
msg = """<i class="fa fa-thumbs-up" /> %s""" % _(
"""Operation has been <b>validated</b>!"""
)
return self.validated and msg or ""
def _get_rejected_message(self):
msg = """<i class="fa fa-thumbs-down" /> %s""" % _(
"""Operation has been <b>rejected</b>."""
)
return self.rejected and msg or ""
def _compute_validated_rejected(self):
for rec in self:
rec.validated = self._calc_reviews_validated(rec.review_ids)
rec.validated_message = rec._get_validated_message()
rec.rejected = self._calc_reviews_rejected(rec.review_ids)
rec.rejected_message = rec._get_rejected_message()
rec.to_validate_message = rec._get_to_validate_message()
def _compute_next_review(self):
for rec in self:
review = rec.review_ids.sorted("sequence").filtered(
lambda l: l.status == "pending"
)[:1]
rec.next_review = review and _("Next: %s") % review.name or ""
@api.model
def _calc_reviews_validated(self, reviews):
"""Override for different validation policy."""
if not reviews:
return False
return not any([s != "approved" for s in reviews.mapped("status")])
@api.model
def _calc_reviews_rejected(self, reviews):
"""Override for different rejection policy."""
return any([s == "rejected" for s in reviews.mapped("status")])
def _compute_need_validation(self):
for rec in self:
if isinstance(rec.id, models.NewId):
rec.need_validation = False
continue
tiers = self.env["tier.definition"].search([("model", "=", self._name)])
valid_tiers = any([rec.evaluate_tier(tier) for tier in tiers])
rec.need_validation = (
not rec.review_ids and valid_tiers and rec._check_state_from_condition()
)
def evaluate_tier(self, tier):
if tier.definition_domain:
domain = literal_eval(tier.definition_domain)
return self.filtered_domain(domain)
else:
return self
@api.model
def _get_under_validation_exceptions(self):
"""Extend for more field exceptions."""
return ["message_follower_ids", "access_token"]
def _check_allow_write_under_validation(self, vals):
"""Allow to add exceptions for fields that are allowed to be written
even when the record is under validation."""
exceptions = self._get_under_validation_exceptions()
for val in vals:
if val not in exceptions:
return False
return True
def write(self, vals):
for rec in self:
if rec._check_state_conditions(vals):
if rec.need_validation:
# try to validate operation
reviews = rec.request_validation()
rec._validate_tier(reviews)
if not self._calc_reviews_validated(reviews):
raise ValidationError(
_(
"This action needs to be validated for at least "
"one record. \nPlease request a validation."
)
)
if rec.review_ids and not rec.validated:
raise ValidationError(
_(
"A validation process is still open for at least "
"one record."
)
)
if (
rec.review_ids
and getattr(rec, self._state_field) in self._state_from
and not vals.get(self._state_field)
in (self._state_to + [self._cancel_state])
and not rec._check_allow_write_under_validation(vals)
and not rec._context.get("skip_validation_check")
):
raise ValidationError(_("The operation is under validation."))
if vals.get(self._state_field) in (self._state_from + [self._cancel_state]):
self.mapped("review_ids").unlink()
return super(TierValidation, self).write(vals)
def _check_state_from_condition(self):
return self.env.context.get("skip_check_state_condition") or (
self._state_field in self._fields
and getattr(self, self._state_field) in self._state_from
)
def _check_state_conditions(self, vals):
self.ensure_one()
return (
self._check_state_from_condition()
and vals.get(self._state_field) in self._state_to
)
def _validate_tier(self, tiers=False):
self.ensure_one()
tier_reviews = tiers or self.review_ids
user_reviews = tier_reviews.filtered(
lambda r: r.status == "pending" and (self.env.user in r.reviewer_ids)
)
user_reviews.write(
{
"status": "approved",
"done_by": self.env.user.id,
"reviewed_date": fields.Datetime.now(),
}
)
for review in user_reviews:
rec = self.env[review.model].browse(review.res_id)
rec._notify_accepted_reviews()
def _get_requested_notification_subtype(self):
return "base_tier_validation.mt_tier_validation_requested"
def _get_accepted_notification_subtype(self):
return "base_tier_validation.mt_tier_validation_accepted"
def _get_rejected_notification_subtype(self):
return "base_tier_validation.mt_tier_validation_rejected"
def _get_restarted_notification_subtype(self):
return "base_tier_validation.mt_tier_validation_restarted"
def _notify_accepted_reviews(self):
post = "message_post"
if hasattr(self, post):
# Notify state change
getattr(self.sudo(), post)(
subtype_xmlid=self._get_accepted_notification_subtype(),
body=self._notify_accepted_reviews_body(),
)
def _notify_accepted_reviews_body(self):
has_comment = self.review_ids.filtered(
lambda r: (self.env.user in r.reviewer_ids) and r.comment
)
if has_comment:
comment = has_comment.mapped("comment")[0]
return _("A review was accepted. (%s)") % comment
return _("A review was accepted")
def _add_comment(self, validate_reject, reviews):
wizard = self.env.ref("base_tier_validation.view_comment_wizard")
return {
"name": _("Comment"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "comment.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {
"default_res_id": self.id,
"default_res_model": self._name,
"default_review_ids": reviews.ids,
"default_validate_reject": validate_reject,
},
}
def validate_tier(self):
self.ensure_one()
sequences = self._get_sequences_to_approve(self.env.user)
reviews = self.review_ids.filtered(lambda l: l.sequence in sequences)
if self.has_comment:
return self._add_comment("validate", reviews)
self._validate_tier(reviews)
self._update_counter()
def reject_tier(self):
self.ensure_one()
sequences = self._get_sequences_to_approve(self.env.user)
reviews = self.review_ids.filtered(lambda l: l.sequence in sequences)
if self.has_comment:
return self._add_comment("reject", reviews)
self._rejected_tier(reviews)
self._update_counter()
def _notify_rejected_review_body(self):
has_comment = self.review_ids.filtered(
lambda r: (self.env.user in r.reviewer_ids) and r.comment
)
if has_comment:
comment = has_comment.mapped("comment")[0]
return _("A review was rejected by %(user)s. (%(comment)s)") % {
"user": self.env.user.name,
"comment": comment,
}
return _("A review was rejected by %s.") % (self.env.user.name)
def _notify_rejected_review(self):
post = "message_post"
if hasattr(self, post):
# Notify state change
getattr(self.sudo(), post)(
subtype_xmlid=self._get_rejected_notification_subtype(),
body=self._notify_rejected_review_body(),
)
def _rejected_tier(self, tiers=False):
self.ensure_one()
tier_reviews = tiers or self.review_ids
user_reviews = tier_reviews.filtered(
lambda r: r.status == "pending" and (self.env.user in r.reviewer_ids)
)
user_reviews.write(
{
"status": "rejected",
"done_by": self.env.user.id,
"reviewed_date": fields.Datetime.now(),
}
)
for review in user_reviews:
rec = self.env[review.model].browse(review.res_id)
rec._notify_rejected_review()
def _notify_requested_review_body(self):
return _("A review has been requested by %s.") % (self.env.user.name)
def _notify_review_requested(self, tier_reviews):
subscribe = "message_subscribe"
post = "message_post"
if hasattr(self, post) and hasattr(self, subscribe):
for rec in self:
users_to_notify = tier_reviews.filtered(
lambda r: r.definition_id.notify_on_create and r.res_id == rec.id
).mapped("reviewer_ids")
# Subscribe reviewers and notify
getattr(rec, subscribe)(
partner_ids=users_to_notify.mapped("partner_id").ids
)
getattr(rec, post)(
subtype_xmlid=self._get_requested_notification_subtype(),
body=rec._notify_requested_review_body(),
)
def request_validation(self):
td_obj = self.env["tier.definition"]
tr_obj = created_trs = self.env["tier.review"]
for rec in self:
if rec._check_state_from_condition():
if rec.need_validation:
tier_definitions = td_obj.search(
[("model", "=", self._name)], order="sequence desc"
)
sequence = 0
for td in tier_definitions:
if rec.evaluate_tier(td):
sequence += 1
created_trs += tr_obj.create(
{
"model": self._name,
"res_id": rec.id,
"definition_id": td.id,
"sequence": sequence,
"requested_by": self.env.uid,
}
)
self._update_counter()
self._notify_review_requested(created_trs)
return created_trs
def _notify_restarted_review_body(self):
return _("The review has been reset by %s.") % (self.env.user.name)
def _notify_restarted_review(self):
post = "message_post"
if hasattr(self, post):
getattr(self.sudo(), post)(
subtype_xmlid=self._get_restarted_notification_subtype(),
body=self._notify_restarted_review_body(),
)
def restart_validation(self):
for rec in self:
if getattr(rec, self._state_field) in self._state_from:
rec.mapped("review_ids").unlink()
self._update_counter()
rec._notify_restarted_review()
@api.model
def _update_counter(self):
self.review_ids._compute_can_review()
notifications = []
channel = "base.tier.validation"
notifications.append([self.env.user.partner_id, channel, {}])
self.env["bus.bus"]._sendmany(notifications)
def unlink(self):
self.mapped("review_ids").unlink()
return super().unlink()
def _add_tier_validation_buttons(self, node, params):
str_element = self.env["ir.qweb"]._render(
"base_tier_validation.tier_validation_buttons", params
)
new_node = etree.fromstring(str_element)
for new_element in new_node:
node.addnext(new_element)
def _add_tier_validation_label(self, node, params):
str_element = self.env["ir.qweb"]._render(
"base_tier_validation.tier_validation_label", params
)
new_node = etree.fromstring(str_element)
for new_element in new_node:
node.addprevious(new_element)
def _add_tier_validation_reviews(self, node, params):
str_element = self.env["ir.qweb"]._render(
"base_tier_validation.tier_validation_reviews", params
)
node.addnext(etree.fromstring(str_element))
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "form" and not self._tier_validation_manual_config:
doc = etree.XML(res["arch"])
params = {
"state_field": self._state_field,
"state_operator": "not in",
"state_value": self._state_from,
}
for node in doc.xpath(self._tier_validation_buttons_xpath):
# By default, after the last button of the header
self._add_tier_validation_buttons(node, params)
for node in doc.xpath("/form/sheet"):
self._add_tier_validation_label(node, params)
self._add_tier_validation_reviews(node, params)
View = self.env["ir.ui.view"]
# Override context for postprocessing
if view_id and res.get("base_model", self._name) != self._name:
View = View.with_context(base_model_name=res["base_model"])
new_arch, new_fields = View.postprocess_and_fields(doc, self._name)
res["arch"] = new_arch
# We don't want to loose previous configuration, so, we only want to add
# the new fields
new_fields.update(res["fields"])
res["fields"] = new_fields
return res
| 39.333333 | 20,296 |
4,361 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-19 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class TierReview(models.Model):
_name = "tier.review"
_description = "Tier Review"
name = fields.Char(related="definition_id.name", readonly=True)
status = fields.Selection(
selection=[
("pending", "Pending"),
("rejected", "Rejected"),
("approved", "Approved"),
],
default="pending",
)
model = fields.Char(string="Related Document Model", index=True)
res_id = fields.Integer(string="Related Document ID", index=True)
definition_id = fields.Many2one(comodel_name="tier.definition")
company_id = fields.Many2one(
related="definition_id.company_id",
store=True,
)
review_type = fields.Selection(related="definition_id.review_type", readonly=True)
reviewer_id = fields.Many2one(related="definition_id.reviewer_id", readonly=True)
reviewer_group_id = fields.Many2one(
related="definition_id.reviewer_group_id", readonly=True
)
reviewer_field_id = fields.Many2one(
related="definition_id.reviewer_field_id", readonly=True
)
reviewer_ids = fields.Many2many(
string="Reviewers",
comodel_name="res.users",
compute="_compute_reviewer_ids",
store=True,
)
sequence = fields.Integer(string="Tier")
todo_by = fields.Char(compute="_compute_todo_by", store=True)
done_by = fields.Many2one(comodel_name="res.users")
requested_by = fields.Many2one(comodel_name="res.users")
reviewed_date = fields.Datetime(string="Validation Date")
has_comment = fields.Boolean(related="definition_id.has_comment", readonly=True)
comment = fields.Char(string="Comments")
can_review = fields.Boolean(
compute="_compute_can_review",
store=True,
help="""Can review will be marked if the review is pending and the
approve sequence has been achieved""",
)
approve_sequence = fields.Boolean(
related="definition_id.approve_sequence", readonly=True
)
@api.depends("definition_id.approve_sequence")
def _compute_can_review(self):
for record in self:
record.can_review = record._can_review_value()
def _can_review_value(self):
if self.status != "pending":
return False
if not self.approve_sequence:
return True
resource = self.env[self.model].browse(self.res_id)
reviews = resource.review_ids.filtered(lambda r: r.status == "pending")
if not reviews:
return True
sequence = min(reviews.mapped("sequence"))
return self.sequence == sequence
@api.model
def _get_reviewer_fields(self):
return ["reviewer_id", "reviewer_group_id", "reviewer_group_id.users"]
@api.depends(lambda self: self._get_reviewer_fields())
def _compute_reviewer_ids(self):
for rec in self:
rec.reviewer_ids = rec._get_reviewers()
@api.depends("reviewer_ids")
def _compute_todo_by(self):
"""Show by group or by abbrev list of names"""
num_show = 3 # Max number of users to display
for rec in self:
todo_by = False
if rec.reviewer_group_id:
todo_by = _("Group %s") % rec.reviewer_group_id.name
else:
todo_by = ", ".join(rec.reviewer_ids[:num_show].mapped("display_name"))
num_users = len(rec.reviewer_ids)
if num_users > num_show:
todo_by = "{} (and {} more)".format(todo_by, num_users - num_show)
rec.todo_by = todo_by
def _get_reviewers(self):
if self.reviewer_id or self.reviewer_group_id.users:
return self.reviewer_id + self.reviewer_group_id.users
reviewer_field = self.env["res.users"]
if self.reviewer_field_id:
resource = self.env[self.model].browse(self.res_id)
reviewer_field = getattr(resource, self.reviewer_field_id.name, False)
if not reviewer_field or not reviewer_field._name == "res.users":
raise ValidationError(_("There are no res.users in the selected field"))
return reviewer_field
| 40.009174 | 4,361 |
709 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Serpent Consulting Services Pvt. Ltd. ([email protected])
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Mass Editing",
"version": "15.0.1.0.1",
"author": "Serpent Consulting Services Pvt. Ltd., "
"Tecnativa, "
"GRAP, "
"Iván Todorovich, "
"Odoo Community Association (OCA)",
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"summary": "Mass Editing",
"depends": [
"base",
],
"data": [
"security/ir.model.access.csv",
"views/ir_actions_server.xml",
"wizard/mass_editing_wizard.xml",
],
"demo": ["demo/mass_editing.xml"],
}
| 29.5 | 708 |
13,476 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Serpent Consulting Services Pvt. Ltd. ([email protected])
# Copyright 2018 Aitor Bouzas <[email protected])
# Copyrithg 2020 Iván Todorovich <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from ast import literal_eval
from odoo.exceptions import ValidationError
from odoo.tests import Form, common, new_test_user
from odoo.addons.base.models.ir_actions import IrActionsServer
def fake_onchange_model_id(self):
result = {
"warning": {
"title": "This is a fake onchange",
},
}
return result
@common.tagged("-at_install", "post_install")
class TestMassEditing(common.TransactionCase):
def setUp(self):
super().setUp()
self.MassEditingWizard = self.env["mass.editing.wizard"]
self.ResPartnerTitle = self.env["res.partner.title"]
self.ResLang = self.env["res.lang"]
self.IrTranslation = self.env["ir.translation"]
self.IrActionsActWindow = self.env["ir.actions.act_window"]
self.mass_editing_user = self.env.ref("mass_editing.mass_editing_user")
self.mass_editing_partner_title = self.env.ref(
"mass_editing.mass_editing_partner_title"
)
user_admin = self.env.ref("base.user_admin")
user_demo = self.env.ref("base.user_demo")
self.users = self.env["res.users"].search(
[("id", "not in", (user_admin.id, user_demo.id))]
)
self.user = new_test_user(
self.env,
login="test-mass_editing-user",
groups="base.group_system",
)
self.partner_title = self._create_partner_title()
def _create_partner_title(self):
"""Create a Partner Title."""
# Loads German to work with translations
self.ResLang._activate_lang("de_DE")
# Creating the title in English
partner_title = self.ResPartnerTitle.create(
{"name": "Ambassador", "shortcut": "Amb."}
)
# Adding translated terms
partner_title.with_context(lang="de_DE").write(
{"name": "Botschafter", "shortcut": "Bots."}
)
return partner_title
def _create_wizard_and_apply_values(self, server_action, items, vals):
action = server_action.with_context(
active_model=items._name,
active_ids=items.ids,
).run()
wizard = (
self.env[action["res_model"]]
.with_context(
**literal_eval(action["context"]),
)
.create(vals)
)
wizard.button_apply()
return wizard
def test_wzd_default_get(self):
"""Test whether `operation_description_danger` is correct"""
wzd_obj = self.MassEditingWizard.with_context(
server_action_id=self.mass_editing_user.id,
active_ids=[1],
original_active_ids=[1],
)
result = wzd_obj.default_get(
fields=[],
)
self.assertEqual(
result["operation_description_info"],
"The treatment will be processed on the 1 selected record(s).",
)
self.assertFalse(
result["operation_description_warning"],
)
self.assertFalse(
result["operation_description_danger"],
)
result = wzd_obj.with_context(active_ids=[]).default_get(
fields=[],
)
self.assertFalse(
result["operation_description_info"],
)
self.assertEqual(
result["operation_description_warning"],
(
"You have selected 1 record(s) that can not be processed.\n"
"Only 0 record(s) will be processed."
),
)
self.assertFalse(
result["operation_description_danger"],
)
result = wzd_obj.with_context(original_active_ids=[]).default_get(
fields=[],
)
self.assertFalse(
result["operation_description_info"],
)
self.assertFalse(
result["operation_description_warning"],
)
self.assertEqual(
result["operation_description_danger"],
"None of the 1 record(s) you have selected can be processed.",
)
def test_wiz_fields_view_get(self):
"""Test whether fields_view_get method returns arch.
with dynamic fields.
"""
result = self.MassEditingWizard.with_context(
active_ids=[],
).fields_view_get()
arch = result.get("arch", "")
self.assertTrue(
"selection__email" not in arch,
"Fields view get must return architecture w/o fields" "created dynamicaly",
)
result = self.MassEditingWizard.with_context(
server_action_id=self.mass_editing_user.id,
active_ids=[],
).fields_view_get()
arch = result.get("arch", "")
self.assertTrue(
"selection__email" in arch,
"Fields view get must return architecture with fields" "created dynamicaly",
)
def test_wzd_clean_check_company_field_domain(self):
"""
Test company field domain replacement
"""
model_name = "res.partner"
field_domain = [
("model", "=", model_name),
("name", "=", "company_id"),
]
field = self.env["ir.model.fields"].search(
field_domain,
)
field_info = {
"name": "company_id",
}
result = self.MassEditingWizard._clean_check_company_field_domain(
self.env[model_name],
field=field,
field_info=field_info,
)
self.assertDictEqual(
result,
field_info,
)
model_name = "res.partner"
field_name = "parent_id"
field_domain = [
("model", "=", model_name),
("name", "=", field_name),
]
field = self.env["ir.model.fields"].search(
field_domain,
)
field_info = {
"name": field_name,
}
model = self.env[model_name]
model._fields[field_name].check_company = True
result = self.MassEditingWizard._clean_check_company_field_domain(
model,
field=field,
field_info=field_info,
)
self.assertEqual(
result.get("domain"),
"[]",
)
def test_wiz_read_fields(self):
"""Test whether read method returns all fields or not."""
fields_view = self.MassEditingWizard.with_context(
server_action_id=self.mass_editing_user.id,
active_ids=[],
).fields_view_get()
fields = list(fields_view["fields"].keys())
# add a real field
fields.append("display_name")
vals = {"selection__email": "remove", "selection__phone": "remove"}
mass_wizard = self._create_wizard_and_apply_values(
self.mass_editing_user, self.users, vals
)
result = mass_wizard.read(fields)[0]
self.assertTrue(
all([field in result for field in fields]), "Read must return all fields."
)
result = mass_wizard.read(fields=[])[0]
self.assertTrue(
"selection__email" not in result,
)
def test_mass_edit_partner_title(self):
"""Test Case for MASS EDITING which will check if translation
was loaded for new partner title, and if they are removed
as well as the value for the abbreviation for the partner title."""
search_domain = [
("res_id", "=", self.partner_title.id),
("type", "=", "model"),
("name", "=", "res.partner.title,shortcut"),
("lang", "=", "de_DE"),
]
translation_ids = self.IrTranslation.search(search_domain)
self.assertEqual(
len(translation_ids),
1,
"Translation for Partner Title's Abbreviation " "was not loaded properly.",
)
# Removing partner title with mass edit action
vals = {"selection__shortcut": "remove"}
self._create_wizard_and_apply_values(
self.mass_editing_partner_title, self.partner_title, vals
)
self.assertEqual(
self.partner_title.shortcut,
False,
"Partner Title's Abbreviation should be removed.",
)
# Checking if translations were also removed
translation_ids = self.IrTranslation.search(search_domain)
self.assertEqual(
len(translation_ids),
0,
"Translation for Partner Title's Abbreviation " "was not removed properly.",
)
def test_mass_edit_email(self):
"""Test Case for MASS EDITING which will remove and after add
User's email and will assert the same."""
# Remove email and phone
vals = {"selection__email": "remove", "selection__phone": "remove"}
self._create_wizard_and_apply_values(self.mass_editing_user, self.user, vals)
self.assertEqual(self.user.email, False, "User's Email should be removed.")
# Set email address
vals = {"selection__email": "set", "email": "[email protected]"}
self._create_wizard_and_apply_values(self.mass_editing_user, self.user, vals)
self.assertNotEqual(self.user.email, False, "User's Email should be set.")
def test_mass_edit_m2m_categ(self):
"""Test Case for MASS EDITING which will remove and add
Partner's category m2m."""
# Remove m2m categories
vals = {"selection__category_id": "remove_m2m"}
self._create_wizard_and_apply_values(self.mass_editing_user, self.user, vals)
self.assertNotEqual(
self.user.category_id, False, "User's category should be removed."
)
# Add m2m categories
dist_categ_id = self.env.ref("base.res_partner_category_14").id
vend_categ_id = self.env.ref("base.res_partner_category_0").id
vals = {
"selection__category_id": "add",
"category_id": [[6, 0, [dist_categ_id, vend_categ_id]]],
}
self._create_wizard_and_apply_values(self.mass_editing_user, self.user, vals)
self.assertTrue(
all(
item in self.user.category_id.ids
for item in [dist_categ_id, vend_categ_id]
),
"Partner's category should be added.",
)
# Remove one m2m category
vals = {
"selection__category_id": "remove_m2m",
"category_id": [[6, 0, [vend_categ_id]]],
}
self._create_wizard_and_apply_values(self.mass_editing_user, self.user, vals)
self.assertTrue(
[dist_categ_id] == self.user.category_id.ids,
"User's category should be removed.",
)
def test_check_field_model_constraint(self):
"""Test that it's not possible to create inconsistent mass edit actions"""
with self.assertRaises(ValidationError):
self.mass_editing_user.write(
{"model_id": self.env.ref("base.model_res_country").id}
)
def test_onchanges(self):
"""Test that form onchanges do what they're supposed to"""
# Test change on server_action.model_id : clear mass_edit_line_ids
server_action_form = Form(self.mass_editing_user)
self.assertGreater(
len(server_action_form.mass_edit_line_ids),
0,
"Mass Editing User demo data should have lines",
)
server_action_form.model_id = self.env.ref("base.model_res_country")
self.assertEqual(
len(server_action_form.mass_edit_line_ids),
0,
"Mass edit lines should be removed when changing model",
)
# Test change on mass_edit_line field_id : set widget_option
mass_edit_line_form = Form(
self.env.ref("mass_editing.mass_editing_user_line_1")
)
mass_edit_line_form.field_id = self.env.ref(
"base.field_res_partner__category_id"
)
self.assertEqual(mass_edit_line_form.widget_option, "many2many_tags")
mass_edit_line_form.field_id = self.env.ref(
"base.field_res_partner__image_1920"
)
self.assertEqual(mass_edit_line_form.widget_option, "image")
mass_edit_line_form.field_id = self.env.ref("base.field_res_company__logo")
self.assertEqual(mass_edit_line_form.widget_option, "image")
# binary
mass_edit_line_form.field_id = self.env.ref("base.field_res_company__favicon")
self.assertEqual(mass_edit_line_form.widget_option, False)
mass_edit_line_form.field_id = self.env.ref("base.field_res_users__country_id")
self.assertFalse(mass_edit_line_form.widget_option)
def test_onchange_model_id(self):
"""Test super call of `_onchange_model_id`"""
IrActionsServer._onchange_model_id = fake_onchange_model_id
result = self.env["ir.actions.server"]._onchange_model_id()
self.assertEqual(
result,
fake_onchange_model_id(self),
)
del IrActionsServer._onchange_model_id
result = self.env["ir.actions.server"]._onchange_model_id()
self.assertEqual(
result,
None,
)
| 36.917808 | 13,475 |
9,821 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2016 Serpent Consulting Services Pvt. Ltd. ([email protected])
# Copyright (C) 2020 Iván Todorovich (https://twitter.com/ivantodorovich)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from lxml import etree
from odoo import _, api, fields, models
class MassEditingWizard(models.TransientModel):
_name = "mass.editing.wizard"
_description = "Wizard for mass edition"
selected_item_qty = fields.Integer(readonly=True)
remaining_item_qty = fields.Integer(readonly=True)
operation_description_info = fields.Text(readonly=True)
operation_description_warning = fields.Text(readonly=True)
operation_description_danger = fields.Text(readonly=True)
message = fields.Text(readonly=True)
@api.model
def default_get(self, fields, active_ids=None):
res = super().default_get(fields)
server_action_id = self.env.context.get("server_action_id")
server_action = self.env["ir.actions.server"].sudo().browse(server_action_id)
# Compute items quantity
# Compatibility with server_actions_domain
active_ids = self.env.context.get("active_ids")
original_active_ids = self.env.context.get("original_active_ids", active_ids)
# Compute operation messages
operation_description_info = False
operation_description_warning = False
operation_description_danger = False
if len(active_ids) == len(original_active_ids):
operation_description_info = _(
"The treatment will be processed on the %(amount)d selected record(s)."
) % {
"amount": len(active_ids),
}
elif len(original_active_ids):
operation_description_warning = _(
"You have selected %(origin_amount)d record(s) that can not be processed.\n"
"Only %(amount)d record(s) will be processed."
) % {
"origin_amount": len(original_active_ids) - len(active_ids),
"amount": len(active_ids),
}
else:
operation_description_danger = _(
"None of the %(amount)d record(s) you have selected can be processed."
) % {
"amount": len(active_ids),
}
# Set values
res.update(
{
"selected_item_qty": len(active_ids),
"remaining_item_qty": len(original_active_ids),
"operation_description_info": operation_description_info,
"operation_description_warning": operation_description_warning,
"operation_description_danger": operation_description_danger,
"message": server_action.mass_edit_message,
}
)
return res
@api.model
def _prepare_fields(self, line, field, field_info):
result = {}
# Add "selection field (set / add / remove / remove_m2m)
if field.ttype == "many2many":
selection = [
("set", _("Set")),
("remove_m2m", _("Remove")),
("add", _("Add")),
]
else:
selection = [("set", _("Set")), ("remove", _("Remove"))]
result["selection__" + field.name] = {
"type": "selection",
"string": field_info["string"],
"selection": selection,
}
# Add field info
result[field.name] = field_info
# Patch fields with required extra data
for item in result.values():
item.setdefault("views", {})
return result
@api.model
def _insert_field_in_arch(self, line, field, main_xml_group):
etree.SubElement(
main_xml_group,
"field",
{"name": "selection__" + field.name, "colspan": "2"},
)
field_vals = self._get_field_options(field)
if line.widget_option:
field_vals["widget"] = line.widget_option
etree.SubElement(main_xml_group, "field", field_vals)
def _get_field_options(self, field):
return {"name": field.name, "nolabel": "1", "colspan": "4"}
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
result = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
server_action_id = self.env.context.get("server_action_id")
server_action = self.env["ir.actions.server"].sudo().browse(server_action_id)
if not server_action:
return result
all_fields = {}
TargetModel = self.env[server_action.model_id.model]
fields_info = TargetModel.fields_get()
arch = etree.fromstring(result["arch"])
main_xml_group = arch.find('.//group[@name="group_field_list"]')
for line in server_action.mapped("mass_edit_line_ids"):
# Field part
field = line.field_id
field_info = self._clean_check_company_field_domain(
TargetModel, field, fields_info[field.name]
)
if not line.apply_domain and "domain" in field_info:
field_info["domain"] = "[]"
all_fields.update(self._prepare_fields(line, field, field_info))
# XML Part
self._insert_field_in_arch(line, field, main_xml_group)
result["arch"] = etree.tostring(arch, encoding="unicode")
result["fields"] = all_fields
return result
@api.model
def _clean_check_company_field_domain(self, TargetModel, field, field_info):
"""
This method remove the field view domain added by Odoo for relational
fields with check_company attribute to avoid error for non exists
company_id or company_ids fields in wizard view.
See _description_domain method in _Relational Class
"""
field_class = TargetModel._fields[field.name]
if not field_class.relational or not field_class.check_company or field.domain:
return field_info
field_info["domain"] = "[]"
return field_info
@api.model
def create(self, vals):
server_action_id = self.env.context.get("server_action_id")
server_action = self.env["ir.actions.server"].sudo().browse(server_action_id)
active_ids = self.env.context.get("active_ids", [])
if server_action and active_ids:
TargetModel = self.env[server_action.model_id.model]
IrModelFields = self.env["ir.model.fields"].sudo()
IrTranslation = self.env["ir.translation"]
values = {}
for key, val in vals.items():
if key.startswith("selection_"):
split_key = key.split("__", 1)[1]
if val == "set":
values.update({split_key: vals.get(split_key, False)})
elif val == "remove":
values.update({split_key: False})
# If field to remove is translatable,
# its translations have to be removed
model_field = IrModelFields.search(
[
("model", "=", server_action.model_id.model),
("name", "=", split_key),
]
)
if model_field and model_field.translate:
translations = IrTranslation.search(
[
("res_id", "in", active_ids),
("type", "=", "model"),
(
"name",
"=",
"{},{}".format(
server_action.model_id.model, split_key
),
),
]
)
translations.unlink()
elif val == "remove_m2m":
m2m_list = []
if vals.get(split_key):
for m2m_id in vals.get(split_key)[0][2]:
m2m_list.append((3, m2m_id))
if m2m_list:
values.update({split_key: m2m_list})
else:
values.update({split_key: [(5, 0, [])]})
elif val == "add":
m2m_list = []
for m2m_id in vals.get(split_key, False)[0][2]:
m2m_list.append((4, m2m_id))
values.update({split_key: m2m_list})
if values:
TargetModel.browse(active_ids).write(values)
return super().create({})
def read(self, fields, load="_classic_read"):
"""Without this call, dynamic fields build by fields_view_get()
generate a log warning, i.e.:
odoo.models:mass.editing.wizard.read() with unknown field 'myfield'
odoo.models:mass.editing.wizard.read()
with unknown field 'selection__myfield'
"""
real_fields = fields
if fields:
# We remove fields which are not in _fields
real_fields = [x for x in fields if x in self._fields]
result = super().read(real_fields, load=load)
# adding fields to result
[result[0].update({x: False}) for x in fields if x not in real_fields]
return result
def button_apply(self):
self.ensure_one()
| 41.610169 | 9,820 |
2,357 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2019 - Today: GRAP (http://www.grap.coop)
# Copyright (C) 2020 Iván Todorovich (https://twitter.com/ivantodorovich)
# @author: Sylvain LE GAL (https://twitter.com/legalsylvain)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
MAGIC_FIELDS = models.MAGIC_COLUMNS + [models.BaseModel.CONCURRENCY_CHECK_FIELD]
class MassEditingLine(models.Model):
_name = "mass.editing.line"
_description = "Mass Editing Line"
_order = "sequence, field_id"
sequence = fields.Integer()
server_action_id = fields.Many2one(
"ir.actions.server",
string="Server Action",
ondelete="cascade",
required=True,
)
model_id = fields.Many2one(
"ir.model",
related="server_action_id.model_id",
)
field_id = fields.Many2one(
"ir.model.fields",
string="Field",
domain="""
[
("name", "not in", %s),
("ttype", "not in", ["reference", "function"]),
("model_id", "=", model_id),
]
"""
% str(MAGIC_FIELDS),
ondelete="cascade",
required=True,
)
widget_option = fields.Char(
help="Add widget text that will be used to display the field in the wizard.\n"
"Example: 'many2many_tags', 'selection', 'image'",
)
apply_domain = fields.Boolean(
default=False,
help="Apply default domain related to field",
)
@api.constrains("server_action_id", "field_id")
def _check_field_model(self):
"""Check that all fields belong to the action model"""
if any(rec.field_id.model_id != rec.server_action_id.model_id for rec in self):
raise ValidationError(
_("Mass edit fields should belong to the server action model.")
)
@api.onchange("field_id")
def _onchange_field_id(self):
for rec in self:
widget_option = False
if rec.field_id.ttype == "many2many":
widget_option = "many2many_tags"
elif rec.field_id.ttype == "binary":
if "image" in rec.field_id.name or "logo" in rec.field_id.name:
widget_option = "image"
rec.widget_option = widget_option
| 34.647059 | 2,356 |
2,021 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 Iván Todorovich (https://twitter.com/ivantodorovich)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class IrActionsServer(models.Model):
_inherit = "ir.actions.server"
state = fields.Selection(
selection_add=[("mass_edit", "Mass Edit Records")],
ondelete={"mass_edit": "cascade"},
)
mass_edit_line_ids = fields.One2many(
"mass.editing.line",
"server_action_id",
)
mass_edit_apply_domain_in_lines = fields.Boolean(
string="Apply domain in lines",
compute="_compute_mass_edit_apply_domain_in_lines",
)
mass_edit_message = fields.Text(
string="Message",
help="If set, this message will be displayed in the wizard.",
)
@api.onchange("model_id")
def _onchange_model_id(self):
# Play nice with other modules
res = None
if hasattr(super(), "_onchange_model_id"):
res = super()._onchange_model_id()
# Clear mass_edit_line_ids
self.update({"mass_edit_line_ids": [(5, 0, 0)]})
return res
@api.constrains("model_id")
def _check_field_model(self):
"""Check that all fields belong to the model"""
self.mapped("mass_edit_line_ids")._check_field_model()
@api.depends("mass_edit_line_ids")
def _compute_mass_edit_apply_domain_in_lines(self):
for record in self:
record.mass_edit_apply_domain_in_lines = any(
record.mass_edit_line_ids.mapped("apply_domain")
)
def _run_action_mass_edit_multi(self, eval_context=None):
"""Show report label wizard"""
context = dict(self.env.context)
context.update({"server_action_id": self.id})
return {
"name": self.name,
"type": "ir.actions.act_window",
"res_model": "mass.editing.wizard",
"context": str(context),
"view_mode": "form",
"target": "new",
}
| 33.666667 | 2,020 |
377 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Multi-Steps Wizards",
"version": "15.0.1.0.1",
"author": "Camptocamp,Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["base"],
"website": "https://github.com/OCA/server-ux",
"data": ["views/multi_step_wizard_views.xml"],
"installable": True,
}
| 31.416667 | 377 |
405 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import models
class MultiStepWizardTest(models.TransientModel):
_name = "multi.step.wizard.test"
_description = "Multi Step Wizard Test"
_inherit = "multi.step.wizard.mixin"
def state_previous_final(self):
self.write({"state": "start"})
| 31.153846 | 405 |
781 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import tagged
from .common import CommonTestMultiStepWizard
@tagged("post_install", "-at_install")
class TestMultiStepWizard(CommonTestMultiStepWizard):
def setUp(self):
super().setUp()
self.MultiStepWizard = self.env["multi.step.wizard.test"]
def test_behavior(self):
wizard = self.MultiStepWizard.create({})
wizard.open_next()
self.assertEqual(wizard.state, "final")
with self.assertRaises(NotImplementedError):
wizard.open_next()
self.assertTrue(wizard.allow_back)
wizard.open_previous()
self.assertEqual(wizard.state, "start")
| 33.956522 | 781 |
683 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo_test_helper import FakeModelLoader
from odoo.tests import common
class CommonTestMultiStepWizard(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .multi_step_wizard_test import MultiStepWizardTest
cls.loader.update_registry((MultiStepWizardTest,))
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super().tearDownClass()
| 31.045455 | 683 |
2,504 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import logging
from odoo import api, fields, models
_logger = logging.getLogger(__name__)
class MultiStepWizard(models.AbstractModel):
"""Mixin to ease the creation of multisteps wizards
_selection_state must return all possible step of
the wizard.
For each state but final, there must be a method named
"state_exit_X" where X is the name of the state. Each
of these method must set the next state in self.state.
For each state but start, there may be a method named
"state_previous_X" where X is the name of the state. Each
of these method must set the next state in self.state.
The final state has no related method because the view
should only display a button to close the wizard.
open_next, open_previous and _reopen_self should not need to be
overidden, but _selection_state and state_exit_start
likely will need to.
"""
_name = "multi.step.wizard.mixin"
_description = "Multi Steps Wizard Mixin"
state = fields.Selection(
selection="_selection_state", default="start", required=True
)
allow_back = fields.Boolean(compute="_compute_allow_back")
@api.depends("state")
def _compute_allow_back(self):
for record in self:
record.allow_back = getattr(
record, "state_previous_%s" % record.state, False
)
@api.model
def _selection_state(self):
return [("start", "Start"), ("final", "Final")]
def open_next(self):
state_method = getattr(self, "state_exit_{}".format(self.state), None)
if state_method is None:
raise NotImplementedError(
"No method defined for state {}".format(self.state)
)
state_method()
return self._reopen_self()
def open_previous(self):
state_method = getattr(self, "state_previous_{}".format(self.state), None)
if state_method is None:
raise NotImplementedError(
"No method defined for state {}".format(self.state)
)
state_method()
return self._reopen_self()
def _reopen_self(self):
return {
"type": "ir.actions.act_window",
"res_model": self._name,
"res_id": self.id,
"view_mode": "form",
"target": "new",
}
def state_exit_start(self):
self.state = "final"
| 30.536585 | 2,504 |
762 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2018 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "MIS Builder Demo",
"summary": """
Demo addon for MIS Builder""",
"version": "15.0.3.1.1",
"license": "AGPL-3",
"author": "ACSONE SA/NV, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/mis-builder",
"depends": ["mis_builder_budget", "purchase"],
"data": [
"security/mis_committed_purchase.xml",
"views/mis_committed_purchase.xml",
"data/mis_report_style.xml",
"data/mis_report.xml",
"data/mis_budget.xml",
"data/mis_report_instance.xml",
],
"installable": True,
"maintainers": ["sbidoul"],
"development_status": "Alpha",
}
| 31.75 | 762 |
2,585 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from os.path import dirname, join as opj
from odoo import fields, models, tools
class MisCommittedPurchase(models.Model):
_name = "mis.committed.purchase"
_description = "MIS Commitment"
_auto = False
line_type = fields.Char()
name = fields.Char()
analytic_account_id = fields.Many2one(
comodel_name="account.analytic.account", string="Analytic Account"
)
account_id = fields.Many2one(comodel_name="account.account", string="Account")
company_id = fields.Many2one(comodel_name="res.company", string="Company")
credit = fields.Float()
debit = fields.Float()
date = fields.Date()
# resource can be purchase.order.line or account.move.line
res_id = fields.Integer(string="Resource ID")
res_model = fields.Char(string="Resource Model Name")
analytic_tag_ids = fields.Many2many(
comodel_name="account.analytic.tag",
relation="mis_committed_purchase_tag_rel",
column1="mis_committed_purchase_id",
column2="account_analytic_tag_id",
string="Analytic Tags",
)
def init(self):
script = opj(
dirname(dirname(__file__)), "examples", "mis_committed_purchase.sql"
)
with open(script) as f:
tools.drop_view_if_exists(self.env.cr, "mis_committed_purchase")
self.env.cr.execute(f.read())
# Create many2many relation for account.analytic.tag
tools.drop_view_if_exists(self.env.cr, "mis_committed_purchase_tag_rel")
self.env.cr.execute(
"""
CREATE OR REPLACE VIEW mis_committed_purchase_tag_rel AS
(SELECT
po_mcp.id AS mis_committed_purchase_id,
po_rel.account_analytic_tag_id AS account_analytic_tag_id
FROM account_analytic_tag_purchase_order_line_rel AS po_rel
INNER JOIN mis_committed_purchase AS po_mcp ON
po_mcp.res_id = po_rel.purchase_order_line_id
WHERE po_mcp.res_model = 'purchase.order.line'
UNION ALL
SELECT
inv_mcp.id AS mis_committed_purchase_id,
inv_rel.account_analytic_tag_id AS account_analytic_tag_id
FROM account_analytic_tag_account_move_line_rel AS inv_rel
INNER JOIN mis_committed_purchase AS inv_mcp ON
inv_mcp.res_id = inv_rel.account_move_line_id
WHERE inv_mcp.res_model = 'account.move.line')
"""
)
| 38.58209 | 2,585 |
562 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-mis-builder",
description="Meta package for oca-mis-builder Odoo addons",
version=version,
install_requires=[
'odoo-addon-mis_builder>=15.0dev,<15.1dev',
'odoo-addon-mis_builder_budget>=15.0dev,<15.1dev',
'odoo-addon-mis_builder_demo>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 28.1 | 562 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
5,481 |
py
|
PYTHON
|
15.0
|
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
from datetime import datetime
# -- Project information -----------------------------------------------------
project = "MIS Builder"
year = datetime.now().year
copyright = "%s, Odoo Community Association (OCA)" % year
author = "Odoo Community Association (OCA)"
# The short X.Y version
version = "3.2"
# The full version, including alpha/beta/rc tags
release = version
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ["sphinx.ext.githubpages", "sphinx.ext.todo"]
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = ".rst"
# The master toctree document.
master_doc = "index"
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path .
exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = "sphinx"
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = "alabaster"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
"description": "Management Information System reports for Odoo",
"logo": "logo.png",
"logo_name": True,
"github_user": "OCA",
"github_repo": "mis-builder",
"github_button": True,
"github_banner": True,
"show_related": True,
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ["_static"]
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
html_sidebars = {
"**": [
"about.html",
"navigation.html",
"relations.html",
"searchbox.html",
"donate.html",
]
}
# -- Options for HTMLHelp output ---------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = "MISBuilderDoc"
# -- Options for LaTeX output ------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(
master_doc,
"MISBuilder.tex",
"MIS Builder Documentation",
"Odoo Community Association (OCA)",
"manual",
)
]
# -- Options for manual page output ------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [(master_doc, "misbuilder", "MIS Builder Documentation", [author], 1)]
# -- Options for Texinfo output ----------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
master_doc,
"MISBuilder",
"MIS Builder Documentation",
author,
"MISBuilder",
"One line description of project.",
"Miscellaneous",
)
]
# -- Extension configuration -------------------------------------------------
todo_include_todos = True
| 30.281768 | 5,481 |
954 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2018 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "MIS Builder Budget",
"summary": """
Create budgets for MIS reports""",
"version": "15.0.4.0.2",
"license": "AGPL-3",
"author": "ACSONE SA/NV, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/mis-builder",
"depends": ["mis_builder", "account"],
"data": [
"views/mis_report_instance_period.xml",
"views/mis_report.xml",
"security/mis_budget_item.xml",
"views/mis_budget_item.xml",
"security/mis_budget.xml",
"views/mis_budget.xml",
"security/mis_budget_by_account_item.xml",
"views/mis_budget_by_account_item.xml",
"security/mis_budget_by_account.xml",
"views/mis_budget_by_account.xml",
],
"installable": True,
"development_status": "Production/Stable",
"maintainers": ["sbidoul"],
}
| 34.071429 | 954 |
4,767 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
from odoo.addons.mis_builder.models.expression_evaluator import ExpressionEvaluator
from odoo.addons.mis_builder.tests.common import assert_matrix
from ..models.mis_report_instance_period import SRC_MIS_BUDGET_BY_ACCOUNT
class TestMisBudgetByAccount(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# create account
account = cls.env["account.account"].create(
dict(
name="test account",
code="1",
user_type_id=cls.env.ref("account.data_account_type_revenue").id,
)
)
# create report
cls.report = cls.env["mis.report"].create(dict(name="test report"))
cls.kpi1 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.report.id,
name="k1",
description="kpi 1",
expression="balp[('id', '=', {})]".format(account.id),
)
)
# budget
cls.budget = cls.env["mis.budget.by.account"].create(
dict(
name="the budget",
date_from="2017-01-01",
date_to="2017-12-31",
company_id=cls.env.ref("base.main_company").id,
item_ids=[
(
0,
0,
dict(
account_id=account.id,
date_from="2017-01-01",
date_to="2017-01-08",
debit=11,
),
),
(
0,
0,
dict(
account_id=account.id,
date_from="2017-01-09",
date_to="2017-01-16",
debit=13,
),
),
],
)
)
def test_basic(self):
"""Sum all budget items in period"""
aep = self.report._prepare_aep(self.env.ref("base.main_company"))
ee = ExpressionEvaluator(
aep=aep,
date_from="2017-01-01",
date_to="2017-01-16",
aml_model="mis.budget.by.account.item",
)
d = self.report._evaluate(ee)
assert d["k1"] == 24.0
def test_one_item(self):
aep = self.report._prepare_aep(self.env.ref("base.main_company"))
ee = ExpressionEvaluator(
aep=aep,
date_from="2017-01-01",
date_to="2017-01-08",
aml_model="mis.budget.by.account.item",
)
d = self.report._evaluate(ee)
assert d["k1"] == 11.0
def test_one_item_and_prorata_second(self):
aep = self.report._prepare_aep(self.env.ref("base.main_company"))
ee = ExpressionEvaluator(
aep=aep,
date_from="2017-01-01",
date_to="2017-01-12",
aml_model="mis.budget.by.account.item",
)
d = self.report._evaluate(ee)
assert d["k1"] == 11.0 + 13.0 / 2
def test_with_report_instance(self):
instance = self.env["mis.report.instance"].create(
dict(name="test instance", report_id=self.report.id, comparison_mode=True)
)
self.pbud1 = self.env["mis.report.instance.period"].create(
dict(
name="pbud1",
report_instance_id=instance.id,
source=SRC_MIS_BUDGET_BY_ACCOUNT,
source_mis_budget_by_account_id=self.budget.id,
manual_date_from="2017-01-01",
manual_date_to="2017-01-31",
)
)
matrix = instance._compute_matrix()
assert_matrix(matrix, [[24]])
def test_copy(self):
budget2 = self.budget.copy()
self.assertEqual(len(budget2.item_ids), len(self.budget.item_ids))
def test_workflow(self):
self.assertEqual(self.budget.state, "draft")
self.budget.action_confirm()
self.assertEqual(self.budget.state, "confirmed")
self.budget.action_cancel()
self.assertEqual(self.budget.state, "cancelled")
self.budget.action_draft()
self.assertEqual(self.budget.state, "draft")
def test_budget_item_balance(self):
item = self.budget.item_ids[0]
item.balance = 100
self.assertEqual(item.debit, 100)
item.balance = -100
self.assertEqual(item.debit, 0)
self.assertEqual(item.credit, 100)
| 35.051471 | 4,767 |
5,931 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import datetime
from odoo.tests.common import TransactionCase
from odoo.addons.mis_builder.tests.common import assert_matrix
from ..models.mis_report_instance_period import SRC_MIS_BUDGET
class TestMisBudget(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# create report
cls.report = cls.env["mis.report"].create(dict(name="test report"))
cls.kpi1 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.report.id,
name="k1",
description="kpi 1",
expression="10",
budgetable=True,
)
)
cls.expr1 = cls.kpi1.expression_ids[0]
cls.kpi2 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.report.id,
name="k2",
description="kpi 2",
expression="k1 + 1",
sequence=0, # kpi2 before kpi1 to test out of order evaluation
)
)
# budget
cls.budget = cls.env["mis.budget"].create(
dict(
name="the budget",
report_id=cls.report.id,
date_from="2017-01-01",
date_to="2017-12-31",
item_ids=[
(
0,
0,
dict(
kpi_expression_id=cls.expr1.id,
date_from="2017-01-01",
date_to="2017-01-31",
amount=10,
),
),
(
0,
0,
dict(
kpi_expression_id=cls.expr1.id,
date_from="2017-02-01",
date_to="2017-02-28",
amount=20,
),
),
],
)
)
# instance
cls.instance = cls.env["mis.report.instance"].create(
dict(name="test instance", report_id=cls.report.id, comparison_mode=True)
)
cls.pact1 = cls.env["mis.report.instance.period"].create(
dict(
name="pact1",
report_instance_id=cls.instance.id,
manual_date_from="2017-01-01",
manual_date_to="2017-01-31",
)
)
cls.pbud1 = cls.env["mis.report.instance.period"].create(
dict(
name="pbud1",
report_instance_id=cls.instance.id,
source=SRC_MIS_BUDGET,
source_mis_budget_id=cls.budget.id,
manual_date_from="2017-01-01",
manual_date_to="2017-01-31",
)
)
cls.pact2 = cls.env["mis.report.instance.period"].create(
dict(
name="pact2",
report_instance_id=cls.instance.id,
manual_date_from="2017-02-01",
manual_date_to="2017-02-28",
)
)
cls.pbud2 = cls.env["mis.report.instance.period"].create(
dict(
name="pbud2",
report_instance_id=cls.instance.id,
source=SRC_MIS_BUDGET,
source_mis_budget_id=cls.budget.id,
manual_date_from="2017-02-01",
manual_date_to="2017-02-21",
)
)
# clear cache to force re-read of kpis ordered by sequence
cls.env.clear()
def test1(self):
matrix = self.instance._compute_matrix()
assert_matrix(
matrix,
[
# jan, bud jan, feb (3w), bud feb (3w),
[11, 11, 11, 16], # k2 = k1 + 1
[10, 10, 10, 15], # k1
],
)
def test_drilldown(self):
act = self.instance.drilldown(
dict(period_id=self.pbud1.id, expr_id=self.expr1.id)
)
self.assertEqual(act["res_model"], "mis.budget.item")
self.assertEqual(
act["domain"],
[
("date_from", "<=", datetime.date(2017, 1, 31)),
("date_to", ">=", datetime.date(2017, 1, 1)),
("kpi_expression_id", "=", self.expr1.id),
("budget_id", "=", self.budget.id),
],
)
def test_copy(self):
budget2 = self.budget.copy()
self.assertEqual(len(budget2.item_ids), len(self.budget.item_ids))
def test_workflow(self):
self.assertEqual(self.budget.state, "draft")
self.budget.action_confirm()
self.assertEqual(self.budget.state, "confirmed")
self.budget.action_cancel()
self.assertEqual(self.budget.state, "cancelled")
self.budget.action_draft()
self.assertEqual(self.budget.state, "draft")
def test_name_search(self):
report2 = self.report.copy()
report2.kpi_ids.filtered(lambda k: k.name == "k1").name = "k1_1"
budget2 = self.budget.copy()
budget2.report_id = report2.id
# search restricted to the context of budget2
# hence we find only k1_1 in report2 and not k1
expr = (
self.env["mis.report.kpi.expression"]
.with_context(default_budget_id=budget2.id)
.name_search("k1")
)
self.assertEqual(len(expr), 1)
self.assertEqual(expr[0][1], "kpi 1 (k1_1)")
expr = (
self.env["mis.report.kpi.expression"]
.with_context(default_budget_id=budget2.id)
.name_search("kpi 1")
)
self.assertEqual(len(expr), 1)
self.assertEqual(expr[0][1], "kpi 1 (k1_1)")
| 34.684211 | 5,931 |
2,523 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
from odoo.addons.mis_builder_budget.models.mis_report_instance import (
MisBudgetAwareExpressionEvaluator,
)
class TestBudgetAwareExpressionEvaluator(TransactionCase):
def _make_evaluator(self, kpi_data=None):
return MisBudgetAwareExpressionEvaluator(
date_from="2017-01-01",
date_to="2017-01-16",
kpi_data=kpi_data or {},
additional_move_line_filter=[],
)
def test_no_expression(self):
evaluator = self._make_evaluator()
evaluator.eval_expressions([None], locals_dict={})
def test_one_expression(self):
evaluator = self._make_evaluator()
kpi = self.env["mis.report.kpi"].new({"name": "thekpi"})
expr = self.env["mis.report.kpi.expression"].new(
{"kpi_id": kpi.id, "name": "a"}
)
vals, drilldown_args, name_error = evaluator.eval_expressions(
[expr], locals_dict={"a": 1}
)
self.assertEqual(vals, [1])
self.assertEqual(drilldown_args, [None])
self.assertFalse(name_error)
def test_two_expressions(self):
evaluator = self._make_evaluator()
kpi = self.env["mis.report.kpi"].new({"name": "thekpi"})
expr1 = self.env["mis.report.kpi.expression"].new(
{"kpi_id": kpi.id, "name": "a"}
)
expr2 = self.env["mis.report.kpi.expression"].new(
{"kpi_id": kpi.id, "name": "b"}
)
vals, drilldown_args, _ = evaluator.eval_expressions(
[expr1, expr2], locals_dict={"a": 1, "b": 2}
)
self.assertEqual(vals, [1, 2])
self.assertEqual(drilldown_args, [None, None])
def test_two_expressions_with_budget(self):
kpi = self.env["mis.report.kpi"].new({"name": "thekpi", "budgetable": True})
expr1 = self.env["mis.report.kpi.expression"].new(
{"kpi_id": kpi.id, "name": "a"}
)
expr2 = self.env["mis.report.kpi.expression"].new(
{"kpi_id": kpi.id, "name": "b"}
)
kpi_data = {
expr1: 10,
expr2: 20,
}
evaluator = self._make_evaluator(kpi_data)
vals, _, _ = evaluator.eval_expressions(
[expr1, expr2], locals_dict={"a": 1, "b": 2}
)
self.assertEqual(vals, [10, 20]) # budget values instead of locals_dict values
| 37.102941 | 2,523 |
512 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class MisBudget(models.Model):
_name = "mis.budget"
_description = "MIS Budget by KPI"
_inherit = ["mis.budget.abstract", "mail.thread"]
report_id = fields.Many2one(
comodel_name="mis.report", string="MIS Report Template", required=True
)
item_ids = fields.One2many(
comodel_name="mis.budget.item", inverse_name="budget_id", copy=True
)
| 28.444444 | 512 |
2,314 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
SRC_MIS_BUDGET = "mis_budget"
SRC_MIS_BUDGET_BY_ACCOUNT = "mis_budget_by_account"
class MisReportInstancePeriod(models.Model):
_inherit = "mis.report.instance.period"
source = fields.Selection(
selection_add=[
(SRC_MIS_BUDGET, "MIS Budget by KPI"),
(SRC_MIS_BUDGET_BY_ACCOUNT, "MIS Budget by Account"),
],
ondelete={
SRC_MIS_BUDGET: "cascade",
SRC_MIS_BUDGET_BY_ACCOUNT: "cascade",
},
)
source_mis_budget_id = fields.Many2one(
comodel_name="mis.budget", string="Budget by KPI"
)
source_mis_budget_by_account_id = fields.Many2one(
comodel_name="mis.budget.by.account", string="Budget by Account"
)
def _get_aml_model_name(self):
if self.source == SRC_MIS_BUDGET_BY_ACCOUNT:
return "mis.budget.by.account.item"
return super()._get_aml_model_name()
def _get_additional_move_line_filter(self):
domain = super()._get_additional_move_line_filter()
if self.source == SRC_MIS_BUDGET_BY_ACCOUNT:
domain.extend([("budget_id", "=", self.source_mis_budget_by_account_id.id)])
return domain
def _get_additional_budget_item_filter(self):
"""Prepare a filter to apply on all budget items
This filter is applied with a AND operator on all
budget items. This hook is intended
to be inherited, and is useful to implement filtering
on analytic dimensions or operational units.
The default filter is built from a ``mis_report_filters context``
key, which is a list set by the analytic filtering mechanism
of the mis report widget::
[(field_name, {'value': value, 'operator': operator})]
This default filter is the same as the one set by
_get_additional_move_line_filter on mis.report.instance.period, so
a budget.item is expected to have the same analytic fields as
a move line.
Returns an Odoo domain expression (a python list)
compatible with mis.budget.item."""
self.ensure_one()
filters = self._get_additional_move_line_filter()
return filters
| 35.6 | 2,314 |
3,103 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2020 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class MisBudgetByAccountItem(models.Model):
_inherit = ["mis.budget.item.abstract", "prorata.read_group.mixin"]
_name = "mis.budget.by.account.item"
_description = "MIS Budget Item (by Account)"
_order = "budget_id, date_from, account_id"
name = fields.Char(string="Label")
budget_id = fields.Many2one(comodel_name="mis.budget.by.account")
debit = fields.Monetary(default=0.0, currency_field="company_currency_id")
credit = fields.Monetary(default=0.0, currency_field="company_currency_id")
balance = fields.Monetary(
compute="_compute_balance",
inverse="_inverse_balance",
store=True,
currency_field="company_currency_id",
)
company_id = fields.Many2one(
"res.company",
related="budget_id.company_id",
readonly=True,
store=True,
)
company_currency_id = fields.Many2one(
"res.currency",
related="budget_id.company_id.currency_id",
string="Company Currency",
readonly=True,
help="Utility field to express amount currency",
store=True,
)
account_id = fields.Many2one(
comodel_name="account.account",
string="Account",
required=True,
# TODO domain (company_id)
)
_sql_constraints = [
(
"credit_debit1",
"CHECK (credit*debit=0)",
"Wrong credit or debit value in budget item! "
"Credit or debit should be zero.",
),
(
"credit_debit2",
"CHECK (credit+debit>=0)",
"Wrong credit or debit value in budget item! "
"Credit and debit should be positive.",
),
]
@api.depends("debit", "credit")
def _compute_balance(self):
for rec in self:
rec.balance = rec.debit - rec.credit
def _prepare_overlap_domain(self):
"""Prepare a domain to check for overlapping budget items."""
if self.budget_id.allow_items_overlap:
# Trick mis.budget.abstract._check_dates into never seeing
# overlapping budget items. This "hack" is necessary because, for now,
# overlapping budget items is only possible for budget by account items
# and kpi budget items.
return [("id", "=", 0)]
domain = super()._prepare_overlap_domain()
domain.extend([("account_id", "=", self.account_id.id)])
return domain
@api.constrains(
"date_range_id",
"date_from",
"date_to",
"budget_id",
"analytic_account_id",
"analytic_tag_ids",
"account_id",
)
def _check_dates(self):
super()._check_dates()
return
def _inverse_balance(self):
for rec in self:
if rec.balance < 0:
rec.credit = -rec.balance
rec.debit = 0
else:
rec.credit = 0
rec.debit = rec.balance
| 31.989691 | 3,103 |
1,206 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class MisBudgetItem(models.Model):
_inherit = ["mis.budget.item.abstract", "mis.kpi.data"]
_name = "mis.budget.item"
_description = "MIS Budget Item (by KPI)"
_order = "budget_id, date_from, seq1, seq2"
budget_id = fields.Many2one(comodel_name="mis.budget")
report_id = fields.Many2one(related="budget_id.report_id", readonly=True)
kpi_expression_id = fields.Many2one(
domain=(
"[('kpi_id.report_id', '=', report_id),"
" ('kpi_id.budgetable', '=', True)]"
)
)
def _prepare_overlap_domain(self):
"""Prepare a domain to check for overlapping budget items."""
domain = super()._prepare_overlap_domain()
domain.extend([("kpi_expression_id", "=", self.kpi_expression_id.id)])
return domain
@api.constrains(
"date_range_id",
"date_from",
"date_to",
"budget_id",
"analytic_account_id",
"analytic_tag_ids",
"kpi_expression_id",
)
def _check_dates(self):
super()._check_dates()
return
| 30.15 | 1,206 |
244 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class MisReportKpi(models.Model):
_inherit = "mis.report.kpi"
budgetable = fields.Boolean(default=False)
| 22.181818 | 244 |
597 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2020 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class MisBudgetByAccount(models.Model):
_name = "mis.budget.by.account"
_description = "MIS Budget by Account"
_inherit = ["mis.budget.abstract", "mail.thread"]
item_ids = fields.One2many(
comodel_name="mis.budget.by.account.item", inverse_name="budget_id", copy=True
)
company_id = fields.Many2one(required=True)
allow_items_overlap = fields.Boolean(
help="If checked, overlap between budget items is allowed"
)
| 31.421053 | 597 |
3,665 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2020 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class MisBudgetItemAbstract(models.AbstractModel):
_name = "mis.budget.item.abstract"
_description = "MIS Budget Item (Abstract Base Class)"
budget_id = fields.Many2one(
comodel_name="mis.budget.abstract",
string="Budget",
required=True,
ondelete="cascade",
index=True,
)
budget_date_from = fields.Date(
related="budget_id.date_from", readonly=True, string="Budget Date From"
)
budget_date_to = fields.Date(
related="budget_id.date_to", readonly=True, string="Budget Date To"
)
date_range_id = fields.Many2one(
comodel_name="date.range",
domain="[('date_start', '>=', budget_date_from),"
" ('date_end', '<=', budget_date_to)]",
string="Date range",
)
date_from = fields.Date(required=True, string="From")
date_to = fields.Date(required=True, string="To")
analytic_account_id = fields.Many2one(
comodel_name="account.analytic.account", string="Analytic account"
)
analytic_tag_ids = fields.Many2many(
comodel_name="account.analytic.tag", string="Analytic Tags"
)
@api.onchange("date_range_id")
def _onchange_date_range(self):
for rec in self:
if rec.date_range_id:
rec.date_from = rec.date_range_id.date_start
rec.date_to = rec.date_range_id.date_end
@api.onchange("date_from", "date_to")
def _onchange_dates(self):
for rec in self:
if rec.date_range_id:
if (
rec.date_from != rec.date_range_id.date_start
or rec.date_to != rec.date_range_id.date_end
):
rec.date_range_id = False
def _prepare_overlap_domain(self):
"""Prepare a domain to check for overlapping budget items."""
self.ensure_one()
domain = [
("id", "!=", self.id),
("budget_id", "=", self.budget_id.id),
("date_from", "<=", self.date_to),
("date_to", ">=", self.date_from),
("analytic_account_id", "=", self.analytic_account_id.id),
]
for tag in self.analytic_tag_ids:
domain.append(("analytic_tag_ids", "in", [tag.id]))
return domain
def _check_dates(self):
for rec in self:
# date_from <= date_to
if rec.date_from > rec.date_to:
raise ValidationError(
_("%s start date must not be after end date") % (rec.display_name,)
)
# within budget dates
if rec.date_from < rec.budget_date_from or rec.date_to > rec.budget_date_to:
raise ValidationError(
_(
"%(rec_name)s is not within budget %(budget_name)s date range.",
rec_name=rec.display_name,
budget_name=rec.budget_id.display_name,
)
)
# overlaps
domain = rec._prepare_overlap_domain()
res = self.search(domain, limit=1)
if res:
raise ValidationError(
_(
"%(rec_name)s overlaps %(res_name)s in budget %(budget_name)s",
rec_name=rec.display_name,
res_name=res.display_name,
budget_name=rec.budget_id.display_name,
)
)
| 37.020202 | 3,665 |
4,454 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, models
from odoo.osv.expression import AND
from odoo.addons.mis_builder.models.accounting_none import AccountingNone
from odoo.addons.mis_builder.models.expression_evaluator import ExpressionEvaluator
from .mis_report_instance_period import SRC_MIS_BUDGET, SRC_MIS_BUDGET_BY_ACCOUNT
class MisBudgetAwareExpressionEvaluator(ExpressionEvaluator):
def __init__(self, date_from, date_to, kpi_data, additional_move_line_filter):
super().__init__(
aep=None,
date_from=date_from,
date_to=date_to,
additional_move_line_filter=additional_move_line_filter,
aml_model=None,
)
self.kpi_data = kpi_data
@api.model
def _get_kpi_for_expressions(self, expressions):
kpi = None
for expression in expressions:
if not expression:
continue
if kpi is None:
kpi = expression.kpi_id
else:
assert (
kpi == expression.kpi_id
), "expressions must belong to the same kpi"
return kpi
def eval_expressions(self, expressions, locals_dict):
kpi = self._get_kpi_for_expressions(expressions)
if kpi and kpi.budgetable:
vals = []
drilldown_args = []
for expression in expressions:
vals.append(self.kpi_data.get(expression, AccountingNone))
drilldown_args.append({"expr_id": expression.id})
return vals, drilldown_args, False
return super().eval_expressions(expressions, locals_dict)
class MisReportInstance(models.Model):
_inherit = "mis.report.instance"
def _add_column_mis_budget(self, aep, kpi_matrix, period, label, description):
# fetch budget data for the period
base_domain = AND(
[
[("budget_id", "=", period.source_mis_budget_id.id)],
period._get_additional_budget_item_filter(),
]
)
kpi_data = self.env["mis.budget.item"]._query_kpi_data(
period.date_from, period.date_to, base_domain
)
expression_evaluator = MisBudgetAwareExpressionEvaluator(
period.date_from,
period.date_to,
kpi_data,
period._get_additional_move_line_filter(),
)
return self.report_id._declare_and_compute_period(
expression_evaluator,
kpi_matrix,
period.id,
label,
description,
period.subkpi_ids,
period._get_additional_query_filter,
no_auto_expand_accounts=self.no_auto_expand_accounts,
)
def _add_column(self, aep, kpi_matrix, period, label, description):
if period.source == SRC_MIS_BUDGET:
return self._add_column_mis_budget(
aep, kpi_matrix, period, label, description
)
elif period.source == SRC_MIS_BUDGET_BY_ACCOUNT:
return self._add_column_move_lines(
aep, kpi_matrix, period, label, description
)
else:
return super()._add_column(aep, kpi_matrix, period, label, description)
def drilldown(self, arg):
self.ensure_one()
period_id = arg.get("period_id")
if period_id:
period = self.env["mis.report.instance.period"].browse(period_id)
if period.source == SRC_MIS_BUDGET:
expr_id = arg.get("expr_id")
if not expr_id:
return False
domain = [
("date_from", "<=", period.date_to),
("date_to", ">=", period.date_from),
("kpi_expression_id", "=", expr_id),
("budget_id", "=", period.source_mis_budget_id.id),
]
domain.extend(period._get_additional_budget_item_filter())
return {
"name": period.name,
"domain": domain,
"type": "ir.actions.act_window",
"res_model": "mis.budget.item",
"views": [[False, "list"], [False, "form"]],
"view_mode": "list",
"target": "current",
}
return super().drilldown(arg)
| 36.809917 | 4,454 |
2,040 |
py
|
PYTHON
|
15.0
|
# Copyright 2017-2020 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
class MisBudgetAbstract(models.AbstractModel):
_name = "mis.budget.abstract"
_description = "MIS Budget (Abstract Base Class)"
_inherit = ["mail.thread"]
name = fields.Char(required=True, tracking=True)
description = fields.Char(tracking=True)
date_range_id = fields.Many2one(comodel_name="date.range", string="Date range")
date_from = fields.Date(required=True, string="From", tracking=True)
date_to = fields.Date(required=True, string="To", tracking=True)
state = fields.Selection(
[("draft", "Draft"), ("confirmed", "Confirmed"), ("cancelled", "Cancelled")],
required=True,
default="draft",
tracking=True,
)
company_id = fields.Many2one(
comodel_name="res.company",
string="Company",
default=lambda self: self.env.company,
)
def copy(self, default=None):
self.ensure_one()
if default is None:
default = {}
if "name" not in default:
default["name"] = _("%s (copy)") % self.name
return super().copy(default=default)
@api.onchange("date_range_id")
def _onchange_date_range(self):
for rec in self:
if rec.date_range_id:
rec.date_from = rec.date_range_id.date_start
rec.date_to = rec.date_range_id.date_end
@api.onchange("date_from", "date_to")
def _onchange_dates(self):
for rec in self:
if rec.date_range_id:
if (
rec.date_from != rec.date_range_id.date_start
or rec.date_to != rec.date_range_id.date_end
):
rec.date_range_id = False
def action_draft(self):
self.write({"state": "draft"})
def action_cancel(self):
self.write({"state": "cancelled"})
def action_confirm(self):
self.write({"state": "confirmed"})
| 32.903226 | 2,040 |
811 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, models
class MisReportKpiExpression(models.Model):
_inherit = "mis.report.kpi.expression"
@api.model
def name_search(self, name="", args=None, operator="ilike", limit=100):
args = args or []
if "default_budget_id" in self.env.context:
report_id = (
self.env["mis.budget"]
.browse(self.env.context["default_budget_id"])
.report_id.id
)
if report_id:
args += [("kpi_id.report_id", "=", report_id)]
if "." in name:
args += [("subkpi_id.report_id", "=", report_id)]
return super().name_search(name, args, operator, limit)
| 33.791667 | 811 |
1,559 |
py
|
PYTHON
|
15.0
|
# Copyright 2014-2018 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "MIS Builder",
"version": "15.0.4.1.3",
"category": "Reporting",
"summary": """
Build 'Management Information System' Reports and Dashboards
""",
"author": "ACSONE SA/NV, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/mis-builder",
"depends": [
"account",
"board",
"report_xlsx", # OCA/reporting-engine
"date_range", # OCA/server-ux
],
"data": [
"wizard/mis_builder_dashboard.xml",
"views/mis_report.xml",
"views/mis_report_instance.xml",
"views/mis_report_style.xml",
"datas/ir_cron.xml",
"security/ir.model.access.csv",
"security/mis_builder_security.xml",
"report/mis_report_instance_qweb.xml",
"report/mis_report_instance_xlsx.xml",
],
"assets": {
"web.assets_backend": [
"mis_builder/static/src/css/custom.css",
"mis_builder/static/src/js/mis_report_widget.js",
],
"web.report_assets_common": [
"/mis_builder/static/src/css/report.css",
],
"web.assets_qweb": [
"mis_builder/static/src/xml/mis_report_widget.xml",
],
},
"qweb": ["static/src/xml/mis_report_widget.xml"],
"installable": True,
"application": True,
"license": "AGPL-3",
"development_status": "Production/Stable",
"maintainers": ["sbidoul"],
}
| 32.479167 | 1,559 |
521 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
def migrate(cr, version):
cr.execute(
"""
ALTER TABLE mis_report_kpi
RENAME COLUMN expression TO old_expression
"""
)
# this migration to date_range type is partial,
# actual date ranges needs to be created manually
cr.execute(
"""
UPDATE mis_report_instance_period
SET type='date_range'
WHERE type='fp'
"""
)
| 26.05 | 521 |
801 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
def migrate(cr, version):
cr.execute(
"""
INSERT INTO mis_report_kpi_expression
(create_uid, create_date, write_uid, write_date,
kpi_id, name, sequence)
SELECT create_uid, create_date, write_uid, write_date,
id, old_expression, sequence
FROM mis_report_kpi
"""
)
cr.execute(
"""
ALTER TABLE mis_report_kpi
DROP COLUMN old_expression
"""
)
# set default mode to relative for existing periods
# as it was the only mode in previous versions
cr.execute(
"""
UPDATE mis_report_instance_period
SET mode='relative'
"""
)
| 27.62069 | 801 |
3,198 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import SavepointCase
from odoo.addons.mis_builder.models.expression_evaluator import ExpressionEvaluator
from odoo.addons.mis_builder.models.mis_report_subreport import (
InvalidNameError,
ParentLoopError,
)
class TestMisSubreport(SavepointCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# create report
cls.subreport = cls.env["mis.report"].create(dict(name="test subreport"))
cls.subreport_kpi1 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.subreport.id,
name="sk1",
description="subreport kpi 1",
expression="11",
)
)
cls.report = cls.env["mis.report"].create(
dict(
name="test report",
subreport_ids=[
(0, 0, dict(name="subreport", subreport_id=cls.subreport.id))
],
)
)
cls.report_kpi1 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.report.id,
name="k1",
description="report kpi 1",
expression="subreport.sk1 + 1",
)
)
cls.parent_report = cls.env["mis.report"].create(
dict(
name="parent report",
subreport_ids=[(0, 0, dict(name="report", subreport_id=cls.report.id))],
)
)
cls.parent_report_kpi1 = cls.env["mis.report.kpi"].create(
dict(
report_id=cls.parent_report.id,
name="pk1",
description="parent report kpi 1",
expression="report.k1 + 1",
)
)
def test_basic(self):
ee = ExpressionEvaluator(aep=None, date_from="2017-01-01", date_to="2017-01-16")
d = self.report._evaluate(ee)
assert d["k1"] == 12
def test_two_levels(self):
ee = ExpressionEvaluator(aep=None, date_from="2017-01-01", date_to="2017-01-16")
d = self.parent_report._evaluate(ee)
assert d["pk1"] == 13
def test_detect_loop(self):
with self.assertRaises(ParentLoopError):
self.report.write(
dict(
subreport_ids=[
(
0,
0,
dict(name="preport1", subreport_id=self.parent_report.id),
)
]
)
)
with self.assertRaises(ParentLoopError):
self.report.write(
dict(
subreport_ids=[
(
0,
0,
dict(name="preport2", subreport_id=self.report.id),
)
]
)
)
def test_invalid_name(self):
with self.assertRaises(InvalidNameError):
self.report.subreport_ids[0].name = "ab c"
| 33.3125 | 3,198 |
5,611 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
class TestAnalyticFilters(TransactionCase):
def setUp(self):
super().setUp()
self.aag = self.env["account.analytic.group"].search([], limit=1)
self.aat = self.env["account.analytic.tag"].search([], limit=1)
def test_context_with_filters(self):
aaa = self.env["account.analytic.account"].search([], limit=1)
mri = self.env["mis.report.instance"].new()
mri.analytic_account_id = False
mri.analytic_group_id = False
assert mri._context_with_filters().get("mis_report_filters") == {}
mri.analytic_account_id = aaa
mri.analytic_group_id = self.aag
assert mri._context_with_filters().get("mis_report_filters") == {
"analytic_account_id": {"value": aaa.id, "operator": "="},
"analytic_account_id.group_id": {"value": self.aag.id, "operator": "="},
}
# test _context_with_filters does nothing is a filter is already
# in the context
assert mri.with_context(
mis_report_filters={"f": 1}
)._context_with_filters().get("mis_report_filters") == {"f": 1}
def _check_get_filter_domain_from_context(
self, mis_report_filters, expected_domain
):
domain = (
self.env["mis.report.instance.period"]
.with_context(mis_report_filters=mis_report_filters)
._get_filter_domain_from_context()
)
assert domain == expected_domain
def _check_get_filter_descriptions_from_context(
self, mis_report_filters, expected_domain
):
filter_descriptions = (
self.env["mis.report.instance"]
.with_context(mis_report_filters=mis_report_filters)
.get_filter_descriptions_from_context()
)
assert filter_descriptions == expected_domain
def test_get_filter_domain_from_context_1(self):
# no filter, no domain
self._check_get_filter_domain_from_context({}, [])
# the most basic analytic account filter (default operator is =)
self._check_get_filter_domain_from_context(
{"analytic_account_id": {"value": 1}}, [("analytic_account_id", "=", 1)]
)
self._check_get_filter_domain_from_context(
{"analytic_group_id": {"value": 1}}, [("analytic_group_id", "=", 1)]
)
# custom operator
self._check_get_filter_domain_from_context(
{"analytic_account_id": {"value": 1, "operator": "!="}},
[("analytic_account_id", "!=", 1)],
)
self._check_get_filter_domain_from_context(
{"analytic_group_id": {"value": 1, "operator": "!="}},
[("analytic_group_id", "!=", 1)],
)
# any field name works
self._check_get_filter_domain_from_context(
{"some_field": {"value": "x"}}, [("some_field", "=", "x")]
)
# filter name without value => no domain
self._check_get_filter_domain_from_context({"some_field": None}, [])
# "is not set" filter must work
self._check_get_filter_domain_from_context(
{"analytic_account_id": {"value": False}},
[("analytic_account_id", "=", False)],
)
self._check_get_filter_domain_from_context(
{"analytic_group_id": {"value": False}},
[("analytic_group_id", "=", False)],
)
# Filter from analytic account filter widget
self._check_get_filter_domain_from_context(
{"analytic_account_id": {"value": 1, "operator": "all"}},
[("analytic_account_id", "in", [1])],
)
# Filter from analytic group filter widget
self._check_get_filter_domain_from_context(
{"analytic_group_id": {"value": 1, "operator": "all"}},
[("analytic_group_id", "in", [1])],
)
# Filter from analytic tags filter widget
self._check_get_filter_domain_from_context(
{"analytic_tag_ids": {"value": [1, 2], "operator": "all"}},
[("analytic_tag_ids", "in", [1]), ("analytic_tag_ids", "in", [2])],
)
def test_get_filter_descriptions_from_context_1(self):
self._check_get_filter_descriptions_from_context(
{"analytic_account_id.group_id": {"value": self.aag.id}},
["Analytic Account Group: %s" % self.aag.display_name],
)
def test_get_filter_descriptions_from_context_2(self):
self._check_get_filter_descriptions_from_context(
{"analytic_tag_ids": {"value": [self.aat.id]}},
["Analytic Tags: %s" % self.aat.display_name],
)
def test_get_filter_descriptions_from_context_3(self):
self._check_get_filter_descriptions_from_context(
{
"analytic_tag_ids": {"value": [self.aat.id]},
"analytic_account_id.group_id": {"value": self.aag.id},
},
[
"Analytic Account Group: %s" % self.aag.display_name,
"Analytic Tags: %s" % self.aat.display_name,
],
)
def test_get_additional_move_line_filter_with_analytic_group(self):
instance_period = self.env["mis.report.instance.period"].new(
{
"analytic_group_id": self.aag.id,
}
)
domain = instance_period._get_additional_move_line_filter()
assert domain == [("analytic_account_id.group_id", "=", self.aag.id)]
| 41.873134 | 5,611 |
239 |
py
|
PYTHON
|
15.0
|
# Copyright 2014 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from ..models import accounting_none
from .common import load_doctests
load_tests = load_doctests(accounting_none)
| 29.875 | 239 |
8,385 |
py
|
PYTHON
|
15.0
|
# Copyright 2014 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import datetime
import odoo.tests.common as common
from odoo import fields
from odoo.tools.safe_eval import safe_eval
from ..models.accounting_none import AccountingNone
from ..models.aep import AccountingExpressionProcessor as AEP
class TestMultiCompanyAEP(common.TransactionCase):
def setUp(self):
super().setUp()
self.res_company = self.env["res.company"]
self.account_model = self.env["account.account"]
self.move_model = self.env["account.move"]
self.journal_model = self.env["account.journal"]
self.currency_model = self.env["res.currency"]
self.curr_year = datetime.date.today().year
self.prev_year = self.curr_year - 1
self.usd = self.currency_model.with_context(active_test=False).search(
[("name", "=", "USD")]
)
self.eur = self.currency_model.with_context(active_test=False).search(
[("name", "=", "EUR")]
)
# create company A and B
self.company_eur = self.res_company.create(
{"name": "CYEUR", "currency_id": self.eur.id}
)
self.company_usd = self.res_company.create(
{"name": "CYUSD", "currency_id": self.usd.id}
)
self.env["res.currency.rate"].search([]).unlink()
type_ar = self.browse_ref("account.data_account_type_receivable")
type_in = self.browse_ref("account.data_account_type_revenue")
for company, divider in [(self.company_eur, 1.0), (self.company_usd, 2.0)]:
# create receivable bs account
company_key = company.name
setattr(
self,
"account_ar_" + company_key,
self.account_model.create(
{
"company_id": company.id,
"code": "400AR",
"name": "Receivable",
"user_type_id": type_ar.id,
"reconcile": True,
}
),
)
# create income pl account
setattr(
self,
"account_in_" + company_key,
self.account_model.create(
{
"company_id": company.id,
"code": "700IN",
"name": "Income",
"user_type_id": type_in.id,
}
),
)
# create journal
setattr(
self,
"journal" + company_key,
self.journal_model.create(
{
"company_id": company.id,
"name": "Sale journal",
"code": "VEN",
"type": "sale",
}
),
)
# create move in december last year
self._create_move(
journal=getattr(self, "journal" + company_key),
date=datetime.date(self.prev_year, 12, 1),
amount=100 / divider,
debit_acc=getattr(self, "account_ar_" + company_key),
credit_acc=getattr(self, "account_in_" + company_key),
)
# create move in january this year
self._create_move(
journal=getattr(self, "journal" + company_key),
date=datetime.date(self.curr_year, 1, 1),
amount=300 / divider,
debit_acc=getattr(self, "account_ar_" + company_key),
credit_acc=getattr(self, "account_in_" + company_key),
)
# create move in february this year
self._create_move(
journal=getattr(self, "journal" + company_key),
date=datetime.date(self.curr_year, 3, 1),
amount=500 / divider,
debit_acc=getattr(self, "account_ar_" + company_key),
credit_acc=getattr(self, "account_in_" + company_key),
)
def _create_move(self, journal, date, amount, debit_acc, credit_acc):
move = self.move_model.create(
{
"journal_id": journal.id,
"date": fields.Date.to_string(date),
"line_ids": [
(0, 0, {"name": "/", "debit": amount, "account_id": debit_acc.id}),
(
0,
0,
{"name": "/", "credit": amount, "account_id": credit_acc.id},
),
],
}
)
move._post()
return move
def _do_queries(self, companies, currency, date_from, date_to):
# create the AEP, and prepare the expressions we'll need
aep = AEP(companies, currency)
aep.parse_expr("bali[]")
aep.parse_expr("bale[]")
aep.parse_expr("balp[]")
aep.parse_expr("balu[]")
aep.parse_expr("bali[700IN]")
aep.parse_expr("bale[700IN]")
aep.parse_expr("balp[700IN]")
aep.parse_expr("bali[400AR]")
aep.parse_expr("bale[400AR]")
aep.parse_expr("balp[400AR]")
aep.parse_expr("debp[400A%]")
aep.parse_expr("crdp[700I%]")
aep.parse_expr("bali[400%]")
aep.parse_expr("bale[700%]")
aep.done_parsing()
aep.do_queries(
date_from=fields.Date.to_string(date_from),
date_to=fields.Date.to_string(date_to),
)
return aep
def _eval(self, aep, expr):
eval_dict = {"AccountingNone": AccountingNone}
return safe_eval(aep.replace_expr(expr), eval_dict)
def _eval_by_account_id(self, aep, expr):
res = {}
eval_dict = {"AccountingNone": AccountingNone}
for account_id, replaced_exprs in aep.replace_exprs_by_account_id([expr]):
res[account_id] = safe_eval(replaced_exprs[0], eval_dict)
return res
def test_aep_basic(self):
# let's query for december, one company
aep = self._do_queries(
self.company_eur,
None,
datetime.date(self.prev_year, 12, 1),
datetime.date(self.prev_year, 12, 31),
)
self.assertEqual(self._eval(aep, "balp[700IN]"), -100)
aep = self._do_queries(
self.company_usd,
None,
datetime.date(self.prev_year, 12, 1),
datetime.date(self.prev_year, 12, 31),
)
self.assertEqual(self._eval(aep, "balp[700IN]"), -50)
# let's query for december, two companies
aep = self._do_queries(
self.company_eur | self.company_usd,
self.eur,
datetime.date(self.prev_year, 12, 1),
datetime.date(self.prev_year, 12, 31),
)
self.assertEqual(self._eval(aep, "balp[700IN]"), -150)
def test_aep_multi_currency(self):
date_from = datetime.date(self.prev_year, 12, 1)
date_to = datetime.date(self.prev_year, 12, 31)
today = datetime.date.today()
self.env["res.currency.rate"].create(
dict(currency_id=self.usd.id, name=date_to, rate=1.1)
)
self.env["res.currency.rate"].create(
dict(currency_id=self.usd.id, name=today, rate=1.2)
)
# let's query for december, one company, default currency = eur
aep = self._do_queries(self.company_eur, None, date_from, date_to)
self.assertEqual(self._eval(aep, "balp[700IN]"), -100)
# let's query for december, two companies
aep = self._do_queries(
self.company_eur | self.company_usd, self.eur, date_from, date_to
)
self.assertAlmostEqual(self._eval(aep, "balp[700IN]"), -100 - 50 / 1.1)
# let's query for december, one company, currency = usd
aep = self._do_queries(self.company_eur, self.usd, date_from, date_to)
self.assertAlmostEqual(self._eval(aep, "balp[700IN]"), -100 * 1.1)
# let's query for december, two companies, currency = usd
aep = self._do_queries(
self.company_eur | self.company_usd, self.usd, date_from, date_to
)
self.assertAlmostEqual(self._eval(aep, "balp[700IN]"), -100 * 1.1 - 50)
| 39.928571 | 8,385 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.