Initial commit: Core packages

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/__init__.py

@@ -0,0 +1,5 @@
+from . import ir_filters
+from . import res_partner
+from . import res_company
+from . import res_currency
+from . import res_user

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/ir_filters.py

@@ -0,0 +1,28 @@
+from odoo import models
+from odoo.tools import populate
+
+
+class Filter(models.Model):
+    _inherit = "ir.filters"
+
+    # Based on the sizes of res.users, 10 filters per user.
+    _populate_sizes = {
+        'small': 100,
+        'medium': 10000,
+        'large': 100000,
+    }
+    _populate_dependencies = ['res.users']
+
+    def _populate_factories(self):
+        return [
+            ('name', populate.constant('filter_{counter}')),
+            ('user_id', populate.randomize(self.env.registry.populated_models['res.users'])),
+            ('domain', populate.iterate(["[('id', '=', 1)]", "[('id', '=', 2)]", "[('id', '=', 3)]"])),
+            ('context', populate.iterate(["{{}}", "{{'group_by': ['create_date:month']}}"])),
+            ('sort', populate.iterate(["[]"])),
+            ('model_id', populate.randomize(
+                list(dict(self._fields['model_id'].get_description(self.env, ['selection'])['selection']).keys())
+            )),
+            ('is_default', populate.cartesian([True, False], [0.1, 0.9])),
+            ('action_id', populate.randomize(self.env['ir.actions.actions'].search([]).ids)),
+        ]

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/res_company.py

@@ -0,0 +1,43 @@
+import collections
+import logging
+
+from odoo import models, Command
+from odoo.tools import populate
+
+_logger = logging.getLogger(__name__)
+
+
+class Partner(models.Model):
+    _inherit = "res.company"
+
+    _populate_sizes = {
+        'small': 5,
+        'medium': 10,
+        'large': 50,
+    }
+
+    def _populate_factories(self):
+        # Activate currency to avoid fail iterator
+        (self.env.ref('base.USD') | self.env.ref('base.EUR')).active = True
+
+        # remaining: paperformat_id, parent_id, partner_id, favicon, font, report_header, external_report_layout_id, report_footer
+        def get_name(values=None, counter=0, **kwargs):
+            return 'company_%s_%s' % (counter, self.env['res.currency'].browse(values['currency_id']).name)
+
+        active_currencies = self.env['res.currency'].search([('active', '=', True)]).ids
+        return [
+            ('name', populate.constant('company_{counter}')),
+            ('sequence', populate.randint(0, 100)),
+            ('company_registry', populate.iterate([False, 'company_registry_{counter}'])),
+            ('base_onboarding_company_state', populate.iterate(
+                [False] + [e[0] for e in self._fields['base_onboarding_company_state'].selection])),
+            ('primary_color', populate.iterate([False, '', '#ff7755'])),
+            ('secondary_color', populate.iterate([False, '', '#ffff55'], seed='primary_color')),
+            ('currency_id', populate.iterate(active_currencies)),
+            ('name', populate.compute(get_name)),
+        ]
+
+    def _populate(self, size):
+        records = super()._populate(size)
+        self.env.ref('base.user_admin').write({'company_ids': [Command.link(rec.id) for rec in records]})  # add all created companies on user admin
+        return records

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/res_currency.py

@@ -0,0 +1,36 @@
+from dateutil.relativedelta import relativedelta
+from datetime import date
+
+from odoo import models, Command
+from odoo.tools import populate
+
+
+class ResCurrencyRate(models.Model):
+    _inherit = "res.currency.rate"
+
+    _populate_sizes = {
+        'small': 100,
+        'medium': 1000,
+        'large': 10000,
+    }
+
+    def _populate_factories(self):
+        def get_rate(random, values, **kwargs):
+            basis = sum(
+                ord(c) for c in
+                self.env['res.currency'].browse(values['currency_id']).name
+            ) % 20
+            return basis + random.uniform(-1, 1)
+
+        def get_date(random, values, **kwargs):
+            return date(2020, 1, 1) - relativedelta(days=kwargs['counter'])
+
+        company_ids = self.env['res.company'].search([
+            ('id', 'in', self.env.registry.populated_models['res.company']),
+        ])
+        return [
+            ('currency_id', populate.randomize(self.env['res.currency'].search([('active', '=', True)]).ids)),
+            ('company_id', populate.randomize(company_ids.ids)),
+            ('name', populate.compute(get_date)),
+            ('rate', populate.compute(get_rate)),
+        ]

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/res_partner.py

