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
|
|---|---|---|---|---|---|---|
1,411 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Pedro M. Baeza
# Copyright 2022 Tecnativa - Víctor Martínez
# License LGPL-3 - See https://www.gnu.org/licenses/lgpl-3.0.html
from odoo.tests import common
class TestCrmProject(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.lead = cls.env["crm.lead"].create(
{
"name": "Test lead",
"description": "Description",
"email_from": "[email protected]",
"partner_name": "Test partner",
"email_cc": "[email protected]",
}
)
cls.project = cls.env["project.project"].create({"name": "Test project"})
def test_crm_project(self):
wizard = (
self.env["crm.lead.convert2task"]
.with_context(
active_id=self.lead.id,
)
.create({"project_id": self.project.id})
)
action = wizard.action_lead_to_project_task()
task = self.env["project.task"].browse(action["res_id"])
self.assertEqual(task.description, "<p>Description</p>")
self.assertEqual(task.email_from, "[email protected]")
self.assertEqual(task.email_cc, "[email protected]")
self.assertEqual(task.partner_id.name, "Test partner")
self.assertEqual(task.project_id, self.project)
self.assertFalse(self.lead.exists())
| 37.078947 | 1,409 |
2,360 |
py
|
PYTHON
|
15.0
|
# Copyright 2010-2020 Odoo S. A.
# Copyright 2021 Tecnativa - Pedro M. Baeza
# Copyright 2022 Tecnativa - Víctor Martínez
# License LGPL-3 - See https://www.gnu.org/licenses/lgpl-3.0.html
from odoo import api, fields, models
class CrmLeadConvert2Task(models.TransientModel):
"""wizard to convert a Lead into a Project task and move the Mail Thread"""
_name = "crm.lead.convert2task"
_description = "Lead convert to Task"
@api.model
def default_get(self, fields):
result = super().default_get(fields)
lead_id = self.env.context.get("active_id")
if lead_id:
result["lead_id"] = lead_id
return result
lead_id = fields.Many2one(
comodel_name="crm.lead", string="Lead", domain=[("type", "=", "lead")]
)
project_id = fields.Many2one(comodel_name="project.project", string="Project")
def action_lead_to_project_task(self):
self.ensure_one()
# get the lead to transform
lead = self.lead_id
partner = lead._find_matching_partner()
if not partner and (lead.partner_name or lead.contact_name):
lead._handle_partner_assignment()
partner = lead.partner_id
# create new project.task
vals = {
"name": lead.name,
"description": lead.description,
"email_from": lead.email_from,
"project_id": self.project_id.id,
"partner_id": partner.id,
"email_cc": lead.email_cc,
}
task = self.env["project.task"].create(vals)
# move the mail thread
lead.message_change_thread(task)
# move attachments
attachments = self.env["ir.attachment"].search(
[("res_model", "=", "crm.lead"), ("res_id", "=", lead.id)]
)
attachments.write({"res_model": "project.task", "res_id": task.id})
# remove the lead
lead.unlink()
# return the action to go to the form view of the new Task
view = self.env.ref("project.view_task_form2")
return {
"name": "Task created",
"view_type": "form",
"view_mode": "form",
"view_id": view.id,
"res_model": "project.task",
"type": "ir.actions.act_window",
"res_id": task.id,
"context": self.env.context,
}
| 36.276923 | 2,358 |
659 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
{
"name": "CRM stage probability",
"summary": "Define fixed probability on the stages",
"version": "15.0.1.0.0",
"development_status": "Alpha",
"category": "Sales/CRM",
"website": "https://github.com/OCA/crm",
"author": "Camptocamp, Odoo Community Association (OCA), Odoo SA",
"license": "AGPL-3",
"depends": ["crm"],
"data": [
"views/crm_lead.xml",
"views/crm_stage.xml",
"wizard/crm_lead_stage_probability_update.xml",
"data/crm_stage.xml",
"security/ir.model.access.csv",
],
}
| 32.95 | 659 |
4,989 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo.exceptions import UserError
from odoo.tests import TransactionCase
class TestCrmLeadProbability(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.stage_new = cls.env.ref("crm.stage_lead1")
cls.stage_qualified = cls.env.ref("crm.stage_lead2")
cls.stage_proposition = cls.env.ref("crm.stage_lead3")
cls.stage_won = cls.env.ref("crm.stage_lead4")
cls.opportunity_1 = cls.env.ref("crm.crm_case_32")
def test_update_probability(self):
self.assertEqual(self.opportunity_1.stage_id, self.stage_qualified)
self.assertFalse(self.opportunity_1.is_automated_probability)
self.assertFalse(self.opportunity_1.is_stage_probability)
self.opportunity_1.write({"stage_id": self.stage_new.id})
self.assertEqual(self.opportunity_1.probability, self.stage_new.probability)
self.assertFalse(self.opportunity_1.is_automated_probability)
self.assertTrue(self.opportunity_1.is_stage_probability)
self.opportunity_1.write({"stage_id": self.stage_proposition.id})
self.assertEqual(
self.opportunity_1.probability, self.stage_proposition.probability
)
self.assertFalse(self.opportunity_1.is_automated_probability)
self.assertTrue(self.opportunity_1.is_stage_probability)
self.opportunity_1.write({"probability": 31.56})
self.assertFalse(self.opportunity_1.is_automated_probability)
self.assertFalse(self.opportunity_1.is_stage_probability)
self.opportunity_1.action_set_stage_probability()
self.assertEqual(
self.opportunity_1.probability, self.opportunity_1.stage_id.probability
)
self.assertTrue(self.opportunity_1.is_stage_probability)
self.opportunity_1.write({"stage_id": False})
self.assertFalse(self.opportunity_1.is_automated_probability)
self.assertFalse(self.opportunity_1.is_stage_probability)
self.opportunity_1.action_set_stage_probability()
self.assertFalse(self.opportunity_1.probability)
def test_create_opportunity(self):
opportunity = self.env["crm.lead"].create(
{"name": "My opportunity", "type": "opportunity"}
)
default_stage_id = (
self.env["crm.lead"]._stage_find(domain=[("fold", "=", False)]).id
)
default_stage = self.env["crm.stage"].browse(default_stage_id)
self.assertEqual(opportunity.probability, default_stage.probability)
self.assertFalse(opportunity.is_automated_probability)
# test if there is no default stage
self.env["crm.stage"].search([("fold", "=", False)]).write({"fold": True})
opportunity = self.env["crm.lead"].create(
{"name": "My opportunity", "type": "opportunity"}
)
self.assertEqual(opportunity.probability, 10)
self.assertFalse(opportunity.is_automated_probability)
def test_change_stage_id_values(self):
self.opportunity_1._onchange_stage_id_values(False)
def test_create_opportunity_default_stage_id(self):
opportunity = (
self.env["crm.lead"]
.with_context(default_stage_id=self.stage_qualified.id)
.create({"name": "My opportunity", "type": "opportunity"})
)
self.assertEqual(opportunity.probability, self.stage_qualified.probability)
self.assertFalse(opportunity.is_automated_probability)
def test_mass_update(self):
all_stages = self.env["crm.stage"].search([])
self.assertTrue(all(all_stages.mapped("on_change")))
wiz = (
self.env["crm.lead.stage.probability.update"]
.with_context(active_ids=all_stages.ids)
.create({})
)
wiz.execute()
all_leads = self.env["crm.lead"].search([])
self.assertTrue(all(all_leads.mapped("is_stage_probability")))
self.assertFalse(all(all_leads.mapped("is_automated_probability")))
new_line = wiz.crm_stage_update_ids.filtered(
lambda x: x.stage_id == self.stage_new
)
self.assertEqual(new_line.lead_count, 13)
won_line = wiz.crm_stage_update_ids.filtered(
lambda x: x.stage_id == self.stage_won
)
self.assertEqual(won_line.lead_count, 3)
def test_mass_update_no_onchange_stage(self):
new_stage = self.env["crm.stage"].create(
{
"name": "No Onchange",
"sequence": 10,
}
)
self.assertFalse(new_stage.on_change)
with self.assertRaises(UserError) as context:
(
self.env["crm.lead.stage.probability.update"]
.with_context(active_ids=new_stage.ids)
.create({})
)
self.assertTrue("Following stages must be set as" in str(context.exception))
| 45.354545 | 4,989 |
3,103 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import _, api, fields, models
from odoo.exceptions import UserError
class CrmLeadStageProbabilityUpdate(models.TransientModel):
_name = "crm.lead.stage.probability.update"
_description = "Mass update of crm lead probability according to stage"
crm_stage_update_ids = fields.Many2many(
"crm.lead.stage.probability.update.line",
"crm_lead_stage_probability_update_line_rel",
"wizard_id",
"stage_id",
readonly=True,
)
@api.model
def default_get(self, fields_list):
res = super().default_get(fields_list)
if "crm_stage_update_ids" in fields_list and "active_ids" in self.env.context:
active_ids = self.env.context.get("active_ids")
stages = self.env["crm.stage"].browse(active_ids)
stages_missing_on_change = stages.filtered(lambda s: not s.on_change)
if stages_missing_on_change:
raise UserError(
_(
"Following stages must be set as 'Change Probability "
"Automatically' in order to update their related leads:"
"\n\n"
"%s"
)
% "\n".join([s.name for s in stages_missing_on_change])
)
line_ids = []
for stage in stages:
new_line = self.env["crm.lead.stage.probability.update.line"].create(
{"stage_id": stage.id}
)
line_ids.append(new_line.id)
res["crm_stage_update_ids"] = [(6, 0, line_ids)]
return res
def execute(self):
updated_leads_ids = []
for stage_line in self.crm_stage_update_ids:
leads = self.env["crm.lead"].search(
[("stage_id", "=", stage_line.stage_id.id)]
)
leads.write({"probability": stage_line.stage_id.probability})
updated_leads_ids += leads.ids
action = self.env.ref("crm.crm_lead_all_leads").read()[0]
action["domain"] = "[('id', 'in', %s)]" % updated_leads_ids
action.pop("context")
return action
class CrmLeadStageProbabilityUpdateStage(models.TransientModel):
_name = "crm.lead.stage.probability.update.line"
_description = "CRM leads stages to updates"
wizard_id = fields.Many2many(
"crm.lead.stage.probability.update",
"crm_lead_stage_probability_update_line_rel",
"stage_id",
"wizard_id",
readonly=True,
)
stage_id = fields.Many2one(
"crm.stage", domain=[("on_change", "=", True)], readonly=True
)
lead_count = fields.Integer(
"No of leads", compute="_compute_lead_count", readonly=True
)
@api.depends("stage_id")
def _compute_lead_count(self):
for stage_line in self:
stage_line.lead_count = self.env["crm.lead"].search_count(
[("stage_id", "=", stage_line.stage_id.id)]
)
| 36.940476 | 3,103 |
823 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import fields, models
class CrmStage(models.Model):
_inherit = "crm.stage"
probability = fields.Float(
"Probability (%)",
required=True,
default=10.0,
help="This percentage depicts the default/average probability of the "
"Case for this stage to be a success",
)
on_change = fields.Boolean(
"Change Probability Automatically",
help="Setting this stage will change the probability automatically on "
"the opportunity.",
)
_sql_constraints = [
(
"check_probability",
"check(probability >= 0 and probability <= 100)",
"The probability should be between 0% and 100%!",
)
]
| 28.37931 | 823 |
3,036 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import api, fields, models, tools
class CrmLead(models.Model):
_inherit = "crm.lead"
is_stage_probability = fields.Boolean(
compute="_compute_is_stage_probability", readonly=True
)
stage_probability = fields.Float(related="stage_id.probability", readonly=True)
probability = fields.Float(default=lambda self: self._default_probability())
def _default_probability(self):
if "default_stage_id" in self._context:
stage_id = self._context.get("default_stage_id")
else:
stage_id = self._stage_find(domain=[("fold", "=", False)]).id
if stage_id:
return self.env["crm.stage"].browse(stage_id).probability
return 10
@api.depends("probability", "stage_id", "stage_id.probability")
def _compute_is_stage_probability(self):
for lead in self:
lead.is_stage_probability = (
tools.float_compare(lead.probability, lead.stage_probability, 2) == 0
)
@api.depends("probability", "automated_probability")
def _compute_is_automated_probability(self):
for lead in self:
if lead.probability != lead.stage_id.probability:
super(CrmLead, lead)._compute_is_automated_probability()
continue
lead.is_automated_probability = False
return
@api.depends(
lambda self: ["tag_ids", "stage_id", "team_id"] + self._pls_get_safe_fields()
)
def _compute_probabilities(self):
self = self.with_context(_auto_update_probability=True)
return super()._compute_probabilities()
@api.model
def _onchange_stage_id_values(self, stage_id):
"""returns the new values when stage_id has changed"""
if not stage_id:
return {}
stage = self.env["crm.stage"].browse(stage_id)
if stage.on_change:
return {"probability": stage.probability}
return {}
@api.onchange("stage_id")
def _onchange_stage_id(self):
values = self._onchange_stage_id_values(self.stage_id.id)
self.update(values)
def write(self, vals):
# Avoid to update probability with automated_probability on
# _update_probability if the stage is set as on_change
# If the stage is not set as on_change, auto PLS will be applied
if (
self.env.context.get("_auto_update_probability")
and "probability" in vals
and "stage_id" not in vals
):
vals.update(self._onchange_stage_id_values(self.stage_id.id))
# Force to use the probability from the stage if set as on_change
if vals.get("stage_id") and "probability" not in vals:
vals.update(self._onchange_stage_id_values(vals.get("stage_id")))
return super().write(vals)
def action_set_stage_probability(self):
self.write({"probability": self.stage_id.probability})
| 38.43038 | 3,036 |
587 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antiun Ingeniería S.L. - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Firstname and Lastname in Leads",
"summary": "Specify split names for contacts in leads",
"version": "15.0.1.0.1",
"category": "Customer Relationship Management",
"website": "https://github.com/OCA/crm",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["crm", "partner_firstname"],
"data": ["views/crm_lead_view.xml"],
}
| 36.625 | 586 |
1,891 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antiun Ingeniería S.L. - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import Form, TransactionCase
class FirstNameCase(TransactionCase):
@classmethod
def setUpClass(cls):
super(FirstNameCase, cls).setUpClass()
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
cls.lead_model = cls.env["crm.lead"]
cls.partner_model = cls.env["res.partner"]
cls.lead = cls.lead_model.create(
{
"name": "Léad",
"partner_name": "Pärtner",
"contact_name": "Firçt name",
"contact_lastname": "Laçt name",
}
)
cls.partner = cls.partner_model.create(
{"firstname": "Firçt name", "lastname": "Laçt name"}
)
def test_create_contact(self):
"""Contact correctly created."""
self.lead._handle_partner_assignment()
partner = self.partner_model.browse(self.lead.partner_id.id)
self.assertEqual(self.lead.contact_name, partner.firstname)
self.assertEqual(self.lead.contact_lastname, partner.lastname)
def test_create_contact_empty(self):
"""No problems creating a contact without names."""
self.lead.write({"contact_name": False, "contact_lastname": False})
self.lead._handle_partner_assignment()
def test_onchange_partner(self):
"""When changing partner, fields get correctly updated."""
with Form(self.env["crm.lead"], view="crm.crm_lead_view_form") as lead_form:
lead_form.partner_id = self.partner
lead_form.name = self.partner.name
lead_form.save()
self.assertEqual(self.partner.firstname, lead_form.contact_name)
self.assertEqual(self.partner.lastname, lead_form.contact_lastname)
| 41.866667 | 1,884 |
2,112 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antiun Ingeniería S.L. - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class CrmLead(models.Model):
_inherit = "crm.lead"
contact_name = fields.Char("First name")
contact_lastname = fields.Char("Last name")
def _prepare_customer_values(self, partner_name, is_company, parent_id=False):
"""Ensure first and last names of contact match those in lead."""
lead_partner_data = super(CrmLead, self)._prepare_customer_values(
partner_name, is_company, parent_id
)
if not is_company:
if self.contact_name:
lead_partner_data.update({"firstname": self.contact_name})
if "name" in lead_partner_data:
del lead_partner_data["name"]
if self.contact_lastname:
lead_partner_data.update({"lastname": self.contact_lastname})
if "name" in lead_partner_data:
del lead_partner_data["name"]
return lead_partner_data
def _prepare_values_from_partner(self, partner):
"""Recover first and last names from partner if available."""
result = super(CrmLead, self)._prepare_values_from_partner(partner)
if partner:
if not partner.is_company:
result.update(
{
"contact_name": partner.firstname,
"contact_lastname": partner.lastname,
}
)
return self._convert_to_write(result)
def _prepare_contact_name_from_partner(self, partner):
result = super()._prepare_contact_name_from_partner(partner)
contact_name = False if partner.is_company else partner.firstname
contact_lastname = False if partner.is_company else partner.lastname
result.update(
{
"contact_name": contact_name or self.contact_name,
"contact_lastname": contact_lastname or self.contact_lastname,
}
)
return result
| 39.092593 | 2,111 |
931 |
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).
def uninstall_hook(cr, registry):
"""Revert table tier_review back to original before this module"""
cr.execute(
"update tier_review a set sequence = "
"(select floor(sequence) from tier_review b where a.id = b.id);"
)
cr.execute(
"update tier_review a set status = 'approved' where status = 'forwarded';"
)
cr.execute("alter table tier_review drop column name cascade;")
cr.execute("alter table tier_review drop column review_type cascade;")
cr.execute("alter table tier_review drop column reviewer_id cascade;")
cr.execute("alter table tier_review drop column reviewer_group_id cascade;")
cr.execute("alter table tier_review drop column has_comment cascade;")
cr.execute("alter table tier_review drop column approve_sequence cascade;")
| 49 | 931 |
977 |
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).
{
"name": "Base Tier Validation Forward",
"summary": "Forward option for base tiers",
"version": "15.0.1.0.0",
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"author": "Ecosoft,Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["base_tier_validation"],
"data": [
"security/ir.model.access.csv",
"data/mail_data.xml",
"views/tier_definition_view.xml",
"wizard/forward_wizard_view.xml",
"templates/tier_validation_templates.xml",
],
"development_status": "Alpha",
"maintainers": ["kittiu"],
"application": False,
"installable": True,
"assets": {
"web.assets_qweb": [
"base_tier_validation_forward/static/src/xml/tier_review_template.xml"
],
},
"uninstall_hook": "uninstall_hook",
}
| 33.689655 | 977 |
4,337 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow S.L.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo_test_helper import FakeModelLoader
from odoo.tests import Form
from odoo.tests.common import TransactionCase, tagged
@tagged("post_install", "-at_install")
class TierTierValidation(TransactionCase):
@classmethod
def setUpClass(cls):
super(TierTierValidation, cls).setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from odoo.addons.base_tier_validation.tests.tier_validation_tester import (
TierValidationTester,
)
cls.loader.update_registry((TierValidationTester,))
cls.test_model = cls.env[TierValidationTester._name]
cls.tester_model = cls.env["ir.model"].search(
[("model", "=", "tier.validation.tester")]
)
# 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,
}
)
# 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"}
)
cls.test_user_3 = cls.env["res.users"].create(
{"name": "Mary", "login": "test3"}
)
# 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)]",
}
)
cls.test_record = cls.test_model.create({"test_field": 2.5})
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super(TierTierValidation, cls).tearDownClass()
def test_01_forward_tier(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_2.id,
"definition_domain": "[('test_field', '>', 1.0)]",
"approve_sequence": True,
"has_forward": 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()
record.validate_tier()
self.assertFalse(record.can_forward)
# User 2 forward to user 1
record = test_record.with_user(self.test_user_2.id)
record.invalidate_cache()
self.assertTrue(record.can_forward)
res = record.forward_tier()
ctx = res.get("context")
wizard = Form(
self.env["tier.validation.forward.wizard"]
.with_user(self.test_user_2.id)
.with_context(**ctx)
)
wizard.forward_reviewer_id = self.test_user_1
wizard.forward_description = "Please review again"
wiz = wizard.save()
wiz.add_forward()
# Newly created forwarded review will have no definition
record = test_record.with_user(self.test_user_2.id)
record.invalidate_cache()
self.assertTrue(record.review_ids.filtered(lambda l: not l.definition_id))
# User 1 validate
res = record.with_user(self.test_user_1.id).validate_tier()
ctx = res.get("context")
wizard = Form(
self.env["comment.wizard"]
.with_user(self.test_user_1.id)
.with_context(**ctx)
)
wizard.comment = "Forward tier is reviewed"
wiz = wizard.save()
wiz.add_comment()
self.assertTrue(record.validated)
| 35.54918 | 4,337 |
496 |
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 models
class CommentWizard(models.TransientModel):
_inherit = "comment.wizard"
def add_comment(self):
super().add_comment()
rec = self.env[self.res_model].browse(self.res_id)
if self.validate_reject == "forward":
rec._forward_tier(self.review_ids)
rec._update_counter()
return self.review_ids
| 33.066667 | 496 |
1,905 |
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 ValidationForwardWizard(models.TransientModel):
_name = "tier.validation.forward.wizard"
_description = "Forward Wizard"
res_model = fields.Char()
res_id = fields.Integer()
forward_reviewer_id = fields.Many2one(
comodel_name="res.users",
string="Next Reviewer",
required=True,
)
forward_description = fields.Char()
has_comment = fields.Boolean(string="Allow Comment", default=True)
approve_sequence = fields.Boolean(
string="Approve by sequence",
default=True,
)
def add_forward(self):
"""Add extra step, with specific reviewer"""
self.ensure_one()
rec = self.env[self.res_model].browse(self.res_id)
prev_comment = self.env["comment.wizard"].browse(
self._context.get("comment_id")
)
prev_comment.write(
{"comment": _(">> %s") % self.forward_reviewer_id.display_name}
)
prev_reviews = prev_comment.add_comment()
review = self.env["tier.review"].create(
{
"model": rec._name,
"res_id": rec.id,
"sequence": max(prev_reviews.mapped("sequence")) + 0.1,
"requested_by": self.env.uid,
}
)
# Because following fileds are readonly, we need to write after create
review.write(
{
"name": self.forward_description,
"review_type": "individual",
"reviewer_id": self.forward_reviewer_id.id,
"has_comment": self.has_comment,
"approve_sequence": self.approve_sequence,
}
)
rec.invalidate_cache()
rec.review_ids._compute_can_review()
| 35.277778 | 1,905 |
385 |
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 TierDefinition(models.Model):
_inherit = "tier.definition"
has_forward = fields.Boolean(
string="Allow Forward",
default=False,
help="Allow option to 'Forward' to different person.",
)
| 29.615385 | 385 |
3,510 |
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 _, api, fields, models
class TierValidation(models.AbstractModel):
_inherit = "tier.validation"
can_forward = fields.Boolean(compute="_compute_can_forward")
def _compute_can_forward(self):
for rec in self:
if not rec.can_review:
rec.can_forward = False
continue
sequences = self._get_sequences_to_approve(self.env.user)
reviews = rec.review_ids.filtered(lambda l: l.sequence in sequences)
definitions = reviews.mapped("definition_id")
rec.can_forward = True in definitions.mapped("has_forward")
@api.model
def _calc_reviews_validated(self, reviews):
"""Override for different validation policy."""
if not reviews:
return False
return not any(
[s not in ("approved", "forwarded") for s in reviews.mapped("status")]
)
def _get_forwarded_notification_subtype(self):
return "base_tier_validation.mt_tier_validation_forwarded"
def forward_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)
ctx = self._add_comment("forward", reviews)["context"]
comment = (
self.env["comment.wizard"].with_context(**ctx).create({"comment": "/"})
)
wizard = self.env.ref("base_tier_validation_forward.view_forward_wizard")
return {
"name": _("Forward"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "tier.validation.forward.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {
"default_res_id": self.id,
"default_res_model": self._name,
"comment_id": comment.id,
},
}
def _forward_tier(self, tiers=False):
self.ensure_one()
tier_reviews = tiers or self.review_ids
user_reviews = tier_reviews.filtered(
lambda r: r.status != "approved" and (self.env.user in r.reviewer_ids)
)
user_reviews.write(
{
"status": "forwarded",
"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_forwarded_reviews()
def _notify_forwarded_reviews(self):
post = "message_post"
if hasattr(self, post):
# Notify state change
getattr(self, post)(
subtype_xmlid=self._get_forwarded_notification_subtype(),
body=self._notify_forwarded_reviews_body(),
)
def _notify_forwarded_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 forwarded from %(user_name)s %(comment)s") % (
{"user_name": self.env.user.name, "comment": comment}
)
return _("A review was forwarded by %s.") % (self.env.user.name)
| 38.152174 | 3,510 |
1,726 |
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 api, fields, models
class TierReview(models.Model):
_inherit = "tier.review"
_order = "sequence"
name = fields.Char(compute="_compute_definition_data", store=True)
status = fields.Selection(
selection_add=[("forwarded", "Forwarded")],
)
review_type = fields.Selection(
compute="_compute_definition_data",
store=True,
)
reviewer_id = fields.Many2one(
comodel_name="res.users",
compute="_compute_definition_data",
store=True,
)
reviewer_group_id = fields.Many2one(
comodel_name="res.groups",
compute="_compute_definition_data",
store=True,
)
sequence = fields.Float()
has_comment = fields.Boolean(
compute="_compute_definition_data",
store=True,
)
approve_sequence = fields.Boolean(
compute="_compute_definition_data",
store=True,
)
@api.depends(
"definition_id.name",
"definition_id.review_type",
"definition_id.reviewer_id",
"definition_id.reviewer_group_id",
"definition_id.has_comment",
"definition_id.approve_sequence",
)
def _compute_definition_data(self):
for rec in self:
rec.name = rec.definition_id.name
rec.review_type = rec.definition_id.review_type
rec.reviewer_id = rec.definition_id.reviewer_id
rec.reviewer_group_id = rec.definition_id.reviewer_group_id
rec.has_comment = rec.definition_id.has_comment
rec.approve_sequence = rec.definition_id.approve_sequence
| 32.566038 | 1,726 |
791 |
py
|
PYTHON
|
15.0
|
# Copyright 2013 Agile Business Group sagl (<http://www.agilebg.com>)
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# Copyright 2018 Dreambits Technologies Pvt. Ltd. (<http://dreambits.in>)
# Copyright 2020 Ecosoft Co., Ltd. (<http://ecosoft.co.th>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Base Revision (abstract)",
"summary": "Keep track of revised document",
"version": "15.0.1.0.0",
"category": "Tools",
"author": "Agile Business Group,"
"Dreambits,"
"Camptocamp,"
"Akretion,"
"Serpent Consulting Services Pvt. Ltd.,"
"Ecosoft,"
"Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"depends": ["base"],
"installable": True,
}
| 34.391304 | 791 |
3,484 |
py
|
PYTHON
|
15.0
|
# Copyright 2013 Agile Business Group sagl (<http://www.agilebg.com>)
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# Copyright 2018 Dreambits Technologies Pvt. Ltd. (<http://dreambits.in>)
# Copyright 2020 Ecosoft (<http://ecosoft.co.th>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo_test_helper import FakeModelLoader
from odoo.tests import common
class TestBaseRevision(common.TransactionCase):
@classmethod
def setUpClass(cls):
super(TestBaseRevision, cls).setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .base_revision_tester import BaseRevisionTester
cls.loader.update_registry((BaseRevisionTester,))
cls.revision_model = cls.env[BaseRevisionTester._name]
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super(TestBaseRevision, cls).tearDownClass()
def _create_tester(self):
return self.revision_model.create({"name": "TEST0001"})
@staticmethod
def _revision_tester(tester):
# Cancel the tester
tester.action_cancel()
# Create a new revision
return tester.create_revision()
def test_revision(self):
"""Check revision process"""
# Create a Tester document
tester_1 = self._create_tester()
# Create a revision of the Tester
self._revision_tester(tester_1)
# Check the previous revision of the tester
revision_1 = tester_1.current_revision_id
self.assertEqual(tester_1.state, "cancel")
# Check the current revision of the tester
self.assertEqual(revision_1.unrevisioned_name, tester_1.name)
self.assertEqual(revision_1.state, "draft")
self.assertTrue(revision_1.active)
self.assertEqual(revision_1.old_revision_ids, tester_1)
self.assertEqual(revision_1.revision_number, 1)
self.assertEqual(revision_1.name.endswith("-01"), True)
self.assertEqual(revision_1.has_old_revisions, True)
self.assertEqual(revision_1.revision_count, 1)
# Create a new revision of the tester
self._revision_tester(revision_1)
revision_2 = revision_1.current_revision_id
# Check the previous revision of the tester
self.assertEqual(revision_1.state, "cancel")
self.assertFalse(revision_1.active)
# Check the current revision of the tester
self.assertEqual(revision_2.unrevisioned_name, tester_1.name)
self.assertEqual(revision_2, tester_1.current_revision_id)
self.assertEqual(revision_2.state, "draft")
self.assertTrue(revision_2.active)
self.assertEqual(revision_2.old_revision_ids, tester_1 + revision_1)
self.assertEqual(revision_2.revision_number, 2)
self.assertEqual(revision_2.name.endswith("-02"), True)
self.assertEqual(revision_2.has_old_revisions, True)
self.assertEqual(revision_2.revision_count, 2)
def test_simple_copy(self):
"""Check copy process"""
# Create a tester
tester_2 = self._create_tester()
# Check the 'Order Reference' of the tester
self.assertEqual(tester_2.name, tester_2.unrevisioned_name)
# Copy the tester
tester_3 = tester_2.copy({"name": "TEST0002"})
# Check the 'Reference' of the copied tester
self.assertEqual(tester_3.name, tester_3.unrevisioned_name)
| 38.711111 | 3,484 |
864 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Ecosoft (http://ecosoft.co.th)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class BaseRevisionTester(models.Model):
_name = "base.revision.tester"
_description = "Base Revision Tester"
_inherit = ["base.revision"]
name = fields.Char(required=True)
state = fields.Selection(
selection=[
("draft", "Draft"),
("confirmed", "Confirmed"),
("cancel", "Cancel"),
],
default="draft",
)
current_revision_id = fields.Many2one(
comodel_name="base.revision.tester",
)
old_revision_ids = fields.One2many(
comodel_name="base.revision.tester",
)
def action_confirm(self):
self.write({"state": "confirmed"})
def action_cancel(self):
self.write({"state": "cancel"})
| 27 | 864 |
4,720 |
py
|
PYTHON
|
15.0
|
# Copyright 2013 Agile Business Group sagl (<http://www.agilebg.com>)
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# Copyright 2018 Dreambits Technologies Pvt. Ltd. (<http://dreambits.in>)
# 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 _, api, fields, models
class BaseRevision(models.AbstractModel):
_name = "base.revision"
_description = "Document Revision (abstract)"
@api.depends("old_revision_ids")
def _compute_has_old_revisions(self):
for rec in self:
rec.has_old_revisions = (
True if rec.with_context(active_test=False).old_revision_ids else False
)
current_revision_id = fields.Many2one(
comodel_name="base.revision",
string="Current revision",
readonly=True,
copy=True,
)
old_revision_ids = fields.One2many(
comodel_name="base.revision",
inverse_name="current_revision_id",
string="Old revisions",
readonly=True,
domain=["|", ("active", "=", False), ("active", "=", True)],
context={"active_test": False},
)
revision_number = fields.Integer(string="Revision", copy=False, default=0)
unrevisioned_name = fields.Char(
string="Original Reference", copy=True, readonly=True
)
active = fields.Boolean(default=True)
has_old_revisions = fields.Boolean(compute="_compute_has_old_revisions")
revision_count = fields.Integer(
compute="_compute_revision_count", string="Previous versions count"
)
@api.depends("old_revision_ids")
def _compute_revision_count(self):
res = self.with_context(active_test=False).read_group(
domain=[("current_revision_id", "in", self.ids)],
fields=["current_revision_id"],
groupby=["current_revision_id"],
)
revision_dict = {
x["current_revision_id"][0]: x["current_revision_id_count"] for x in res
}
for rec in self:
rec.revision_count = revision_dict.get(rec.id, 0)
_sql_constraints = [
(
"revision_unique",
"unique(unrevisioned_name, revision_number)",
"Reference and revision must be unique.",
)
]
@api.returns("self", lambda value: value.id)
def copy(self, default=None):
default = default or {}
if "unrevisioned_name" not in default:
default["unrevisioned_name"] = False
rec = super().copy(default=default)
if not rec.unrevisioned_name:
name_field = self._context.get("revision_name_field", "name")
rec.write({"unrevisioned_name": rec[name_field]})
return rec
def _get_new_rev_data(self, new_rev_number):
self.ensure_one()
return {
"revision_number": new_rev_number,
"unrevisioned_name": self.unrevisioned_name,
"name": "%s-%02d" % (self.unrevisioned_name, new_rev_number),
"old_revision_ids": [(4, self.id, False)],
}
def _prepare_revision_data(self, new_revision):
return {"active": False, "current_revision_id": new_revision.id}
def copy_revision_with_context(self):
default_data = self.default_get([])
new_rev_number = self.revision_number + 1
vals = self._get_new_rev_data(new_rev_number)
default_data.update(vals)
new_revision = self.copy(default_data)
self.old_revision_ids.write({"current_revision_id": new_revision.id})
self.write(self._prepare_revision_data(new_revision))
return new_revision
@api.model
def create(self, values):
rec = super().create(values)
if "unrevisioned_name" not in values:
name_field = self._context.get("revision_name_field", "name")
rec.write({"unrevisioned_name": rec[name_field]})
return rec
def create_revision(self):
revision_ids = []
# Looping over records
for rec in self:
# Calling Copy method
copied_rec = rec.copy_revision_with_context()
if hasattr(self, "message_post"):
msg = _("New revision created: %s") % copied_rec.name
copied_rec.message_post(body=msg)
rec.message_post(body=msg)
revision_ids.append(copied_rec.id)
action = {
"type": "ir.actions.act_window",
"view_mode": "tree,form",
"name": _("New Revisions"),
"res_model": self._name,
"domain": "[('id', 'in', %s)]" % revision_ids,
"target": "current",
}
return action
| 37.460317 | 4,720 |
646 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Akretion (<http://www.akretion.com>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Base Sub State",
"version": "15.0.1.0.0",
"category": "Tools",
"author": "Akretion, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"depends": ["base", "mail"],
"data": [
"security/base_substate_security.xml",
"security/ir.model.access.csv",
"views/base_substate_type_views.xml",
"views/base_substate_value_views.xml",
"views/base_substate_views.xml",
],
"installable": True,
}
| 32.3 | 646 |
4,082 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Akretion Mourad EL HADJ MIMOUNE
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
from .sale_test import LineTest, SaleTest
@common.tagged("post_install", "-at_install")
class TestBaseSubstate(common.TransactionCase):
@classmethod
def setUpClass(cls):
super(TestBaseSubstate, cls).setUpClass()
SaleTest._test_setup_models(cls.env, [SaleTest, LineTest])
LineTest._test_setup_model(cls.env)
cls.substate_test_sale = cls.env["base.substate.test.sale"]
cls.substate_test_sale_line = cls.env["base.substate.test.sale.line"]
cls.base_substate = cls.env["base.substate.mixin"]
cls.substate_type = cls.env["base.substate.type"]
cls.substate_type._fields["model"].selection.append(
("base.substate.test.sale", "Sale Order")
)
cls.substate_type = cls.env["base.substate.type"].create(
{
"name": "Sale",
"model": "base.substate.test.sale",
"target_state_field": "state",
}
)
cls.substate_val_quotation = cls.env["target.state.value"].create(
{
"name": "Quotation",
"base_substate_type_id": cls.substate_type.id,
"target_state_value": "draft",
}
)
cls.substate_val_sale = cls.env["target.state.value"].create(
{
"name": "Sale order",
"base_substate_type_id": cls.substate_type.id,
"target_state_value": "sale",
}
)
cls.substate_under_negotiation = cls.env["base.substate"].create(
{
"name": "Under negotiation",
"sequence": 1,
"target_state_value_id": cls.substate_val_quotation.id,
}
)
cls.substate_won = cls.env["base.substate"].create(
{
"name": "Won",
"sequence": 1,
"target_state_value_id": cls.substate_val_quotation.id,
}
)
cls.substate_wait_docs = cls.env["base.substate"].create(
{
"name": "Waiting for legal documents",
"sequence": 2,
"target_state_value_id": cls.substate_val_sale.id,
}
)
cls.substate_valid_docs = cls.env["base.substate"].create(
{
"name": "To validate legal documents",
"sequence": 3,
"target_state_value_id": cls.substate_val_sale.id,
}
)
cls.substate_in_delivering = cls.env["base.substate"].create(
{
"name": "In delivering",
"sequence": 4,
"target_state_value_id": cls.substate_val_sale.id,
}
)
@classmethod
def tearDownClass(cls):
SaleTest._test_teardown_model(cls.env)
LineTest._test_teardown_model(cls.env)
return super().tearDownClass()
def test_sale_order_substate(self):
partner = self.env.ref("base.res_partner_1")
so_test1 = self.substate_test_sale.create(
{
"name": "Test base substate to basic sale",
"partner_id": partner.id,
"line_ids": [
(0, 0, {"name": "line test", "amount": 120.0, "qty": 1.5})
],
}
)
self.assertTrue(so_test1.state == "draft")
self.assertTrue(so_test1.substate_id == self.substate_under_negotiation)
# Test that validation of sale order change substate_id
so_test1.button_confirm()
self.assertTrue(so_test1.state == "sale")
self.assertTrue(so_test1.substate_id == self.substate_wait_docs)
# Test that substate_id is set to false if
# there is not substate corresponding to state
so_test1.button_cancel()
self.assertTrue(so_test1.state == "cancel")
self.assertTrue(not so_test1.substate_id)
| 34.302521 | 4,082 |
1,733 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Akretion Mourad EL HADJ MIMOUNE
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
from .models_mixin import TestMixin
class SaleTest(models.Model, TestMixin):
_inherit = "base.substate.mixin"
_name = "base.substate.test.sale"
_description = "Base substate Test Model"
name = fields.Char(required=True)
user_id = fields.Many2one("res.users", string="Responsible")
state = fields.Selection(
[("draft", "New"), ("cancel", "Cancelled"), ("sale", "Sale"), ("done", "Done")],
string="Status",
readonly=True,
default="draft",
)
active = fields.Boolean(default=True)
partner_id = fields.Many2one("res.partner", string="Partner")
line_ids = fields.One2many(
comodel_name="base.substate.test.sale.line",
inverse_name="sale_id",
context={"active_test": False},
)
amount_total = fields.Float(compute="_compute_amount_total", store=True)
@api.depends("line_ids")
def _compute_amount_total(self):
for record in self:
for line in record.line_ids:
record.amount_total += line.amount * line.qty
def button_confirm(self):
self.write({"state": "sale"})
return True
def button_cancel(self):
self.write({"state": "cancel"})
class LineTest(models.Model, TestMixin):
_name = "base.substate.test.sale.line"
_description = "Base substate Test Model Line"
name = fields.Char()
sale_id = fields.Many2one(
comodel_name="base.substate.test.sale",
ondelete="cascade",
context={"active_test": False},
)
qty = fields.Float()
amount = fields.Float()
| 31.509091 | 1,733 |
4,378 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Simone Orsi - Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from operator import attrgetter
class TestMixin(object):
"""Mixin to setup fake models for tests.
Usage - the model:
class FakeModel(models.Model, TestMixin):
_name = 'fake.model'
name = fields.Char()
Usage - the test klass:
@classmethod
def setUpClass(cls):
super().setUpClass()
FakeModel._test_setup_model(cls.env)
@classmethod
def tearDownClass(cls):
FakeModel._test_teardown_model(cls.env)
super().tearDownClass()
"""
# Generate xmlids
# This is needed if you want to load data tied to a test model via xid.
_test_setup_gen_xid = False
# If you extend a real model (ie: res.partner) you must enable this
# to not delete the model on tear down.
_test_teardown_no_delete = False
# You can add custom fields to real models (eg: res.partner).
# In this case you must delete them to leave registry and model clean.
# This is mandatory for relational fields that link a fake model.
_test_purge_fields = []
@classmethod
def _test_setup_models(cls, env, model_clses):
"""
Setup models at the same time
if one fake model ref to another in relational
field.
ex : many2one fields
in this case we should don't use manual=True as an option in field.
"""
for model_cls in model_clses:
model_cls._build_model(env.registry, env.cr)
env.registry.setup_models(env.cr)
ctx = dict(env.context, update_custom_fields=True)
if cls._test_setup_gen_xid:
ctx["module"] = cls._module
env.registry.init_models(
env.cr, [model_cls._name for model_cls in model_clses], ctx
)
@classmethod
def _test_setup_model(cls, env):
"""Initialize it."""
cls._build_model(env.registry, env.cr)
env.registry.setup_models(env.cr)
ctx = dict(env.context, update_custom_fields=True)
if cls._test_setup_gen_xid:
ctx["module"] = cls._module
env.registry.init_models(env.cr, [cls._name], ctx)
@classmethod
def _test_teardown_model(cls, env):
"""Cleanup registry and real models."""
for fname in cls._test_purge_fields:
model = env[cls._name]
if fname in model:
model._pop_field(fname)
if not getattr(cls, "_test_teardown_no_delete", False):
del env.registry.models[cls._name]
# here we must remove the model from list of children of inherited
# models
parents = cls._inherit
parents = [parents] if isinstance(parents, str) else (parents or [])
# keep a copy to be sure to not modify the original _inherit
parents = list(parents)
parents.extend(cls._inherits.keys())
parents.append("base")
funcs = [
attrgetter(kind + "_children") for kind in ["_inherits", "_inherit"]
]
for parent in parents:
for func in funcs:
children = func(env.registry[parent])
if cls._name in children:
# at this stage our cls is referenced as children of
# parent -> must un reference it
children.remove(cls._name)
def _test_get_model_id(self):
self.env.cr.execute("SELECT id FROM ir_model WHERE model = %s", (self._name,))
res = self.env.cr.fetchone()
return res[0] if res else None
def _test_create_ACL(self, **kw):
model_id = self._test_get_model_id()
if not model_id:
self._reflect()
model_id = self._test_get_model_id()
if model_id:
vals = self._test_ACL_values(model_id)
vals.update(kw)
self.env["ir.model.access"].create(vals)
def _test_ACL_values(self, model_id):
values = {
"name": "Fake ACL for %s" % self._name,
"model_id": model_id,
"perm_read": 1,
"perm_create": 1,
"perm_write": 1,
"perm_unlink": 1,
"active": True,
}
return values
| 35.024 | 4,378 |
4,594 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Akretion
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class BaseSubstateMixin(models.AbstractModel):
_name = "base.substate.mixin"
_description = "BaseSubstate Mixin"
_state_field = "state"
@api.constrains("substate_id", _state_field)
def check_substate_id_value(self):
rec_states = dict(self._fields[self._state_field].selection)
for rec in self:
target_state = rec.substate_id.target_state_value_id.target_state_value
if rec.substate_id and rec.state != target_state:
raise ValidationError(
_(
"The substate %(name)s is not defined for the state"
" %(state)s but for %(target_state)s "
)
% {
"name": rec.substate_id.name,
"state": _(rec_states[rec.state]),
"target_state": _(rec_states[target_state]),
}
)
def _track_template(self, tracking):
res = super()._track_template(tracking)
first_rec = self[0]
changes, tracking_value_ids = tracking[first_rec.id]
if "substate_id" in changes and first_rec.substate_id.mail_template_id:
res["substate_id"] = (
first_rec.substate_id.mail_template_id,
{
"auto_delete_message": True,
"subtype_id": self.env["ir.model.data"].xmlid_to_res_id(
"mail.mt_note"
),
"notif_layout": "mail.mail_notification_light",
},
)
return res
def _get_default_substate_id(self, state_val=False):
"""Gives default substate_id"""
search_domain = self._get_default_substate_domain(state_val)
# perform search, return the first found
return (
self.env["base.substate"]
.search(search_domain, order="sequence", limit=1)
.id
)
def _get_default_substate_domain(self, state_val=False):
"""Override this method
to change domain values
"""
if not state_val:
state_val = self._get_default_state_value()
substate_type = self._get_substate_type()
state_field = substate_type.target_state_field
if self and not state_val and state_field in self._fields:
state_val = self[state_field]
domain = [("target_state_value_id.target_state_value", "=", state_val)]
domain += [
("target_state_value_id.base_substate_type_id", "=", substate_type.id)
]
return domain
def _get_default_state_value(
self,
):
"""Override this method
to change state_value
"""
return "draft"
def _get_substate_type(
self,
):
"""Override this method
to change substate_type (get by xml id for example)
"""
return self.env["base.substate.type"].search(
[("model", "=", self._name)], limit=1
)
substate_id = fields.Many2one(
"base.substate",
string="Sub State",
ondelete="restrict",
default=lambda self: self._get_default_substate_id(),
tracking=5,
index=True,
domain=lambda self: [("model", "=", self._name)],
copy=False,
)
@api.constrains("substate_id")
def check_substate_id_consistency(self):
for mixin_obj in self:
if mixin_obj.substate_id and mixin_obj.substate_id.model != self._name:
raise ValidationError(
_("This substate is not define for this object but for %s")
% mixin_obj.substate_id.model
)
def _update_before_write_create(self, values):
substate_type = self._get_substate_type()
state_field = substate_type.target_state_field
if values.get(state_field) and not values.get("substate_id"):
state_val = values.get(state_field)
values["substate_id"] = self._get_default_substate_id(state_val)
return values
def write(self, values):
values = self._update_before_write_create(values)
res = super().write(values)
return res
@api.model
def create(self, values):
values = self._update_before_write_create(values)
res = super().create(values)
return res
| 35.338462 | 4,594 |
3,356 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Akretion
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class BaseSubstateType(models.Model):
"""This model defines technical data which precises
for each target model concerned by substate,
the technical "state" field name.
Data in this model should be created by import as technical data
in the specific module. For example in sale_substate we can define:
base.substate.type:
- name: Sale order Substate
- model: sale.order
- target_state_field: state
"""
_name = "base.substate.type"
_description = "Base Substate Type"
_order = "name asc, model asc"
name = fields.Char(required=True, translate=True)
model = fields.Selection(selection=[], string="Apply on", required=True)
target_state_field = fields.Char(
required=True,
help="Technical target state field name."
' Ex for sale order "state" for other "status" ... ',
)
class TargetStateValue(models.Model):
"""This model define technical data that precise the translatable name
of the target model state (ex:Quotation for 'draft' State)
Data in this model should be created by import as technical data
in specific module ex : sale_subsatate
"""
_name = "target.state.value"
_description = "Target State Value"
_order = "name asc"
name = fields.Char(
"Target state Name",
required=True,
translate=True,
help="Target state translateble name.\n"
'Ex: for sale order "Quotation", "Sale order", "Locked"...',
)
base_substate_type_id = fields.Many2one(
"base.substate.type",
string="Substate Type",
ondelete="restrict",
)
target_state_value = fields.Char(
required=True,
help="Technical target state value.\n"
'Ex: for sale order "draft", "sale", "done", ...',
)
model = fields.Selection(
related="base_substate_type_id.model",
store=True,
readonly=True,
help="Model for technical use",
)
class BaseSubstate(models.Model):
"""This model define substates that will be applied on the target model.
for each state we can define one or more substate.
ex:
for the quotation state of a sale order we can define
3 substates "In negotiation",
"Won" and "Lost".
We can also send mail when the susbstate is reached.
"""
_name = "base.substate"
_description = "Base Substate"
_order = "active desc, sequence asc"
name = fields.Char("Substate Name", required=True, translate=True)
description = fields.Text(translate=True)
sequence = fields.Integer(
index=True,
help="Gives the sequence order when applying the default substate",
)
target_state_value_id = fields.Many2one(
"target.state.value", string="Target State Value", ondelete="restrict"
)
active = fields.Boolean(default=True)
mail_template_id = fields.Many2one(
"mail.template",
string="Email Template",
help="If set, an email will be sent to the partner "
"when the object reaches this substate.",
)
model = fields.Selection(
related="target_state_value_id.model",
store=True,
readonly=True,
help="Model for technical use",
)
| 32.582524 | 3,356 |
867 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Restrict records duplicating",
"summary": "Adds a security group to restrict which users can copy records",
"version": "15.0.1.0.1",
"development_status": "Beta",
"category": "Server tools",
"website": "https://github.com/OCA/server-ux",
"author": "Tecnativa, Odoo Community Association (OCA)",
"maintainers": ["chienandalu"],
"license": "AGPL-3",
"depends": ["web_tour"],
"data": ["security/base_duplicate_security_group_security.xml"],
"assets": {
"web.assets_backend": [
"/base_duplicate_security_group/static/src/js/duplicate.esm.js",
],
"web.assets_tests": [
"/base_duplicate_security_group/static/src/js/tour_duplicate.esm.js",
],
},
}
| 37.695652 | 867 |
685 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import HttpCase, tagged
@tagged("-at_install", "post_install")
class TestDuplicateSecurityGroup(HttpCase):
def test_duplicate_button(self):
"""Whether or not the duplicate button is available
The button should be accessible depending on the user permissions."""
self.start_tour("web", "button_duplicate_ok", login="admin")
group = self.env.ref("base_duplicate_security_group.group_duplicate_records")
group.users -= self.env.ref("base.user_admin")
self.start_tour("web", "button_duplicate_ko", login="admin")
| 48.928571 | 685 |
857 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Document Quick Access Folder Auto Classification",
"summary": """
Auto classification of Documents after reading a QR""",
"version": "15.0.1.1.0",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"depends": ["document_quick_access", "edi_storage_oca"],
"external_dependencies": {
"deb": ["libzbar0", "poppler-utils"],
"python": ["pyzbar", "pdf2image"],
},
"data": [
"data/edi_data.xml",
"security/security.xml",
"security/ir.model.access.csv",
"wizards/document_quick_access_missing_assign.xml",
"views/edi_exchange_record.xml",
],
"maintainers": ["etobella"],
}
| 34.28 | 857 |
9,791 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import os
import shutil
import uuid
from mock import patch
from odoo import tools
from odoo.tools import mute_logger
from odoo.addons.component.tests.common import TransactionComponentRegistryCase
class Encoded:
__slots__ = "data"
def __init__(self, data):
self.data = data
class TestDocumentQuickAccessClassification(TransactionComponentRegistryCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.env = cls.env(
context=dict(
cls.env.context, tracking_disable=True, test_queue_job_no_delay=True
)
)
self = cls
self.exchange_model = self.env["edi.exchange.record"]
self._setup_registry(self)
self._load_module_components(self, "component_event")
self._load_module_components(self, "edi")
self._load_module_components(self, "edi_storage")
self._load_module_components(
self, "document_quick_access_folder_auto_classification"
)
self.base_dir = os.path.join(self.env["ir.attachment"]._filestore(), "storage")
try:
os.mkdir(self.base_dir)
self.clean_base_dir = True
except FileExistsError:
# If the directory exists we respect it and do not clean it on teardown.
self.clean_base_dir = False
self.tmpdir = os.path.join(self.base_dir, str(uuid.uuid4()))
self.storage = self.env["storage.backend"].create(
{
"name": "Demo Storage",
"backend_type": "filesystem",
"directory_path": self.tmpdir,
}
)
self.backend = self.env["edi.backend"].create(
{
"name": "Demo Backend",
"backend_type_id": self.env.ref(
"document_quick_access_folder_auto_classification.backend_type"
).id,
"storage_id": self.storage.id,
"input_dir_pending": self.tmpdir,
}
)
os.mkdir(self.tmpdir)
self.model_id = self.env.ref("base.model_res_partner")
@classmethod
def tearDownClass(cls):
shutil.rmtree(cls.tmpdir)
if cls.clean_base_dir:
shutil.rmtree(cls.base_dir)
return super().tearDownClass()
def test_ok_pdf_multi(self):
partners = self.env["res.partner"].create({"name": "Partner 1"})
partners |= self.env["res.partner"].create({"name": "Partner 2"})
partners |= self.env["res.partner"].create({"name": "Partner 3"})
partners |= self.env["res.partner"].create({"name": "Partner 4"})
self.test_ok_pdf(partners)
@mute_logger("odoo.addons.queue_job.models.base")
def test_ok_pdf(self, partners=False):
"""Assign automatically PDFs to their assigned place"""
if not partners:
partners = self.env["res.partner"].create({"name": "Partner"})
file = tools.file_open(
"addons/document_quick_access_folder_auto_classification/tests/test_file.pdf",
mode="rb",
).read()
self.env["document.quick.access.rule"].create(
{
"model_id": self.model_id.id,
"name": "PARTNER",
"priority": 1,
"barcode_format": "standard",
}
)
with open(os.path.join(self.tmpdir, "test_file.pdf"), "wb") as f:
f.write(file)
code = [
Encoded(partner.get_quick_access_code().encode("utf-8"))
for partner in partners
]
with patch(
"odoo.addons.document_quick_access_folder_auto_classification."
"components.document_quick_access_process.decode"
) as ptch:
ptch.return_value = code
self.assertFalse(self.exchange_model.search([]))
self.backend._storage_cron_check_pending_input()
self.assertEqual(self.exchange_model.search_count([]), 1)
self.backend._cron_check_input_exchange_sync()
self.assertEqual(ptch.call_count, 1)
self.assertTrue(partners)
for partner in partners:
self.assertTrue(
self.env["ir.attachment"].search(
[("res_model", "=", partner._name), ("res_id", "=", partner.id)]
)
)
@mute_logger("odoo.addons.queue_job.models.base")
def test_no_ok_assign(self):
"""Assign failed files"""
file = tools.file_open(
"addons/document_quick_access_folder_auto_classification/tests/test_file.pdf",
mode="rb",
).read()
with open(os.path.join(self.tmpdir, "test_file.pdf"), "wb") as f:
f.write(file)
self.assertFalse(self.exchange_model.search([]))
self.backend._storage_cron_check_pending_input()
self.assertEqual(self.exchange_model.search_count([]), 1)
self.backend._cron_check_input_exchange_sync()
self.assertTrue(
self.exchange_model.search(
[
("backend_id", "=", self.backend.id),
("exchange_filename", "=", "test_file.pdf"),
("edi_exchange_state", "=", "input_processed_error"),
]
)
)
partner = self.env["res.partner"].create({"name": "Partner"})
missing = self.exchange_model.search(
[
("exchange_filename", "=", "test_file.pdf"),
("edi_exchange_state", "=", "input_processed_error"),
("backend_id", "=", self.backend.id),
]
)
self.assertTrue(missing)
action = missing.action_open_related_record()
self.assertFalse(action.keys())
self.env["document.quick.access.rule"].create(
{
"model_id": self.model_id.id,
"name": "PARTNER",
"priority": 1,
"barcode_format": "standard",
}
)
wizard = self.env["document.quick.access.missing.assign"].create(
{
"object_id": "{},{}".format(partner._name, partner.id),
"exchange_record_id": missing.id,
}
)
wizard.manually_assign()
self.assertEqual(missing.edi_exchange_state, "input_processed")
action = missing.action_open_related_record()
self.assertEqual(partner._name, action["res_model"])
self.assertEqual(partner.id, action["res_id"])
@mute_logger("odoo.addons.queue_job.models.base")
def test_failure(self):
"""We will check that if a major exception raises all is handled"""
file = tools.file_open(
"addons/document_quick_access_folder_auto_classification/tests/test_file.pdf",
mode="rb",
).read()
with open(os.path.join(self.tmpdir, "test_file.pdf"), "wb") as f:
f.write(file)
with self.assertRaises(TypeError):
with patch(
"odoo.addons.document_quick_access_folder_auto_classification."
"components.document_quick_access_process.decode"
) as ptch:
ptch.return_value = 1
self.backend._storage_cron_check_pending_input()
self.assertEqual(self.exchange_model.search_count([]), 1)
self.backend._cron_check_input_exchange_sync()
@mute_logger("odoo.addons.queue_job.models.base")
def test_no_ok_reject(self):
"""We will check that we can manage and reject failed files"""
file = tools.file_open(
"addons/document_quick_access_folder_auto_classification/tests/test_file.pdf",
mode="rb",
).read()
with open(os.path.join(self.tmpdir, "test_file.pdf"), "wb") as f:
f.write(file)
self.backend._storage_cron_check_pending_input()
self.assertEqual(self.exchange_model.search_count([]), 1)
self.backend._cron_check_input_exchange_sync()
missing = self.exchange_model.search(
[
("exchange_filename", "=", "test_file.pdf"),
("edi_exchange_state", "=", "input_processed_error"),
("backend_id", "=", self.backend.id),
]
)
self.assertTrue(missing)
missing.with_context(
document_quick_access_reject_file=True
).action_exchange_process()
missing.refresh()
self.assertEqual(missing.edi_exchange_state, "input_processed")
self.assertFalse(missing.model)
@mute_logger("odoo.addons.queue_job.models.base")
def test_corrupted(self):
"""We will check that corrupted files are stored also"""
file = tools.file_open(
"document_quick_access_folder_auto_classification/tests/test_file.pdf",
mode="rb",
).read()
with open(os.path.join(self.tmpdir, "test_file.pdf"), "wb") as f:
f.write(file[: int(len(file) / 2)])
with mute_logger(
"odoo.addons.document_quick_access_folder_auto_classification."
"components.document_quick_access_process",
):
self.backend._storage_cron_check_pending_input()
self.assertEqual(self.exchange_model.search_count([]), 1)
self.backend._cron_check_input_exchange_sync()
self.assertTrue(
self.exchange_model.search(
[
("backend_id", "=", self.backend.id),
("exchange_filename", "=", "test_file.pdf"),
("edi_exchange_state", "=", "input_processed_error"),
]
)
)
| 39.164 | 9,791 |
654 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import api, models
try:
from odoo.addons.queue_job.job import job
except ImportError:
job = lambda *args, **kwargs: lambda func: func # noqa: E731
_logger = logging.getLogger(__name__)
class DocumentQuickAccessRule(models.Model):
_inherit = "document.quick.access.rule"
@api.model
def read_code(self, code):
try:
return super().read_code(code)
except Exception:
if self.env.context.get("no_raise_document_access", False):
return False
raise
| 26.16 | 654 |
2,892 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Creu Blanca
# @author: Enric Tobella
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import base64
import logging
import traceback
from io import StringIO
from odoo import _
from odoo.exceptions import UserError
from odoo.addons.component.core import Component
_logger = logging.getLogger(__name__)
try:
from pyzbar.pyzbar import ZBarSymbol, decode
except (ImportError, IOError) as err:
_logger.warning(err)
try:
import pdf2image
from pdf2image.exceptions import (
PDFInfoNotInstalledError,
PDFPageCountError,
PDFSyntaxError,
)
except (ImportError, IOError) as err:
_logger.warning(err)
class EdiDocumentQuickAccessProcess(Component):
_name = "edi.input.process.document.quick.access"
_usage = "input.process"
_backend_type = "document_quick_access"
_exchange_type = "document_quick_access"
_inherit = "edi.component.input.mixin"
def process(self):
data = self.exchange_record.exchange_file
records = self._search_document_pdf(data)
for record in records:
self.env["ir.attachment"].create(self._get_attachment_vals(record))
if records:
record = records[0]
self.exchange_record.write({"res_id": record.id, "model": record._name})
elif self.env.context.get("document_quick_access_reject_file"):
return
else:
raise UserError(_("No file found"))
def _get_attachment_vals(self, record):
return {
"name": self.exchange_record.exchange_filename,
"datas": self.exchange_record.exchange_file,
"res_id": record.id,
"res_model": record._name,
}
def _search_document_pdf(self, datas):
if self.env.context.get("document_quick_access_reject_file"):
return []
if self.env.context.get("force_object_process"):
return [self.env.context["force_object_process"]]
records = []
try:
images = pdf2image.convert_from_bytes(base64.b64decode(datas))
except (PDFInfoNotInstalledError, PDFPageCountError, PDFSyntaxError) as e:
buff = StringIO()
traceback.print_exc(file=buff)
_logger.warning(buff.getvalue())
raise UserError(str(e)) from e
for im in images:
records += self._search_pil_image(im)
return records
def _search_pil_image(self, image):
results = decode(image, symbols=[ZBarSymbol.QRCODE])
records = []
rule_obj = self.env["document.quick.access.rule"]
for result in results:
record = rule_obj.with_context(no_raise_document_access=True).read_code(
result.data.decode("utf-8")
)
if record and record not in records:
records += record
return records
| 33.241379 | 2,892 |
997 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class DocumentQuickAccessMissingAssign(models.TransientModel):
_name = "document.quick.access.missing.assign"
_description = "document.quick.access.missing.assign"
@api.model
def document_quick_access_models(self):
models = self.env["document.quick.access.rule"].search([]).mapped("model_id")
res = []
for model in models:
res.append((model.model, model.name))
return res
object_id = fields.Reference(
selection=lambda r: r.document_quick_access_models(), required=True
)
exchange_record_id = fields.Many2one("edi.exchange.record", required=True)
def manually_assign(self):
self.ensure_one()
self.exchange_record_id.backend_id.with_context(
force_object_process=self.object_id
).exchange_process(self.exchange_record_id)
return True
| 34.37931 | 997 |
1,085 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Anubía, soluciones en la nube,SL (http://www.anubia.es)
# Copyright 2017 Onestein (http://www.onestein.eu)
# Copyright (C) 2019-Today: Druidoo (<https://www.druidoo.io>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Optional CSV import",
"version": "15.0.1.0.1",
"category": "Server tools",
"summary": "Group-based permissions for importing CSV files",
"license": "AGPL-3",
"author": "Odoo Community Association (OCA), "
"Alejandro Santana <[email protected]>, "
"Onestein",
"maintainer": "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"depends": [
"web",
"web_tour",
"base_import",
],
"data": [
"security/base_import_security_group_security.xml",
],
"assets": {
"web.assets_backend": ["base_import_security_group/static/src/js/import.js"],
"web.assets_tests": [
"base_import_security_group/static/src/js/tour_import.js",
],
},
"installable": True,
}
| 33.875 | 1,084 |
2,471 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Onestein (http://www.onestein.eu)
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests import common, tagged
from odoo.tools import mute_logger
@tagged("-at_install", "post_install")
class TestImportSecurityGroup(common.HttpCase):
def setUp(self):
super().setUp()
self.Access = self.env["ir.model.access"]
self.user_test = self.env.ref("base.user_demo")
self.user_admin = self.env.ref("base.user_admin")
self.fields = (
"id",
"name",
"perm_read",
"perm_write",
"perm_create",
"perm_unlink",
)
self.data = [
("access_res_users_test", "res.users test", "1", "0", "0", "0"),
("access_res_users_test2", "res.users test2", "1", "1", "1", "1"),
]
def test_import_button(self):
"""Whether or not the import button is available depending on permissions"""
self.start_tour("/web", "button_import_ok", login="admin")
group = self.env.ref("base_import_security_group.group_import_csv")
group.users -= self.user_admin
self.start_tour("/web", "button_import_ko", login="admin")
def test_access_admin(self):
"""Admin user can import data"""
with mute_logger("odoo.sql_db"):
res = self.Access.with_user(self.user_admin).load(self.fields, self.data)
self.assertEqual(res["ids"], False)
self.assertEqual(len(res["messages"]), 2)
self.assertEqual(
res["messages"][0]["message"],
"Missing required value for the field 'Model' (model_id)",
)
self.assertEqual(
res["messages"][1]["message"],
"Missing required value for the field 'Model' (model_id)",
)
def test_access_demo(self):
"""Demo user cannot import data"""
self.user_test.write({"groups_id": [(4, self.ref("base.group_system"))]})
self.start_tour("/web", "button_import_ko", login="demo")
res2 = self.Access.with_user(self.user_test).load(self.fields, self.data)
self.assertEqual(res2["ids"], None)
self.assertEqual(len(res2["messages"]), 1)
self.assertEqual(
res2["messages"][0]["message"],
"User (ID: %s) is not allowed to import data in "
"model ir.model.access." % self.user_test.id,
)
| 39.190476 | 2,469 |
757 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Opener B.V. <[email protected]>
# Copyright 2017 Antonio Esposito <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
from odoo.http import request
class Http(models.AbstractModel):
_inherit = "ir.http"
def session_info(self):
"""Expose in the env whether the user is allowed to import records"""
res = super().session_info()
allowed_group = "base_import_security_group.group_import_csv"
allowed_group_id = request.env.ref(allowed_group, raise_if_not_found=False)
if not allowed_group_id or request.env.user.has_group(allowed_group):
res["base_import_security_group__allow_import"] = 1
return res
| 42.055556 | 757 |
1,334 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Anubía, soluciones en la nube,SL (http://www.anubia.es)
# Copyright 2017 Onestein (http://www.onestein.eu)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from odoo import api, models
_logger = logging.getLogger(__name__)
class Base(models.AbstractModel):
_inherit = "base"
@api.model
def load(self, fields, data):
"""Overriding this method we only allow its execution
if current user belongs to the group allowed for CSV data import.
An exception is raised otherwise, and also log the import attempt.
"""
current_user = self.env.user
allowed_group = "base_import_security_group.group_import_csv"
allowed_group_id = self.env.ref(allowed_group, raise_if_not_found=False)
if not allowed_group_id or current_user.has_group(allowed_group):
res = super().load(fields=fields, data=data)
else:
msg = ("User (ID: %s) is not allowed to import data " "in model %s.") % (
self.env.uid,
self._name,
)
_logger.info(msg)
messages = []
info = {}
messages.append(dict(info, type="error", message=msg, moreinfo=None))
res = {"ids": None, "messages": messages}
return res
| 37.027778 | 1,333 |
785 |
py
|
PYTHON
|
15.0
|
from odoo import SUPERUSER_ID, api
def post_init_hook(cr, registry):
"""
Set deprecated value for all existing fields
"""
env = api.Environment(cr, SUPERUSER_ID, {})
model_obj = env["ir.model"]
field_obj = env["ir.model.fields"]
for model in model_obj.search([]):
all_fields = model._fields.items()
for field_name, field in all_fields:
# Only assign for deprecated fields to avoid too many useless searches
to_assign = bool(field.deprecated)
if to_assign:
odoo_field = field_obj.search(
[("name", "=", field_name), ("model", "=", model._name)], limit=1
)
if odoo_field:
odoo_field.write({"deprecated": to_assign})
| 35.681818 | 785 |
646 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Base Field Deprecated",
"summary": "Adds the deprecated attribute to the Odoo field model.",
"version": "15.0.1.0.0",
"category": "Usability",
"license": "AGPL-3",
"website": "https://github.com/OCA/server-ux",
"author": "ForgeFlow, Odoo Community Association (OCA)",
"depends": ["base"],
"data": ["views/ir_model_fields_views.xml"],
"maintainers": ["GuillemCForgeFlow"],
"installable": True,
"application": False,
"post_init_hook": "post_init_hook",
}
| 38 | 646 |
378 |
py
|
PYTHON
|
15.0
|
from odoo import fields, models
class IrModelFields(models.Model):
_inherit = "ir.model.fields"
deprecated = fields.Boolean(help="Whether the field is deprecated or not.")
def _reflect_field_params(self, field, model_id):
result = super()._reflect_field_params(field, model_id)
result["deprecated"] = bool(field.deprecated)
return result
| 31.5 | 378 |
544 |
py
|
PYTHON
|
15.0
|
# Copyright 2013 Agile Business Group sagl (<http://www.agilebg.com>)
# Copyright 2016 ACSONE SA/NV (<https://acsone.eu>)
{
"name": "Optional quick create",
"version": "15.0.1.0.0",
"category": "Tools",
"summary": 'Avoid "quick create" on m2o fields, on a "by model" basis',
"author": "Agile Business Group,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"depends": ["base"],
"data": [
"views/model_view.xml",
],
"installable": True,
}
| 32 | 544 |
1,716 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Simone Rubino - Agile Business Group
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase
class TestQuickCreate(TransactionCase):
def setUp(self, *args, **kwargs):
super().setUp()
model_model = self.env["ir.model"]
self.partner_model = model_model.search([("model", "=", "res.partner")])
def test_quick_create(self):
partner_id = self.env["res.partner"].name_create("TEST partner")
self.assertEqual(bool(partner_id), True)
# Setting the flag, patches the method
self.partner_model.avoid_quick_create = True
with self.assertRaises(UserError):
self.env["res.partner"].name_create("TEST partner")
# Unsetting the flag, unpatches the method
self.partner_model.avoid_quick_create = False
partner_id = self.env["res.partner"].name_create("TEST partner")
self.assertEqual(bool(partner_id), True)
# New Model
# Setting the flag, patches the method
self.env["ir.model"].create(
{"name": "Test Model", "model": "x_.test.model", "avoid_quick_create": True}
)
with self.assertRaises(UserError):
self.env["x_.test.model"].name_create("TEST Model")
# Unsetting the flag, unpatches the method
self.env["ir.model"].create(
{
"name": "Test Model",
"model": "x_.test.model.quick",
"avoid_quick_create": False,
}
)
test_id = self.env["x_.test.model.quick"].name_create("TEST Model")
self.assertEqual(bool(test_id), True)
| 37.304348 | 1,716 |
1,963 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (https://acsone.eu)
# Copyright 2016 Akretion (Alexis de Lattre [email protected])
# Copyright 2018 Simone Rubino - Agile Business Group
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError
class IrModel(models.Model):
_inherit = "ir.model"
avoid_quick_create = fields.Boolean()
def _patch_quick_create(self):
def _wrap_name_create():
@api.model
def wrapper(self, name):
raise UserError(
_(
"Can't create %(model)s with name %(name)s quickly.\n"
"Please contact your system administrator to disable "
"this behaviour."
)
% {"model": self._name, "name": name}
)
return wrapper
method_name = "name_create"
for model in self:
model_obj = self.env.get(model.model)
if model.avoid_quick_create and model_obj is not None:
model_obj._patch_method(method_name, _wrap_name_create())
else:
method = getattr(model_obj, method_name, None)
if method and hasattr(method, "origin"):
model_obj._revert_method(method_name)
return True
def _register_hook(self):
models = self.search([])
models._patch_quick_create()
return super()._register_hook()
@api.model_create_multi
def create(self, vals_list):
ir_models = super().create(vals_list)
ir_models._patch_quick_create()
return ir_models
def write(self, vals):
res = super().write(vals)
self._patch_quick_create()
if "avoid_quick_create" in vals:
self.pool.registry_invalidated = True
self.pool.signal_changes()
return res
| 33.844828 | 1,963 |
586 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Base Archive Date",
"summary": """
Adds an archive timestamp and user doing the archiving to all models.
""",
"version": "15.0.1.0.0",
"category": "Usability",
"license": "AGPL-3",
"website": "https://github.com/OCA/server-ux",
"author": "ForgeFlow, Odoo Community Association (OCA)",
"depends": ["base"],
"maintainers": ["GuillemCForgeFlow"],
"installable": True,
"application": False,
}
| 34.470588 | 586 |
1,139 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields
from odoo.tests.common import TransactionCase
class TestBaseArchiveDate(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
# Models
cls.partner_model = cls.env["res.partner"]
# Instances
cls.partner = cls.partner_model.create({"name": "Test Partner"})
def test_01_archive_partner_timestamp(self):
"""
Check that the technical field exists and check for the timestamp once the
partner is archived.
"""
self.assertTrue(self.partner.active)
self.assertTrue("archive_date" in self.partner._fields)
self.partner.toggle_active()
now = fields.Datetime.context_timestamp(
self.partner, fields.Datetime.now()
).replace(tzinfo=None)
self.assertEqual(
self.partner.archive_date, now, "Archive Date should be equal to now."
)
| 34.515152 | 1,139 |
2,557 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 ForgeFlow S.L. (https://www.forgeflow.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
LOG_ARCHIVE_DATE = "archive_date"
LOG_ARCHIVE_UID = "archive_uid"
class Base(models.AbstractModel):
"""
The base model is inherited by all models.
Whenever a record has the active field, we save the latest date in which the record
has been archived, False otherwise. We also save which user did the archiving.
"""
_inherit = "base"
@api.model
def _get_now_date(self):
"""
:return: datetime.datetime: actual time formated in the way Odoo saves dates
for base fields, such as write_date or create_date
"""
now = fields.Datetime.context_timestamp(self, fields.Datetime.now())
return now.replace(tzinfo=None)
@api.model
def _setup_base(self):
result = super(Base, self)._setup_base()
if self._log_access and "active" in self._fields:
self._add_field(
LOG_ARCHIVE_DATE,
fields.Datetime(
string="Last Archived on", automatic=True, readonly=True
),
)
self._add_field(
LOG_ARCHIVE_UID,
fields.Many2one(
comodel_name="res.users",
string="Last Archived by",
automatic=True,
readonly=True,
),
)
return result
@api.model_create_multi
@api.returns("self", lambda value: value.id)
def create(self, vals_list):
if self._log_access:
for vals in vals_list:
if "active" in vals:
archive_date = (
False if vals.get("active", False) else self._get_now_date()
)
archive_uid = self.env.user.id if archive_date else False
vals.update(
{LOG_ARCHIVE_DATE: archive_date, LOG_ARCHIVE_UID: archive_uid}
)
return super(Base, self).create(vals_list)
def write(self, vals):
if (
self._log_access
and LOG_ARCHIVE_DATE not in vals
and "active" in vals
and not vals.get("active", True)
):
now = self._get_now_date()
user_id = self.env.user.id
vals.update({LOG_ARCHIVE_DATE: now, LOG_ARCHIVE_UID: user_id})
return super(Base, self).write(vals)
| 34.554054 | 2,557 |
727 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Jairo Llopis <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import SUPERUSER_ID, api
def post_init_hook(cr, registry):
"""Loaded after installing the module.
``ir.exports.line.name`` was before a char field, and now it is a computed
char field with stored values. We have to inverse it to avoid database
inconsistencies.
"""
with api.Environment.manage():
env = api.Environment(cr, SUPERUSER_ID, {})
env["ir.exports.line"].search(
[
("field1_id", "=", False),
("export_id", "!=", False),
("name", "!=", False),
]
)._inverse_name()
| 34.619048 | 727 |
1,057 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Pedro M. Baeza
# Copyright 2018 Tecnativa - Jairo Llopis
# Copyright 2019 brain-tec AG - Olivier Jossen
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Manage model export profiles",
"category": "Personalization",
"version": "15.0.1.0.1",
"depends": ["web"],
"data": [
"views/ir_exports.xml",
"views/ir_model.xml",
"views/ir_model_access.xml",
"views/res_groups.xml",
],
"qweb": ["static/src/xml/base.xml"],
"author": "Tecnativa, "
"LasLabs, "
"Ursa Information Systems, "
"brain-tec AG, "
"Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"assets": {
"web.assets_backend": [
"base_export_manager/static/src/js/base_export_manager.js",
],
"web.assets_qweb": ["base_export_manager/static/src/xml/base.xml"],
},
"installable": True,
"application": False,
}
| 31.088235 | 1,057 |
3,543 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antiun Ingenieria S.L. - Javier Iniesta
# Copyright 2016 Pedro M. Baeza <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
class TestIrExportsLineCase(TransactionCase):
def setUp(self):
super(TestIrExportsLineCase, self).setUp()
m_ir_exports = self.env["ir.exports"]
self.export = m_ir_exports.create(
{"name": "Partner Test", "resource": "res.partner"}
)
self.partner_model = self.env["ir.model"].search(
[("model", "=", "res.partner")]
)
self.field_parent_id = self.env["ir.model.fields"].search(
[("name", "=", "parent_id"), ("model_id", "=", self.partner_model.id)]
)
self.field_name = self.env["ir.model.fields"].search(
[("name", "=", "name"), ("model_id", "=", self.partner_model.id)]
)
def _record_create(self, field_name):
m_ir_exports_line = self.env["ir.exports.line"]
virt_line = m_ir_exports_line.new(
{"name": field_name, "export_id": self.export.id}
)
virt_line._inverse_name()
return m_ir_exports_line.create(virt_line._convert_to_write(virt_line._cache))
def test_check_name(self):
self._record_create("name")
with self.assertRaises(ValidationError):
self._record_create("name")
with self.assertRaises(ValidationError):
self._record_create("bad_error_name")
def test_get_label_string(self):
export_line = self._record_create("parent_id/name")
self.assertEqual(
export_line.with_context(lang="en_US").label,
"Related Company/Name (parent_id/name)",
)
with self.assertRaises(ValidationError):
self._record_create("")
def test_model_default_by_context(self):
"""Fields inherit the model_id by context."""
m_ir_exports_line = self.env["ir.exports.line"]
virt_line = m_ir_exports_line.new({"name": "name", "export_id": self.export.id})
virt_line._inverse_name()
line = m_ir_exports_line.with_context(
default_model1_id=self.export.model_id.id
).create(virt_line._convert_to_write(virt_line._cache))
self.assertEqual(line.model1_id, self.export.model_id)
def test_inverse_name(self):
line = self._record_create("parent_id/parent_id/parent_id/name")
self.assertEqual(line.model1_id, self.partner_model)
self.assertEqual(line.model2_id, self.partner_model)
self.assertEqual(line.field1_id, self.field_parent_id)
self.assertEqual(line.field2_id, self.field_parent_id)
self.assertEqual(line.field3_id, self.field_parent_id)
self.assertEqual(line.field4_id, self.field_name)
def test_compute_name(self):
line = self.env["ir.exports.line"].create(
{
"export_id": self.export.id,
"field1_id": self.field_parent_id.id,
"field2_id": self.field_parent_id.id,
"field3_id": self.field_parent_id.id,
"field4_id": self.field_name.id,
}
)
self.assertEqual(line.name, "parent_id/parent_id/parent_id/name")
def test_write_name_same_root(self):
self._record_create("parent_id")
line = self._record_create("name")
# This should end without errors
line.name = "parent_id/name"
| 41.682353 | 3,543 |
1,873 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2018 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
class TestIrExportsCase(TransactionCase):
def test_create_with_basic_data(self):
"""Emulate creation from original form.
This form is handled entirely client-side, and lacks some required
field values.
"""
# Emulate creation from JsonRpc, without model_id and field#_id
data = {
"name": "Test éxport",
"resource": "ir.exports",
"export_fields": [
[0, 0, {"name": "export_fields"}],
[0, 0, {"name": "export_fields/create_uid"}],
[0, 0, {"name": "export_fields/create_date"}],
[0, 0, {"name": "export_fields/field1_id"}],
],
}
virt_record = self.env["ir.exports"].new(data)
virt_record.export_fields._inverse_name()
record = self.env["ir.exports"].create(
virt_record._convert_to_write(virt_record._cache)
)
self.assertEqual(record.model_id.model, data["resource"])
def test_create_without_model(self):
"""Creating a record without ``model_id`` and ``resource`` fails."""
IrExports = self.env["ir.exports"]
model = self.env["ir.model"]._get("res.partner")
# Creating with resource
record = IrExports.create({"name": "some", "resource": model.model})
self.assertEqual(record.model_id, model)
# Creating with model_id
record = IrExports.create({"name": "some", "model_id": model.id})
self.assertEqual(record.resource, model.model)
# Creating without anyone
with self.assertRaises(ValidationError):
IrExports.create({"name": "some"})
| 38.204082 | 1,872 |
716 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 brain-tec AG - Olivier Jossen
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
from odoo.http import request
class Http(models.AbstractModel):
_inherit = "ir.http"
def session_info(self):
"""
Odoo implementation doesn't allow add more access types, so we
send all models where the user has the 'export' access over the
session dictionary.
TODO: Use other way to don't send all this data every time.
"""
res = super().session_info()
user = request.env.user
export_models = user.fetch_export_models()
res.update({"export_models": export_models})
return res
| 32.545455 | 716 |
1,793 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2016 Jairo Llopis <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class IrExports(models.Model):
_inherit = "ir.exports"
name = fields.Char(required=True)
resource = fields.Char(readonly=True, help="Model's technical name.")
model_id = fields.Many2one(
"ir.model",
"Model",
store=True,
inverse="_inverse_model_id",
compute="_compute_model_id",
domain=[("transient", "=", False)],
help="Database model to export.",
)
@api.onchange("resource")
def _onchange_resource(self):
self.ensure_one()
self.export_fields = [(5, 0, 0)]
@api.depends("model_id")
def _inverse_model_id(self):
"""Gets resource from model"""
for record in self:
record.resource = self.model_id.model
@api.depends("resource")
def _compute_model_id(self):
"""Gets resource from model"""
IrModel = self.env["ir.model"]
for record in self:
record.model_id = IrModel._get(record.resource)
@api.model_create_multi
def create(self, vals_list):
"""Check required values when creating the record.
Odoo's export dialog populates ``resource``, while this module's new
form populates ``model_id``. At least one of them is required to
trigger the methods that fill up the other, so this should fail if
one is missing.
"""
for vals in vals_list:
if not any(f in vals for f in ("model_id", "resource")):
raise ValidationError(_("You must supply a model or resource."))
return super().create(vals_list)
| 33.830189 | 1,793 |
7,779 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antiun Ingeniería S.L. - Antonio Espinosa
# Copyright 2015-2016 Jairo Llopis <[email protected]>
# Copyright 2019 brain-tec AG - Olivier Jossen
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, exceptions, fields, models
class IrExportsLine(models.Model):
_inherit = "ir.exports.line"
_order = "sequence,id"
name = fields.Char(
store=True,
compute="_compute_name",
inverse="_inverse_name",
help="Field's technical name.",
)
field1_id = fields.Many2one(
"ir.model.fields", "First field", domain="[('model_id', '=', model1_id)]"
)
field2_id = fields.Many2one(
"ir.model.fields", "Second field", domain="[('model_id', '=', model2_id)]"
)
field3_id = fields.Many2one(
"ir.model.fields", "Third field", domain="[('model_id', '=', model3_id)]"
)
field4_id = fields.Many2one(
"ir.model.fields", "Fourth field", domain="[('model_id', '=', model4_id)]"
)
model1_id = fields.Many2one(
"ir.model",
"First model",
readonly=True,
related="export_id.model_id",
)
model2_id = fields.Many2one(
"ir.model", "Second model", compute="_compute_model2_id"
)
model3_id = fields.Many2one("ir.model", "Third model", compute="_compute_model3_id")
model4_id = fields.Many2one(
"ir.model", "Fourth model", compute="_compute_model4_id"
)
sequence = fields.Integer()
label = fields.Char(compute="_compute_label")
@api.depends("field1_id", "field2_id", "field3_id", "field4_id")
def _compute_name(self):
"""Get the name from the selected fields."""
for one in self:
name = "/".join(
one.field_n(num).name for num in range(1, 5) if one.field_n(num)
)
if name != one.name:
one.name = name
@api.depends("field1_id")
def _compute_model2_id(self):
"""Get the related model for the second field."""
IrModel = self.env["ir.model"]
for one in self:
one.model2_id = (
one.field1_id.ttype
and "2" in one.field1_id.ttype
and IrModel.search([("model", "=", one.field1_id.relation)])
)
@api.depends("field2_id")
def _compute_model3_id(self):
"""Get the related model for the third field."""
IrModel = self.env["ir.model"]
for one in self:
one.model3_id = (
one.field2_id.ttype
and "2" in one.field2_id.ttype
and IrModel.search([("model", "=", one.field2_id.relation)])
)
@api.depends("field3_id")
def _compute_model4_id(self):
"""Get the related model for the third field."""
IrModel = self.env["ir.model"]
for one in self:
one.model4_id = (
one.field3_id.ttype
and "2" in one.field3_id.ttype
and IrModel.search([("model", "=", one.field3_id.relation)])
)
@api.depends("name")
def _compute_label(self):
"""Column label in a user-friendly format and language."""
for one in self:
parts = list()
for num in range(1, 5):
field = one.field_n(num)
if not field:
break
# Translate label if possible
try:
parts.append(
one.env[one.model_n(num).model]
._fields[field.name]
.get_description(one.env)["string"]
)
except KeyError:
# No human-readable string available, so empty this
parts = []
break
one.label = (
"{} ({})".format("/".join(parts), one.name)
if parts and one.name
else False
)
def _inverse_name(self):
"""Get the fields from the name."""
for one in self:
# Field names can have up to only 4 indentation levels
parts = (one.name or "").split("/")
if len(parts) > 4:
raise exceptions.ValidationError(
_("It's not allowed to have more than 4 levels depth: %s")
% one.name
)
for num in range(1, 5):
if not any(parts) or num > len(parts):
# Empty subfield in this case
# You could get to failing constraint while populating the
# fields, so we skip the uniqueness check and manually
# check the full constraint after the loop
one.with_context(skip_check=True)[one.field_n(num, True)] = False
continue
field_name = parts[num - 1]
model = one.model_n(num)
# You could get to failing constraint while populating the
# fields, so we skip the uniqueness check and manually check
# the full constraint after the loop
one.with_context(skip_check=True)[
one.field_n(num, True)
] = one._get_field_id(model, field_name)
if any(parts):
# invalidate_cache -> in order to get actual value of field 'label'
# in function '_check_name'
self.invalidate_cache(ids=one.ids)
one._check_name()
@api.constrains("field1_id", "field2_id", "field3_id", "field4_id")
def _check_name(self):
# do also skip the check if label is set or not, when skip_check is set
if self._context.get("skip_check"):
return
for one in self:
if not one.label:
raise exceptions.ValidationError(
_("Field '%s' does not exist") % one.name
)
num_lines = one.search_count(
[("export_id", "=", one.export_id.id), ("name", "=", one.name)]
)
if num_lines > 1:
raise exceptions.ValidationError(
_("Field '%s' already exists") % one.name
)
@api.model
def _get_field_id(self, model, name):
"""Get a field object from its model and name.
:param int model:
``ir.model`` object that contains the field.
:param str name:
Technical name of the field, like ``child_ids``.
"""
field = self.env["ir.model.fields"].search(
[("name", "=", name), ("model_id", "=", model.id)]
)
if not field.exists():
raise exceptions.ValidationError(
_("Field '%(name)s' not found in model '%(model)s'")
% {"name": name, "model": model.model}
)
return field
def field_n(self, n, only_name=False):
"""Helper to choose the field according to its indentation level.
:param int n:
Number of the indentation level to choose the field, from 1 to 3.
:param bool only_name:
Return only the field name, or return its value.
"""
name = "field%d_id" % n
return name if only_name else self[name]
def model_n(self, n, only_name=False):
"""Helper to choose the model according to its indentation level.
:param int n:
Number of the indentation level to choose the model, from 1 to 3.
:param bool only_name:
Return only the model name, or return its value.
"""
name = "model%d_id" % n
return name if only_name else self[name]
| 37.394231 | 7,778 |
689 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 - Ursa Information Systems <http://ursainfosystems.com>
# Copyright 2019 brain-tec AG - Olivier Jossen
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
from odoo import api, models
class ResUsers(models.Model):
_inherit = "res.users"
@api.model
def fetch_export_models(self):
"""Gets all models where the user has export access."""
accessobj = self.env["ir.model.access"]
accessobj_ids = accessobj.search(
[("perm_export", "=", True), ("group_id", "in", self.groups_id.ids)]
)
model_names = [access_obj.model_id.model for access_obj in accessobj_ids]
return list(set(model_names))
| 34.45 | 689 |
490 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 - Ursa Information Systems <http://ursainfosystems.com>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
from odoo import fields, models
class IrModelAccess(models.Model):
_inherit = "ir.model.access"
# WARN: This can't be used in 'check()'
# See https://github.com/odoo/odoo/blob/0b6a2569920b6584652c39b3465998649fe305b4/odoo/addons/base/models/ir_model.py#L1496 # noqa: B950
perm_export = fields.Boolean("Export Access", default=True)
| 37.692308 | 490 |
663 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Carlos Dauden
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Add custom filters for fields via UI",
"version": "15.0.1.0.0",
"category": "Usability",
"website": "https://github.com/OCA/server-ux",
"author": "Tecnativa, Odoo Community Association (OCA)",
"demo": ["demo/demo_ir_ui_custom_field_filter.xml"],
"data": [
"security/ir.model.access.csv",
"views/ir_ui_custom_field_filter_views.xml",
],
"depends": ["web"],
"license": "AGPL-3",
"installable": True,
"maintainers": ["pedrobaeza"],
}
| 34.894737 | 663 |
1,552 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Carlos Dauden
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import _, api, exceptions, fields, models
class IrUiCustomFilter(models.Model):
_name = "ir.ui.custom.field.filter"
_description = "Custom UI field filter"
_order = "model_id, sequence, id"
sequence = fields.Integer()
model_id = fields.Many2one(
comodel_name="ir.model", required=True, ondelete="cascade"
)
model_name = fields.Char(
related="model_id.model",
store=True,
readonly=True,
index=True,
string="Model name",
)
name = fields.Char(required=True, translate=True)
expression = fields.Char(required=True)
position_after = fields.Char(
help="Optional field name for putting the filter after that one. "
"If empty or not found, it will be put at the end.",
)
def _get_related_field(self):
"""Determine the chain of fields."""
self.ensure_one()
related = self.expression.split(".")
target = self.env[self.model_name]
for name in related:
field = target._fields[name]
target = target[name]
return field
@api.constrains("model_id", "expression")
def _check_expression(self):
for record in self:
try:
record._get_related_field()
except KeyError as e:
raise exceptions.ValidationError(_("Incorrect expression.")) from e
| 33.021277 | 1,552 |
2,535 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Carlos Dauden
# Copyright 2020 Tecnativa - Pedro M. Baeza
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://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_custom_filters(self, res, custom_filters):
arch = etree.fromstring(res["arch"])
for custom_filter in custom_filters:
node = False
if custom_filter.position_after:
node = arch.xpath("//field[@name='%s']" % custom_filter.position_after)
if not node:
node = arch.xpath("//field[last()]")
if node:
elem = etree.Element(
"field",
{"name": custom_filter.expression, "string": custom_filter.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
):
"""Inject fields field in search views."""
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "search":
custom_filters = self.env["ir.ui.custom.field.filter"].search(
[("model_name", "=", res.get("model"))]
)
if custom_filters:
res = self._add_custom_filters(res, custom_filters)
return res
@api.model
def load_views(self, views, options=None):
"""Inject fake field definition for having custom filters available."""
res = super(
Base,
self.with_context(
custom_field_filter=True,
),
).load_views(views, options=options)
custom_filters = self.env["ir.ui.custom.field.filter"].search(
[("model_name", "=", self._name)]
)
for custom_filter in custom_filters:
field = custom_filter._get_related_field()
field_name = custom_filter.expression
res["fields"][field_name] = field.get_description(self.env)
# force this for avoiding to appear on the rest of the UI
res["fields"][field_name]["selectable"] = False
res["fields"][field_name]["sortable"] = False
res["fields"][field_name]["store"] = False
return res
| 37.25 | 2,533 |
479 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Base Tier Validation Formula",
"summary": """
Formulas for Base tier validation""",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-ux",
"depends": ["base_tier_validation"],
"data": ["views/tier_definition_view.xml"],
"demo": [],
}
| 31.933333 | 479 |
6,205 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow S.L.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo_test_helper import FakeModelLoader
from odoo.exceptions import UserError
from odoo.tests import common
from odoo.tests.common import tagged
@tagged("post_install", "-at_install")
class TierTierValidation(common.TransactionCase):
@classmethod
def setUpClass(cls):
super(TierTierValidation, cls).setUpClass()
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from odoo.addons.base_tier_validation.tests.tier_validation_tester import (
TierValidationTester,
)
cls.loader.update_registry((TierValidationTester,))
cls.test_model = cls.env[TierValidationTester._name]
cls.tester_model = cls.env["ir.model"].search(
[("model", "=", "tier.validation.tester")]
)
# 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,
}
)
# 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"}
)
cls.test_user_3 = cls.env["res.users"].create(
{"name": "Mary", "login": "test3"}
)
# 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)]",
}
)
cls.test_record = cls.test_model.create({"test_field": 2.5})
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
return super(TierTierValidation, cls).tearDownClass()
def test_01_reviewer_from_python_expression(self):
tier_definition = self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_type": "formula",
"python_code": "rec.test_field > 1.0",
}
)
tier_definition.write(
{
"model_id": self.tester_model.id,
"review_type": "expression",
"python_code": "rec.test_field > 3.0",
}
)
tier_definition.onchange_review_type()
tier_definition.write({"reviewer_expression": "rec.user_id"})
self.test_record.write({"test_field": 3.5, "user_id": self.test_user_2.id})
reviews = self.test_record.with_user(self.test_user_3.id).request_validation()
self.assertTrue(reviews)
self.assertEqual(len(reviews), 2)
record = self.test_record.with_user(self.test_user_1.id)
self.test_record.invalidate_cache()
record.invalidate_cache()
self.assertIn(self.test_user_1, record.reviewer_ids)
self.assertIn(self.test_user_2, record.reviewer_ids)
res = self.test_model.search([("reviewer_ids", "in", self.test_user_2.id)])
self.assertTrue(res)
def test_02_wrong_reviewer_expression(self):
"""Error should raise with incorrect python expresions on
tier definitions."""
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "expression",
"reviewer_expression": "rec.test_field",
"python_code": "rec.test_field > 1.0",
}
)
with self.assertRaises(UserError):
self.test_record.with_user(self.test_user_3).request_validation()
self.test_record.review_ids.invalidate_cache()
self.test_record.review_ids._compute_python_reviewer_ids()
def test_03_evaluate_wrong_reviewer_expression(self):
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "expression",
"reviewer_expression": "raise Exception",
"python_code": "rec.test_field > 1.0",
}
)
with self.assertRaises(UserError):
self.test_record.with_user(self.test_user_3).request_validation()
self.test_record.review_ids.invalidate_cache()
self.test_record.review_ids._compute_python_reviewer_ids()
def test_04_evaluate_wrong_python_formula_expression(self):
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": "expression",
"reviewer_expression": "raise Exception",
"python_code": "raise Exception",
}
)
# Request validation
with self.assertRaises(UserError):
review = test_record.with_user(self.test_user_2).request_validation()
self.test_record.evaluate_formula_tier(review)
def test_05_definition_from_domain_formula(self):
self.tier_def_obj.create(
{
"model_id": self.tester_model.id,
"review_type": "individual",
"reviewer_id": self.test_user_1.id,
"definition_type": "domain_formula",
"definition_domain": '[("test_field", "<", 5.0)]',
"python_code": "rec.test_field > 1.0",
}
)
self.test_record.write({"test_field": 3.5, "user_id": self.test_user_2.id})
reviews = self.test_record.with_user(self.test_user_3.id).request_validation()
self.assertTrue(reviews)
| 38.302469 | 6,205 |
1,473 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class TierDefinition(models.Model):
_inherit = "tier.definition"
python_code = fields.Text(
string="Tier Definition Expression",
help="Write Python code that defines when this tier confirmation "
"will be needed. The result of executing the expresion must be "
"a boolean.",
default="""# Available locals:\n# - rec: current record\nTrue""",
)
definition_type = fields.Selection(
selection_add=[("formula", "Formula"), ("domain_formula", "Domain & Formula")]
)
reviewer_expression = fields.Text(
string="Review Expression",
help="Write Python code that defines the reviewer. "
"The result of executing the expression must be a res.users "
"recordset.",
default="# Available locals:\n# - rec: current record\n"
"# - Expects a recordset of res.users\nrec.env.user",
)
review_type = fields.Selection(selection_add=[("expression", "Python Expression")])
@api.onchange("review_type")
def onchange_review_type(self):
res = super(TierDefinition, self).onchange_review_type()
self.reviewer_expression = (
"# Available locals:\n"
"# - rec: current record\n"
"# - Expects a recordset of res.users\n"
"rec.env.user"
)
return res
| 37.769231 | 1,473 |
907 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, models
from odoo.exceptions import UserError
from odoo.tools.safe_eval import safe_eval
class TierValidation(models.AbstractModel):
_inherit = "tier.validation"
def evaluate_formula_tier(self, tier):
try:
res = safe_eval(tier.python_code, globals_dict={"rec": self})
except Exception as error:
raise UserError(
_("Error evaluating tier validation conditions.\n %s") % error
) from error
return res
def evaluate_tier(self, tier):
res = super().evaluate_tier(tier)
if tier.definition_type == "formula":
return self.evaluate_formula_tier(tier)
if tier.definition_type == "domain_formula":
return res and self.evaluate_formula_tier(tier)
return res
| 33.592593 | 907 |
2,062 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from odoo.tools.safe_eval import safe_eval
class TierReview(models.Model):
_inherit = "tier.review"
python_reviewer_ids = fields.Many2many(
comodel_name="res.users",
relation="tier_review_python_reviewer_rel",
column1="tier_review_id",
column2="user_id",
string="Reviewers from Python expression",
compute="_compute_python_reviewer_ids",
store=True,
)
@api.model
def _get_reviewer_fields(self):
res = super()._get_reviewer_fields()
return res + ["python_reviewer_ids"]
def _get_reviewers(self):
return super()._get_reviewers() + self.python_reviewer_ids
@api.depends("definition_id.reviewer_expression", "review_type", "model", "res_id")
def _compute_python_reviewer_ids(self):
for rec in self:
if rec.review_type != "expression":
rec.python_reviewer_ids = self.env["res.users"].browse()
continue
record = rec.env[rec.model].browse(rec.res_id).exists()
try:
reviewer_ids = safe_eval(
rec.definition_id.reviewer_expression, globals_dict={"rec": record}
)
except Exception as error:
raise UserError(
_("Error evaluating tier validation " "conditions.\n %s") % error
) from error
# Check if python expression returns 'res.users' recordset
if (
not isinstance(reviewer_ids, models.Model)
or reviewer_ids._name != "res.users"
):
raise UserError(
_(
"Reviewer python expression must return a "
"res.users recordset."
)
)
else:
rec.python_reviewer_ids = reviewer_ids
| 36.175439 | 2,062 |
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 |
2,133 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-server-ux",
description="Meta package for oca-server-ux Odoo addons",
version=version,
install_requires=[
'odoo-addon-announcement>=15.0dev,<15.1dev',
'odoo-addon-barcode_action>=15.0dev,<15.1dev',
'odoo-addon-base_archive_date>=15.0dev,<15.1dev',
'odoo-addon-base_cancel_confirm>=15.0dev,<15.1dev',
'odoo-addon-base_custom_filter>=15.0dev,<15.1dev',
'odoo-addon-base_duplicate_security_group>=15.0dev,<15.1dev',
'odoo-addon-base_export_manager>=15.0dev,<15.1dev',
'odoo-addon-base_field_deprecated>=15.0dev,<15.1dev',
'odoo-addon-base_import_security_group>=15.0dev,<15.1dev',
'odoo-addon-base_menu_visibility_restriction>=15.0dev,<15.1dev',
'odoo-addon-base_optional_quick_create>=15.0dev,<15.1dev',
'odoo-addon-base_revision>=15.0dev,<15.1dev',
'odoo-addon-base_search_custom_field_filter>=15.0dev,<15.1dev',
'odoo-addon-base_substate>=15.0dev,<15.1dev',
'odoo-addon-base_technical_features>=15.0dev,<15.1dev',
'odoo-addon-base_tier_validation>=15.0dev,<15.1dev',
'odoo-addon-base_tier_validation_formula>=15.0dev,<15.1dev',
'odoo-addon-base_tier_validation_forward>=15.0dev,<15.1dev',
'odoo-addon-base_tier_validation_report>=15.0dev,<15.1dev',
'odoo-addon-chained_swapper>=15.0dev,<15.1dev',
'odoo-addon-date_range>=15.0dev,<15.1dev',
'odoo-addon-default_multi_user>=15.0dev,<15.1dev',
'odoo-addon-document_quick_access>=15.0dev,<15.1dev',
'odoo-addon-document_quick_access_folder_auto_classification>=15.0dev,<15.1dev',
'odoo-addon-filter_multi_user>=15.0dev,<15.1dev',
'odoo-addon-mass_editing>=15.0dev,<15.1dev',
'odoo-addon-multi_step_wizard>=15.0dev,<15.1dev',
'odoo-addon-sequence_reset_period>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 47.4 | 2,133 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
611 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Filter Multi User",
"summary": "Allows to share user-defined filters filters 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": ["security/ir_filters_security.xml", "views/ir_filters_view.xml"],
}
| 38.1875 | 611 |
4,723 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ForgeFlow S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.exceptions import AccessError
from odoo.tests import common
class TestFilterMultiUser(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.filter_model = cls.env["ir.filters"]
cls.user_model = cls.env["res.users"]
cls.group_user = cls.env.ref("base.group_user")
cls.group_private = cls.env["res.groups"].create({"name": "Test Group"})
cls.user_1 = cls._create_user("user_1", [cls.group_user, cls.group_private])
cls.user_2 = cls._create_user("user_2", [cls.group_user])
cls.user_3 = cls._create_user("user_3", [cls.group_user, cls.group_private])
@classmethod
def _create_user(cls, login, groups):
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)],
}
)
return user
def test_01_no_multi_user(self):
test_filter = self.filter_model.create(
{
"name": "Test filter",
"model_id": "ir.filters",
"user_id": self.user_1.id,
}
)
self.assertTrue(test_filter.with_user(self.user_1).name)
test_filter.invalidate_cache()
with self.assertRaises(AccessError):
self.assertTrue(test_filter.with_user(self.user_2).name)
def test_02_multi_user(self):
test_filter = self.filter_model.create(
{
"name": "Test filter",
"model_id": "ir.filters",
"user_id": self.user_1.id,
"manual_user_ids": [(6, 0, (self.user_1 + self.user_2).ids)],
}
)
self.assertTrue(test_filter.with_user(self.user_1).name)
test_filter.invalidate_cache()
self.assertTrue(test_filter.with_user(self.user_2).name)
def test_03_get_filters(self):
test_filter_1 = self.filter_model.create(
{
"name": "Test filter - specific user",
"model_id": "ir.filters",
"manual_user_ids": [(6, 0, (self.user_1 + self.user_2).ids)],
}
)
test_filter_2 = self.filter_model.create(
{
"name": "Test filter 2 - Regular",
"model_id": "ir.filters",
"user_id": self.user_1.id,
}
)
test_filter_3 = self.filter_model.create(
{
"name": "Test filter 3 - Group",
"model_id": "ir.filters",
"user_id": self.user_1.id,
"group_ids": [(6, 0, self.group_private.ids)],
}
)
# User 1:
res = self.filter_model.with_user(self.user_1).get_filters("ir.filters")
result = []
for filters in res:
result.append(filters.get("id"))
self.assertIn(test_filter_1.id, result)
self.assertIn(test_filter_2.id, result)
self.assertIn(test_filter_3.id, result)
# User 2:
res = self.filter_model.with_user(self.user_2).get_filters("ir.filters")
result = []
for filters in res:
result.append(filters.get("id"))
self.assertIn(test_filter_1.id, result)
self.assertNotIn(test_filter_2.id, result)
self.assertNotIn(test_filter_3.id, result)
# User 3:
res = self.filter_model.with_user(self.user_3).get_filters("ir.filters")
result = []
for filters in res:
result.append(filters.get("id"))
self.assertNotIn(test_filter_1.id, result)
self.assertNotIn(test_filter_2.id, result)
self.assertIn(test_filter_3.id, result)
def test_04_group_filter(self):
test_filter = self.filter_model.create(
{
"name": "Test filter",
"model_id": "ir.filters",
"user_id": self.user_1.id,
"group_ids": [(6, 0, self.group_private.ids)],
}
)
self.assertTrue(test_filter.with_user(self.user_1).name)
test_filter.invalidate_cache()
with self.assertRaises(AccessError):
self.assertTrue(test_filter.with_user(self.user_2).name)
test_filter.invalidate_cache()
self.assertTrue(test_filter.with_user(self.user_3).name)
| 37.188976 | 4,723 |
1,656 |
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 IrFilters(models.Model):
_inherit = "ir.filters"
user_ids = fields.Many2many(
comodel_name="res.users",
string="Users",
compute="_compute_user_ids",
store=True,
)
manual_user_ids = fields.Many2many(
comodel_name="res.users",
string="Available for Users",
relation="ir_filters_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_filters(self, model, action_id=None):
# WARNING: this function overrides the standard one.
# The only change done is in the domain used to search the filters.
action_domain = self._get_action_domain(action_id)
filters = self.search(
action_domain
+ [
("model_id", "=", model),
"|",
"|",
("user_id", "=", self._uid),
("user_ids", "in", self._uid),
"&",
("user_id", "=", False),
("user_ids", "=", False),
]
)
user_context = self.env["res.users"].context_get()
return filters.with_context(**user_context).read(
["name", "is_default", "domain", "context", "user_id", "sort"]
)
| 31.846154 | 1,656 |
467 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.api import SUPERUSER_ID, Environment
def uninstall_hook(cr, registry):
"""Delete the actions that were created with chained_swapper when
the module is uninstalled"""
env = Environment(cr, SUPERUSER_ID, {})
env["ir.actions.act_window"].search(
[("res_model", "=", "chained.swapper.wizard")]
).unlink()
return True
| 33.357143 | 467 |
672 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Chained Swapper",
"summary": "Chained Swapper",
"version": "15.0.1.0.2",
"development_status": "Mature",
"author": "Tecnativa, Odoo Community Association (OCA)",
"category": "Tools",
"website": "https://github.com/OCA/server-ux",
"license": "AGPL-3",
"depends": ["base"],
"data": [
"security/ir.model.access.csv",
"views/chained_swapper_views.xml",
"wizard/chained_swapper_wizard_views.xml",
],
"demo": ["demo/chained_swapper_demo.xml"],
"uninstall_hook": "uninstall_hook",
}
| 33.6 | 672 |
4,462 |
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 exceptions
from odoo.modules import registry
from odoo.tests import common
from odoo.tests.common import Form
from ..hooks import uninstall_hook
class TestChainedSwapper(common.TransactionCase):
@classmethod
def setUpClass(cls):
super(TestChainedSwapper, cls).setUpClass()
cls.env["res.lang"]._activate_lang("es_ES")
res_partner = cls.env["res.partner"]
cls.partner_parent = res_partner.create(
{"name": "parent partner cs", "lang": "en_US"}
)
cls.partner_child_1 = res_partner.create(
{"name": "partner child1 cs", "parent_id": cls.partner_parent.id}
)
cls.partner_child_2 = res_partner.create(
{"name": "partner child2 cs", "parent_id": cls.partner_parent.id}
)
# Prevent duplicate error removing demo data if exists
record = cls.env.ref("chained_swapper.chained_swapper_demo", False)
if record:
record.unlink()
chained_swapper_form = Form(cls.env["chained.swapper"])
chained_swapper_form.name = "Language"
chained_swapper_form.model_id = cls.env.ref("base.model_res_partner")
chained_swapper_form.field_id = cls.env.ref("base.field_res_partner__lang")
with chained_swapper_form.sub_field_ids.new() as sub_field_form:
sub_field_form.sub_field_chain = "child_ids.lang"
with chained_swapper_form.constraint_ids.new() as constraint_form:
constraint_form.name = "Only parent company"
constraint_form.expression = "bool(records.mapped('parent_id'))"
cls.chained_swapper = chained_swapper_form.save()
cls.chained_swapper.add_action()
def test_create_unlink_action(self):
"""Test if Sidebar Action is added / removed to / from given object."""
action = (
self.chained_swapper.ref_ir_act_window_id
and self.chained_swapper.ref_ir_act_window_id.binding_model_id
)
self.assertTrue(action)
# Remove the action
self.chained_swapper.unlink_action()
action = self.chained_swapper.ref_ir_act_window_id
self.assertFalse(action)
# Add an action
self.chained_swapper.add_action()
action = (
self.chained_swapper.ref_ir_act_window_id
and self.chained_swapper.ref_ir_act_window_id.binding_model_id
)
self.assertTrue(action)
def test_unlink_chained_swapper(self):
"""Test if related actions are removed when a chained swapper
record is unlinked."""
action_id = self.chained_swapper.ref_ir_act_window_id.id
self.chained_swapper.unlink()
action = self.env["ir.actions.act_window"].search([("id", "=", action_id)])
self.assertFalse(action)
def test_change_constrained_partner_language(self):
with self.assertRaises(exceptions.UserError):
self.env["chained.swapper.wizard"].with_context(
active_model="res.partner",
active_id=self.partner_parent.id,
active_ids=(self.partner_parent | self.partner_child_1).ids,
chained_swapper_id=self.chained_swapper.id,
).create({"lang": "es_ES"})
def test_change_partner_language(self):
self.env["chained.swapper.wizard"].with_context(
active_model="res.partner",
active_id=self.partner_parent.id,
active_ids=[self.partner_parent.id],
chained_swapper_id=self.chained_swapper.id,
).create({"lang": "es_ES"})
self.assertEqual(self.partner_parent.lang, "es_ES")
self.assertEqual(self.partner_child_1.lang, "es_ES")
self.assertEqual(self.partner_child_2.lang, "es_ES")
def test_uninstall_hook(self):
"""Test if related actions are removed when mass editing
record is uninstalled."""
action_id = self.chained_swapper.ref_ir_act_window_id.id
uninstall_hook(self.cr, registry)
self.assertFalse(self.env["ir.actions.act_window"].browse(action_id).exists())
def test_invalid_constraint(self):
with self.assertRaises(exceptions.ValidationError):
self.chained_swapper.constraint_ids.write(
{"expression": "Something incorrect"}
)
| 42.903846 | 4,462 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.