@@ -0,0 +1,165 @@
+
+import collections
+import logging
+
+from odoo import models
+from odoo.tools import populate
+
+_logger = logging.getLogger(__name__)
+
+
+class Partner(models.Model):
+    _inherit = "res.partner"
+    _populate_dependencies = ["res.company", "res.partner.industry"]
+
+    _populate_sizes = {
+        'small': 100,
+        'medium': 2000,
+        'large': 100000,
+    }
+
+    def _populate_factories(self):
+
+        # example of more complex generator composed of multiple sub generators
+        # this define one subgenerator per "country"
+        address_factories_groups = [
+            [ # Falsy, 2 records
+                ('street', populate.iterate([False, ''])),
+                ('street2', populate.iterate([False, ''])),
+                ('city', populate.iterate([False, ''])),
+                ('zip', populate.iterate([False, ''])),
+                ('country_id', populate.iterate([False])),
+            ], [  # BE, 1 record
+                ('street', populate.iterate(['Boulevard Tintin {counter}'])),
+                ('city', populate.iterate(['Brussels'])),
+                ('zip', populate.iterate([1020])),
+                ('country_id', populate.iterate([self.env.ref('base.be').id])),
+            ], [  # US, 3 records
+                ('street', populate.iterate(['Main street', '3th street {counter}', False])),
+                ('street2', populate.iterate([False, '', 'Behind the tree {counter}'], [90, 5, 5])),
+                ('city', populate.randomize(['Sans Fransisco', 'Los Angeles', '', False])),
+                ('zip', populate.iterate([False, '', '50231'])),
+                ('country_id', populate.iterate([self.env.ref('base.us').id])),
+            ], [  # IN, 2 records
+                ('street', populate.iterate(['Main Street', 'Some Street {counter}'])),
+                ('city', populate.iterate(['ગાંધીનગર (Gandhinagar)'])),
+                ('zip', populate.randomize(['382002', '382008'])),
+                ('country_id', populate.randomize([self.env.ref('base.in').id])),
+            ], [  # other corner cases, 4 records
+                ('street', populate.iterate(['万泉寺村', 'საბჭოს სკვერი {counter}', '10th Street {counter}'])),
+                ('city', populate.iterate(['北京市', 'თბილისი', 'دبي'])),
+                ('zip', populate.iterate([False, 'UF47', '0', '10201'])),
+                ('country_id', populate.randomize([False] + self.env['res.country'].search([]).ids)),
+            ]
+        ]
+
+        def generate_address(iterator, *args):
+            address_generators = [populate.chain_factories(address_factories, self._name) for address_factories in address_factories_groups]
+            # first, exhaust all address_generators
+            for adress_generator in address_generators:
+                for adress_values in adress_generator:
+                    if adress_values['__complete']:
+                        break
+                    values = next(iterator)  # only consume main iterator if usefull
+                    yield {**values, **adress_values}
+
+            # then, go pseudorandom between generators
+            r = populate.Random('res.partner+address_generator_selector')
+            for values in iterator:
+                adress_generator = r.choice(address_generators)
+                adress_values = next(adress_generator)
+                yield {**adress_values, **values}
+
+        # state based on country
+        states = self.env['res.country.state'].search([])
+        states_per_country = collections.defaultdict(list)
+        for state in states:
+            states_per_country[state.country_id.id].append(state.id)
+
+        def get_state(values=None, random=None, **kwargs):
+            country_id = values['country_id']
+            if not country_id:
+                return False
+            return random.choice([False] + states_per_country[country_id])
+
+        def get_name(values=None, counter=0, **kwargs):
+            is_company = values['is_company']
+            complete = values['__complete']
+            return  '%s_%s_%s' % ('company' if is_company else 'partner', int(complete), counter)
+
+        industry_ids = self.env.registry.populated_models['res.partner.industry']
+        company_ids = self.env.registry.populated_models['res.company']
+
+        # not defined fields: vat, partner_longitude, date, partner_latitude, color, company_name, employee, lang, user_id
+        return [
+            ('active', populate.cartesian([True, False], [0.9, 0.1])),
+            ('employee', populate.cartesian([True, False], [0.1, 0.9])),
+            ('email', populate.iterate(
+                [False, '', 'email{counter}@example.com', '<contact 万> contact{counter}@anotherexample.com', 'invalid_email'])),
+            ('type', populate.constant('contact')),  # todo add more logic, manage 'invoice', 'delivery', 'other', 'private'
+            ('is_company', populate.iterate([True, False], [0.05, 0.95])),
+            ('_address', generate_address),
+            ('state_id', populate.compute(get_state)),
+            ('phone', populate.randomize([False, '', '+3212345678', '003212345678', '12345678'])),
+            ('mobile', populate.randomize([False, '', '+32412345678', '0032412345678', '412345678'])),
+            ('title', populate.randomize(self.env['res.partner.title'].search([]).ids)),
+            ('function', populate.randomize(
+                [False, '', 'President of Sales', 'Senior Consultant', 'Product owner', 'Functional Consultant', 'Chief Executive Officer'],
+                [50, 10, 2, 20, 5, 10, 1])),
+            ('tz', populate.randomize([tz for tz in self.env['res.partner']._fields['tz'].get_values(self.env)])),
+            ('website', populate.randomize([False, '', 'http://www.example.com'])),
+            ('name', populate.compute(get_name)),  # keep after is_company
+            ('ref', populate.randomize([False, '', '{counter}', 'p-{counter}'], [10, 10, 30, 50])),
+            ('industry_id', populate.randomize(
+                [False] + industry_ids,
+                [0.5] + ([0.5/(len(industry_ids) or 1)] * len(industry_ids)))),
+            ('comment', populate.iterate([False, '', 'This is a partner {counter}'])),
+            ('company_id', populate.iterate(
+                [False, self.env.ref('base.main_company').id] + company_ids,
+                [1, 1] + [1/(len(company_ids) or 1)]*len(company_ids))),
+            ('parent_id', populate.constant(False)),  # will be setted in _populate override
+        ]
+
+    def _populate(self, size):
+        records = super()._populate(size)
+        # set parent_ids
+        self._populate_set_companies(records)
+        return records
+
+    def _populate_set_companies(self, records):
+        _logger.info('Setting companies')
+        r_company = populate.Random('res.partner+company_has_partners')
+        r_partner = populate.Random('res.partner+partner_has_company')
+        r_company_pick = populate.Random('res.partner+partner_company_pick=')
+
+        companies = records.filtered(lambda p: p.is_company and r_company.getrandbits(1))  # 50% change to have partners
+        partners = records.filtered(lambda p: not p.is_company and r_partner.getrandbits(1))  # 50% change to have a company
+
+        companies_partners = collections.defaultdict(lambda: self.env['res.partner'])
+        for partner in partners:
+            companies_partners[r_company_pick.choice(companies)] |= partner
+
+        # batching company write improves performances a lot (~40% faster for total partner creation).
+        for count, (company, partners) in enumerate(companies_partners.items(), start=1):
+            if count % 100 == 0:
+                _logger.info('Setting company: %s/%s', count, len(companies))
+            partners.write({'parent_id': company.id})
+            partners._onchange_company_id()
+
+class ResPartnerIndustry(models.Model):
+    _inherit = "res.partner.industry"
+
+    _populate_sizes = {
+        'small': 15,
+        'medium': 60,
+        'large': 300,
+    }
+
+    def _populate_factories(self):
+        return [
+            ('active', populate.cartesian([False, True], [0.1, 0.9])),
+            ('name', populate.cartesian(
+                [False, 'Industry name', 'Industry name {counter}'],
+                [0.08, 0.01, 0.9])),
+            ('full_name', populate.iterate([False, 'Industry full name %s']))
+        ]

odoo-bringout-oca-ocb-base/odoo/addons/base/populate/res_user.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+import logging
+
+from odoo import models
+from odoo.tools import populate
+
+_logger = logging.getLogger(__name__)
+
+
+class Users(models.Model):
+    _inherit = "res.users"
+
+    _populate_sizes = {
+        'small': 10,
+        'medium': 1000,
+        'large': 10000,
+    }
+
+    _populate_dependencies = ["res.partner"]
+
+    def _populate_factories(self):
+        def generate_partner_id(iterator, *args):
+            partner_factories = self.env['res.partner']._populate_factories()
+            partner_generator = populate.chain_factories(partner_factories, self._name)
+            for dependant_values in partner_generator:
+                values = next(iterator)
+                yield {**dependant_values, **values, '__complete': values['__complete']}
+
+        def get_company_ids(values, **kwargs):
+            return [(6, 0, [values['company_id']])]
+
+        return [
+            ('active', populate.cartesian([True, False], [0.9, 0.1])),
+            ('partner_id', generate_partner_id),
+            ('company_id', populate.randomize(self.env.registry.populated_models['res.company'])),
+            ('company_ids', populate.compute(get_company_ids)),
+            ('login', populate.constant('user_login_{counter}')),
+            ('name', populate.constant('user_{counter}')),
+        ]
+
+    def _populate(self, size):
+        self = self.with_context(no_reset_password=True)  # avoid sending reset password email
+        return super(Users, self)._populate(size)