Initial commit: Hr packages

odoo-bringout-oca-ocb-hr/hr/models/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import hr_contract_type
+from . import hr_employee_base
+from . import hr_employee
+from . import hr_employee_category
+from . import hr_employee_public
+from . import hr_department
+from . import hr_departure_reason
+from . import hr_job
+from . import hr_plan
+from . import hr_plan_activity_type
+from . import hr_work_location
+from . import mail_alias
+from . import mail_channel
+from . import models
+from . import res_config_settings
+from . import res_partner
+from . import res_users
+from . import res_company
+from . import resource
+from . import ir_ui_menu

odoo-bringout-oca-ocb-hr/hr/models/hr_contract_type.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models
+
+
+class ContractType(models.Model):
+    _name = 'hr.contract.type'
+    _description = 'Contract Type'
+    _order = 'sequence'
+
+    name = fields.Char(required=True, translate=True)
+    sequence = fields.Integer()

odoo-bringout-oca-ocb-hr/hr/models/hr_department.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import ValidationError
+
+
+class Department(models.Model):
+    _name = "hr.department"
+    _description = "Department"
+    _inherit = ['mail.thread']
+    _order = "name"
+    _rec_name = 'complete_name'
+    _parent_store = True
+
+    name = fields.Char('Department Name', required=True)
+    complete_name = fields.Char('Complete Name', compute='_compute_complete_name', recursive=True, store=True)
+    active = fields.Boolean('Active', default=True)
+    company_id = fields.Many2one('res.company', string='Company', index=True, default=lambda self: self.env.company)
+    parent_id = fields.Many2one('hr.department', string='Parent Department', index=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    child_ids = fields.One2many('hr.department', 'parent_id', string='Child Departments')
+    manager_id = fields.Many2one('hr.employee', string='Manager', tracking=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    member_ids = fields.One2many('hr.employee', 'department_id', string='Members', readonly=True)
+    total_employee = fields.Integer(compute='_compute_total_employee', string='Total Employee')
+    jobs_ids = fields.One2many('hr.job', 'department_id', string='Jobs')
+    plan_ids = fields.One2many('hr.plan', 'department_id')
+    plans_count = fields.Integer(compute='_compute_plan_count')
+    note = fields.Text('Note')
+    color = fields.Integer('Color Index')
+    parent_path = fields.Char(index=True, unaccent=False)
+    master_department_id = fields.Many2one(
+        'hr.department', 'Master Department', compute='_compute_master_department_id', store=True)
+
+    def name_get(self):
+        if not self.env.context.get('hierarchical_naming', True):
+            return [(record.id, record.name) for record in self]
+        return super(Department, self).name_get()
+
+    @api.model
+    def name_create(self, name):
+        return self.create({'name': name}).name_get()[0]
+
+    @api.depends('name', 'parent_id.complete_name')
+    def _compute_complete_name(self):
+        for department in self:
+            if department.parent_id:
+                department.complete_name = '%s / %s' % (department.parent_id.complete_name, department.name)
+            else:
+                department.complete_name = department.name
+
+    @api.depends('parent_path')
+    def _compute_master_department_id(self):
+        for department in self:
+            department.master_department_id = int(department.parent_path.split('/')[0])
+
+    def _compute_total_employee(self):
+        emp_data = self.env['hr.employee']._read_group([('department_id', 'in', self.ids)], ['department_id'], ['department_id'])
+        result = dict((data['department_id'][0], data['department_id_count']) for data in emp_data)
+        for department in self:
+            department.total_employee = result.get(department.id, 0)
+
+    def _compute_plan_count(self):
+        plans_data = self.env['hr.plan']._read_group([('department_id', 'in', self.ids)], ['department_id'], ['department_id'])
+        plans_count = {x['department_id'][0]: x['department_id_count'] for x in plans_data}
+        for department in self:
+            department.plans_count = plans_count.get(department.id, 0)
+
+    @api.constrains('parent_id')
+    def _check_parent_id(self):
+        if not self._check_recursion():
+            raise ValidationError(_('You cannot create recursive departments.'))
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        # TDE note: auto-subscription of manager done by hand, because currently
+        # the tracking allows to track+subscribe fields linked to a res.user record
+        # An update of the limited behavior should come, but not currently done.
+        departments = super(Department, self.with_context(mail_create_nosubscribe=True)).create(vals_list)
+        for department, vals in zip(departments, vals_list):
+            manager = self.env['hr.employee'].browse(vals.get("manager_id"))
+            if manager.user_id:
+                department.message_subscribe(partner_ids=manager.user_id.partner_id.ids)
+        return departments
+
+    def write(self, vals):
+        """ If updating manager of a department, we need to update all the employees
+            of department hierarchy, and subscribe the new manager.
+        """
+        # TDE note: auto-subscription of manager done by hand, because currently
+        # the tracking allows to track+subscribe fields linked to a res.user record
+        # An update of the limited behavior should come, but not currently done.
+        if 'manager_id' in vals:
+            manager_id = vals.get("manager_id")
+            if manager_id:
+                manager = self.env['hr.employee'].browse(manager_id)
+                # subscribe the manager user
+                if manager.user_id:
+                    self.message_subscribe(partner_ids=manager.user_id.partner_id.ids)
+            # set the employees's parent to the new manager
+            self._update_employee_manager(manager_id)
+        return super(Department, self).write(vals)
+
+    def _update_employee_manager(self, manager_id):
+        employees = self.env['hr.employee']
+        for department in self:
+            employees = employees | self.env['hr.employee'].search([
+                ('id', '!=', manager_id),
+                ('department_id', '=', department.id),
+                ('parent_id', '=', department.manager_id.id)
+            ])
+        employees.write({'parent_id': manager_id})
+
+    def get_formview_action(self, access_uid=None):
+        res = super().get_formview_action(access_uid=access_uid)
+        if (not self.user_has_groups('hr.group_hr_user') and
+           self.env.context.get('open_employees_kanban', False)):
+            res.update({
+                'name': self.name,
+                'res_model': 'hr.employee.public',
+                'view_type': 'kanban',
+                'view_mode': 'kanban',
+                'views': [(False, 'kanban'), (False, 'form')],
+                'context': {'searchpanel_default_department_id': self.id},
+                'res_id': False,
+            })
+        return res
+
+    def action_plan_from_department(self):
+        action = self.env['ir.actions.actions']._for_xml_id('hr.hr_plan_action')
+        action['context'] = {'default_department_id': self.id, 'search_default_department_id': self.id}
+        return action
+
+    def get_children_department_ids(self):
+        return self.env['hr.department'].search([('id', 'child_of', self.ids)])

odoo-bringout-oca-ocb-hr/hr/models/hr_departure_reason.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import UserError
+
+
+class DepartureReason(models.Model):
+    _name = "hr.departure.reason"
+    _description = "Departure Reason"
+    _order = "sequence"
+
+    sequence = fields.Integer("Sequence", default=10)
+    name = fields.Char(string="Reason", required=True, translate=True)
+    # YTI TODO: Move reason_code to hr + adapt _unlink_except_default_departure_reasons
+    # to use the codes instead of refs
+
+    def _get_default_departure_reasons(self):
+        return {
+            'fired': 342,
+            'resigned': 343,
+            'retired': 340,
+        }
+
+    @api.ondelete(at_uninstall=False)
+    def _unlink_except_default_departure_reasons(self):
+        master_reasons = [self.env.ref('hr.departure_fired', False), self.env.ref('hr.departure_resigned', False), self.env.ref('hr.departure_retired', False)]
+        if any(reason in master_reasons for reason in self):
+            raise UserError(_('Default departure reasons cannot be deleted.'))

odoo-bringout-oca-ocb-hr/hr/models/hr_employee.py

@@ -0,0 +1,551 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+import pytz
+from pytz import UTC
+from datetime import datetime, time
+from random import choice
+from string import digits
+from werkzeug.urls import url_encode
+from dateutil.relativedelta import relativedelta
+
+from odoo import api, fields, models, _
+from odoo.exceptions import ValidationError, AccessError
+from odoo.osv import expression
+from odoo.tools import format_date, Query
+
+
+class HrEmployeePrivate(models.Model):
+    """
+    NB: Any field only available on the model hr.employee (i.e. not on the
+    hr.employee.public model) should have `groups="hr.group_hr_user"` on its
+    definition to avoid being prefetched when the user hasn't access to the
+    hr.employee model. Indeed, the prefetch loads the data for all the fields
+    that are available according to the group defined on them.
+    """
+    _name = "hr.employee"
+    _description = "Employee"
+    _order = 'name'
+    _inherit = ['hr.employee.base', 'mail.thread', 'mail.activity.mixin', 'resource.mixin', 'avatar.mixin']
+    _mail_post_access = 'read'
+
+    # resource and user
+    # required on the resource, make sure required="True" set in the view
+    name = fields.Char(string="Employee Name", related='resource_id.name', store=True, readonly=False, tracking=True)
+    user_id = fields.Many2one('res.users', 'User', related='resource_id.user_id', store=True, readonly=False)
+    user_partner_id = fields.Many2one(related='user_id.partner_id', related_sudo=False, string="User's partner")
+    active = fields.Boolean('Active', related='resource_id.active', default=True, store=True, readonly=False)
+    company_id = fields.Many2one('res.company', required=True)
+    company_country_id = fields.Many2one('res.country', 'Company Country', related='company_id.country_id', readonly=True)
+    company_country_code = fields.Char(related='company_country_id.code', depends=['company_country_id'], readonly=True)
+    # private partner
+    address_home_id = fields.Many2one(
+        'res.partner', 'Address', help='Enter here the private address of the employee, not the one linked to your company.',
+        groups="hr.group_hr_user", tracking=True,
+        domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    is_address_home_a_company = fields.Boolean(
+        'The employee address has a company linked',
+        compute='_compute_is_address_home_a_company',
+    )
+    private_email = fields.Char(related='address_home_id.email', string="Private Email", groups="hr.group_hr_user")
+    lang = fields.Selection(related='address_home_id.lang', string="Lang", groups="hr.group_hr_user", readonly=False)
+    country_id = fields.Many2one(
+        'res.country', 'Nationality (Country)', groups="hr.group_hr_user", tracking=True)
+    gender = fields.Selection([
+        ('male', 'Male'),
+        ('female', 'Female'),
+        ('other', 'Other')
+    ], groups="hr.group_hr_user", tracking=True)
+    marital = fields.Selection([
+        ('single', 'Single'),
+        ('married', 'Married'),
+        ('cohabitant', 'Legal Cohabitant'),
+        ('widower', 'Widower'),
+        ('divorced', 'Divorced')
+    ], string='Marital Status', groups="hr.group_hr_user", default='single', tracking=True)
+    spouse_complete_name = fields.Char(string="Spouse Complete Name", groups="hr.group_hr_user", tracking=True)
+    spouse_birthdate = fields.Date(string="Spouse Birthdate", groups="hr.group_hr_user", tracking=True)
+    children = fields.Integer(string='Number of Dependent Children', groups="hr.group_hr_user", tracking=True)
+    place_of_birth = fields.Char('Place of Birth', groups="hr.group_hr_user", tracking=True)
+    country_of_birth = fields.Many2one('res.country', string="Country of Birth", groups="hr.group_hr_user", tracking=True)
+    birthday = fields.Date('Date of Birth', groups="hr.group_hr_user", tracking=True)
+    ssnid = fields.Char('SSN No', help='Social Security Number', groups="hr.group_hr_user", tracking=True)
+    sinid = fields.Char('SIN No', help='Social Insurance Number', groups="hr.group_hr_user", tracking=True)
+    identification_id = fields.Char(string='Identification No', groups="hr.group_hr_user", tracking=True)
+    passport_id = fields.Char('Passport No', groups="hr.group_hr_user", tracking=True)
+    bank_account_id = fields.Many2one(
+        'res.partner.bank', 'Bank Account Number',
+        domain="[('partner_id', '=', address_home_id), '|', ('company_id', '=', False), ('company_id', '=', company_id)]",
+        groups="hr.group_hr_user",
+        tracking=True,
+        help='Employee bank account to pay salaries')
+    permit_no = fields.Char('Work Permit No', groups="hr.group_hr_user", tracking=True)
+    visa_no = fields.Char('Visa No', groups="hr.group_hr_user", tracking=True)
+    visa_expire = fields.Date('Visa Expiration Date', groups="hr.group_hr_user", tracking=True)
+    work_permit_expiration_date = fields.Date('Work Permit Expiration Date', groups="hr.group_hr_user", tracking=True)
+    has_work_permit = fields.Binary(string="Work Permit", groups="hr.group_hr_user", tracking=True)
+    work_permit_scheduled_activity = fields.Boolean(default=False, groups="hr.group_hr_user")
+    work_permit_name = fields.Char('work_permit_name', compute='_compute_work_permit_name')
+    additional_note = fields.Text(string='Additional Note', groups="hr.group_hr_user", tracking=True)
+    certificate = fields.Selection([
+        ('graduate', 'Graduate'),
+        ('bachelor', 'Bachelor'),
+        ('master', 'Master'),
+        ('doctor', 'Doctor'),
+        ('other', 'Other'),
+    ], 'Certificate Level', default='other', groups="hr.group_hr_user", tracking=True)
+    study_field = fields.Char("Field of Study", groups="hr.group_hr_user", tracking=True)
+    study_school = fields.Char("School", groups="hr.group_hr_user", tracking=True)
+    emergency_contact = fields.Char("Contact Name", groups="hr.group_hr_user", tracking=True)
+    emergency_phone = fields.Char("Contact Phone", groups="hr.group_hr_user", tracking=True)
+    km_home_work = fields.Integer(string="Home-Work Distance", groups="hr.group_hr_user", tracking=True)
+
+    job_id = fields.Many2one(tracking=True)
+    phone = fields.Char(related='address_home_id.phone', related_sudo=False, readonly=False, string="Private Phone", groups="hr.group_hr_user")
+    # employee in company
+    child_ids = fields.One2many('hr.employee', 'parent_id', string='Direct subordinates')
+    category_ids = fields.Many2many(
+        'hr.employee.category', 'employee_category_rel',
+        'emp_id', 'category_id', groups="hr.group_hr_user",
+        string='Tags')
+    # misc
+    notes = fields.Text('Notes', groups="hr.group_hr_user")
+    color = fields.Integer('Color Index', default=0)
+    barcode = fields.Char(string="Badge ID", help="ID used for employee identification.", groups="hr.group_hr_user", copy=False)
+    pin = fields.Char(string="PIN", groups="hr.group_hr_user", copy=False,
+        help="PIN used to Check In/Out in the Kiosk Mode of the Attendance application (if enabled in Configuration) and to change the cashier in the Point of Sale application.")
+    departure_reason_id = fields.Many2one("hr.departure.reason", string="Departure Reason", groups="hr.group_hr_user",
+                                          copy=False, tracking=True, ondelete='restrict')
+    departure_description = fields.Html(string="Additional Information", groups="hr.group_hr_user", copy=False, tracking=True)
+    departure_date = fields.Date(string="Departure Date", groups="hr.group_hr_user", copy=False, tracking=True)
+    message_main_attachment_id = fields.Many2one(groups="hr.group_hr_user")
+    id_card = fields.Binary(string="ID Card Copy", groups="hr.group_hr_user")
+    driving_license = fields.Binary(string="Driving License", groups="hr.group_hr_user")
+    currency_id = fields.Many2one('res.currency', related='company_id.currency_id', readonly=True)
+
+    _sql_constraints = [
+        ('barcode_uniq', 'unique (barcode)', "The Badge ID must be unique, this one is already assigned to another employee."),
+        ('user_uniq', 'unique (user_id, company_id)', "A user cannot be linked to multiple employees in the same company.")
+    ]
+
+    @api.depends('name', 'user_id.avatar_1920', 'image_1920')
+    def _compute_avatar_1920(self):
+        super()._compute_avatar_1920()
+
+    @api.depends('name', 'user_id.avatar_1024', 'image_1024')
+    def _compute_avatar_1024(self):
+        super()._compute_avatar_1024()
+
+    @api.depends('name', 'user_id.avatar_512', 'image_512')
+    def _compute_avatar_512(self):
+        super()._compute_avatar_512()
+
+    @api.depends('name', 'user_id.avatar_256', 'image_256')
+    def _compute_avatar_256(self):
+        super()._compute_avatar_256()
+
+    @api.depends('name', 'user_id.avatar_128', 'image_128')
+    def _compute_avatar_128(self):
+        super()._compute_avatar_128()
+
+    def _compute_avatar(self, avatar_field, image_field):
+        for employee in self:
+            avatar = employee._origin[image_field]
+            if not avatar:
+                if employee.user_id:
+                    avatar = employee.user_id.sudo()[avatar_field]
+                else:
+                    avatar = base64.b64encode(employee._avatar_get_placeholder())
+            employee[avatar_field] = avatar
+
+    @api.depends('name', 'permit_no')
+    def _compute_work_permit_name(self):
+        for employee in self:
+            name = employee.name.replace(' ', '_') + '_' if employee.name else ''
+            permit_no = '_' + employee.permit_no if employee.permit_no else ''
+            employee.work_permit_name = "%swork_permit%s" % (name, permit_no)
+
+    def action_create_user(self):
+        self.ensure_one()
+        if self.user_id:
+            raise ValidationError(_("This employee already has an user."))
+        return {
+            'name': _('Create User'),
+            'type': 'ir.actions.act_window',
+            'res_model': 'res.users',
+            'view_mode': 'form',
+            'view_id': self.env.ref('hr.view_users_simple_form').id,
+            'target': 'new',
+            'context': {
+                'default_create_employee_id': self.id,
+                'default_name': self.name,
+                'default_phone': self.work_phone,
+                'default_mobile': self.mobile_phone,
+                'default_login': self.work_email,
+            }
+        }
+
+    def name_get(self):
+        if self.check_access_rights('read', raise_exception=False):
+            return super(HrEmployeePrivate, self).name_get()
+        return self.env['hr.employee.public'].browse(self.ids).name_get()
+
+    def _read(self, fields):
+        if self.check_access_rights('read', raise_exception=False):
+            return super(HrEmployeePrivate, self)._read(fields)
+
+        # HACK: retrieve publicly available values from hr.employee.public and
+        # copy them to the cache of self; non-public data will be missing from
+        # cache, and interpreted as an access error
+        self.flush_recordset(fields)
+        public = self.env['hr.employee.public'].browse(self._ids)
+        public.read(fields)
+        for fname in fields:
+            values = self.env.cache.get_values(public, public._fields[fname])
+            if self._fields[fname].translate:
+                values = [(value.copy() if value else None) for value in values]
+            self.env.cache.update_raw(self, self._fields[fname], values)
+
+    @api.model
+    def _cron_check_work_permit_validity(self):
+        # Called by a cron
+        # Schedule an activity 1 month before the work permit expires
+        outdated_days = fields.Date.today() + relativedelta(months=+1)
+        nearly_expired_work_permits = self.search([('work_permit_scheduled_activity', '=', False), ('work_permit_expiration_date', '<', outdated_days)])
+        employees_scheduled = self.env['hr.employee']
+        for employee in nearly_expired_work_permits.filtered(lambda employee: employee.parent_id):
+            responsible_user_id = employee.parent_id.user_id.id
+            if responsible_user_id:
+                employees_scheduled |= employee
+                lang = self.env['res.users'].browse(responsible_user_id).lang
+                formated_date = format_date(employee.env, employee.work_permit_expiration_date, date_format="dd MMMM y", lang_code=lang)
+                employee.activity_schedule(
+                    'mail.mail_activity_data_todo',
+                    note=_('The work permit of %(employee)s expires at %(date)s.',
+                        employee=employee.name,
+                        date=formated_date),
+                    user_id=responsible_user_id)
+        employees_scheduled.write({'work_permit_scheduled_activity': True})
+
+    def read(self, fields, load='_classic_read'):
+        if self.check_access_rights('read', raise_exception=False):
+            return super(HrEmployeePrivate, self).read(fields, load=load)
+        private_fields = set(fields).difference(self.env['hr.employee.public']._fields.keys())
+        if private_fields:
+            raise AccessError(_('The fields "%s" you try to read is not available on the public employee profile.') % (','.join(private_fields)))
+        return self.env['hr.employee.public'].browse(self.ids).read(fields, load=load)
+
+    @api.model
+    def get_view(self, view_id=None, view_type='form', **options):
+        if self.check_access_rights('read', raise_exception=False):
+            return super().get_view(view_id, view_type, **options)
+        return self.env['hr.employee.public'].get_view(view_id, view_type, **options)
+
+    @api.model
+    def get_views(self, views, options):
+        if self.check_access_rights('read', raise_exception=False):
+            return super().get_views(views, options)
+        res = self.env['hr.employee.public'].get_views(views, options)
+        res['models'].update({'hr.employee': res['models']['hr.employee.public']})
+        return res
+
+    @api.model
+    def _search(self, args, offset=0, limit=None, order=None, count=False, access_rights_uid=None):
+        """
+            We override the _search because it is the method that checks the access rights
+            This is correct to override the _search. That way we enforce the fact that calling
+            search on an hr.employee returns a hr.employee recordset, even if you don't have access
+            to this model, as the result of _search (the ids of the public employees) is to be
+            browsed on the hr.employee model. This can be trusted as the ids of the public
+            employees exactly match the ids of the related hr.employee.
+        """
+        if self.check_access_rights('read', raise_exception=False):
+            return super(HrEmployeePrivate, self)._search(args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
+        try:
+            ids = self.env['hr.employee.public']._search(args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
+        except ValueError:
+            raise AccessError(_('You do not have access to this document.'))
+        if not count and isinstance(ids, Query):
+            # the result is expected from this table, so we should link tables
+            ids = super(HrEmployeePrivate, self.sudo())._search([('id', 'in', ids)])
+        return ids
+
+    def get_formview_id(self, access_uid=None):
+        """ Override this method in order to redirect many2one towards the right model depending on access_uid """
+        if access_uid:
+            self_sudo = self.with_user(access_uid)
+        else:
+            self_sudo = self
+
+        if self_sudo.user_has_groups('hr.group_hr_user'):
+            return super(HrEmployeePrivate, self).get_formview_id(access_uid=access_uid)
+        # Hardcode the form view for public employee
+        return self.env.ref('hr.hr_employee_public_view_form').id
+
+    def get_formview_action(self, access_uid=None):
+        """ Override this method in order to redirect many2one towards the right model depending on access_uid """
+        res = super(HrEmployeePrivate, self).get_formview_action(access_uid=access_uid)
+        if access_uid:
+            self_sudo = self.with_user(access_uid)
+        else:
+            self_sudo = self
+
+        if not self_sudo.user_has_groups('hr.group_hr_user'):
+            res['res_model'] = 'hr.employee.public'
+
+        return res
+
+    @api.constrains('pin')
+    def _verify_pin(self):
+        for employee in self:
+            if employee.pin and not employee.pin.isdigit():
+                raise ValidationError(_("The PIN must be a sequence of digits."))
+
+    @api.onchange('user_id')
+    def _onchange_user(self):
+        if self.user_id:
+            self.update(self._sync_user(self.user_id, (bool(self.image_1920))))
+            if not self.name:
+                self.name = self.user_id.name
+
+    @api.onchange('resource_calendar_id')
+    def _onchange_timezone(self):
+        if self.resource_calendar_id and not self.tz:
+            self.tz = self.resource_calendar_id.tz
+
+    def _sync_user(self, user, employee_has_image=False):
+        vals = dict(
+            work_contact_id=user.partner_id.id,
+            user_id=user.id,
+        )
+        if not employee_has_image:
+            vals['image_1920'] = user.image_1920
+        if user.tz:
+            vals['tz'] = user.tz
+        return vals
+
+    def _prepare_resource_values(self, vals, tz):
+        resource_vals = super()._prepare_resource_values(vals, tz)
+        vals.pop('name')  # Already considered by super call but no popped
+        # We need to pop it to avoid useless resource update (& write) call
+        # on every newly created resource (with the correct name already)
+        user_id = vals.pop('user_id', None)
+        if user_id:
+            resource_vals['user_id'] = user_id
+        active_status = vals.get('active')
+        if active_status is not None:
+            resource_vals['active'] = active_status
+        return resource_vals
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        for vals in vals_list:
+            if vals.get('user_id'):
+                user = self.env['res.users'].browse(vals['user_id'])
+                vals.update(self._sync_user(user, bool(vals.get('image_1920'))))
+                vals['name'] = vals.get('name', user.name)
+        employees = super().create(vals_list)
+        if self.env.context.get('salary_simulation'):
+            return employees
+        employee_departments = employees.department_id
+        if employee_departments:
+            self.env['mail.channel'].sudo().search([
+                ('subscription_department_ids', 'in', employee_departments.ids)
+            ])._subscribe_users_automatically()
+        onboarding_notes_bodies = {}
+        hr_root_menu = self.env.ref('hr.menu_hr_root')
+        for employee in employees:
+            employee._message_subscribe(employee.address_home_id.ids)
+            # Launch onboarding plans
+            url = '/web#%s' % url_encode({
+                'action': 'hr.plan_wizard_action',
+                'active_id': employee.id,
+                'active_model': 'hr.employee',
+                'menu_id': hr_root_menu.id,
+            })
+            onboarding_notes_bodies[employee.id] = _(
+                '<b>Congratulations!</b> May I recommend you to setup an <a href="%s">onboarding plan?</a>',
+                url,
+            )
+        employees._message_log_batch(onboarding_notes_bodies)
+        return employees
+
+    def write(self, vals):
+        if 'address_home_id' in vals:
+            address_home_id = vals['address_home_id']
+            account_ids = vals.get('bank_account_id') or self.bank_account_id.ids
+            if account_ids and address_home_id:
+                self.env['res.partner.bank'].browse(account_ids).partner_id = address_home_id
+            self.message_unsubscribe(self.address_home_id.ids)
+            if address_home_id:
+                self._message_subscribe([address_home_id])
+        if 'user_id' in vals:
+            # Update the profile pictures with user, except if provided 
+            vals.update(self._sync_user(self.env['res.users'].browse(vals['user_id']),
+                                        (bool(all(emp.image_1920 for emp in self)))))
+        if 'work_permit_expiration_date' in vals:
+            vals['work_permit_scheduled_activity'] = False
+        res = super(HrEmployeePrivate, self).write(vals)
+        if vals.get('department_id') or vals.get('user_id'):
+            department_id = vals['department_id'] if vals.get('department_id') else self[:1].department_id.id
+            # When added to a department or changing user, subscribe to the channels auto-subscribed by department
+            self.env['mail.channel'].sudo().search([
+                ('subscription_department_ids', 'in', department_id)
+            ])._subscribe_users_automatically()
+        return res
+
+    def unlink(self):
+        resources = self.mapped('resource_id')
+        super(HrEmployeePrivate, self).unlink()
+        return resources.unlink()
+
+    def _get_employee_m2o_to_empty_on_archived_employees(self):
+        return ['parent_id', 'coach_id']
+
+    def _get_user_m2o_to_empty_on_archived_employees(self):
+        return []
+
+    def toggle_active(self):
+        res = super(HrEmployeePrivate, self).toggle_active()
+        unarchived_employees = self.filtered(lambda employee: employee.active)
+        unarchived_employees.write({
+            'departure_reason_id': False,
+            'departure_description': False,
+            'departure_date': False
+        })
+        archived_addresses = unarchived_employees.mapped('address_home_id').filtered(lambda addr: not addr.active)
+        archived_addresses.toggle_active()
+
+        archived_employees = self.filtered(lambda e: not e.active)
+        if archived_employees:
+            # Empty links to this employees (example: manager, coach, time off responsible, ...)
+            employee_fields_to_empty = self._get_employee_m2o_to_empty_on_archived_employees()
+            user_fields_to_empty = self._get_user_m2o_to_empty_on_archived_employees()
+            employee_domain = [[(field, 'in', archived_employees.ids)] for field in employee_fields_to_empty]
+            user_domain = [[(field, 'in', archived_employees.user_id.ids)] for field in user_fields_to_empty]
+            employees = self.env['hr.employee'].search(expression.OR(employee_domain + user_domain))
+            for employee in employees:
+                for field in employee_fields_to_empty:
+                    if employee[field] in archived_employees:
+                        employee[field] = False
+                for field in user_fields_to_empty:
+                    if employee[field] in archived_employees.user_id:
+                        employee[field] = False
+
+        if len(self) == 1 and not self.active and not self.env.context.get('no_wizard', False):
+            return {
+                'type': 'ir.actions.act_window',
+                'name': _('Register Departure'),
+                'res_model': 'hr.departure.wizard',
+                'view_mode': 'form',
+                'target': 'new',
+                'context': {'active_id': self.id},
+                'views': [[False, 'form']]
+            }
+        return res
+
+    @api.onchange('company_id')
+    def _onchange_company_id(self):
+        if self._origin:
+            return {'warning': {
+                'title': _("Warning"),
+                'message': _("To avoid multi company issues (losing the access to your previous contracts, leaves, ...), you should create another employee in the new company instead.")
+            }}
+
+    def generate_random_barcode(self):
+        for employee in self:
+            employee.barcode = '041'+"".join(choice(digits) for i in range(9))
+
+    @api.depends('address_home_id', 'user_partner_id')
+    def _compute_related_contacts(self):
+        super()._compute_related_contacts()
+        for employee in self:
+            employee.related_contact_ids |= employee.address_home_id | employee.user_partner_id
+
+    @api.depends('address_home_id.parent_id')
+    def _compute_is_address_home_a_company(self):
+        """Checks that chosen address (res.partner) is not linked to a company.
+        """
+        for employee in self:
+            try:
+                employee.is_address_home_a_company = employee.address_home_id.parent_id.id is not False
+            except AccessError:
+                employee.is_address_home_a_company = False
+
+    def _get_tz(self):
+        # Finds the first valid timezone in his tz, his work hours tz,
+        #  the company calendar tz or UTC and returns it as a string
+        self.ensure_one()
+        return self.tz or\
+               self.resource_calendar_id.tz or\
+               self.company_id.resource_calendar_id.tz or\
+               'UTC'
+
+    def _get_tz_batch(self):
+        # Finds the first valid timezone in his tz, his work hours tz,
+        #  the company calendar tz or UTC
+        # Returns a dict {employee_id: tz}
+        return {emp.id: emp._get_tz() for emp in self}
+
+    # ---------------------------------------------------------
+    # Business Methods
+    # ---------------------------------------------------------
+
+    @api.model
+    def get_import_templates(self):
+        return [{
+            'label': _('Import Template for Employees'),
+            'template': '/hr/static/xls/hr_employee.xls'
+        }]
+
+    def _post_author(self):
+        """
+        When a user updates his own employee's data, all operations are performed
+        by super user. However, tracking messages should not be posted as OdooBot
+        but as the actual user.
+        This method is used in the overrides of `_message_log` and `message_post`
+        to post messages as the correct user.
+        """
+        real_user = self.env.context.get('binary_field_real_user')
+        if self.env.is_superuser() and real_user:
+            self = self.with_user(real_user)
+        return self
+
+    def _get_unusual_days(self, date_from, date_to=None):
+        # Checking the calendar directly allows to not grey out the leaves taken
+        # by the employee or fallback to the company calendar
+        return (self.resource_calendar_id or self.env.company.resource_calendar_id)._get_unusual_days(
+            datetime.combine(fields.Date.from_string(date_from), time.min).replace(tzinfo=UTC),
+            datetime.combine(fields.Date.from_string(date_to), time.max).replace(tzinfo=UTC)
+        )
+
+    def _get_expected_attendances(self, date_from, date_to, domain=None):
+        self.ensure_one()
+        employee_timezone = pytz.timezone(self.tz) if self.tz else None
+        calendar = self.resource_calendar_id or self.company_id.resource_calendar_id
+        calendar_intervals = calendar._work_intervals_batch(
+            date_from,
+            date_to,
+            tz=employee_timezone,
+            resources=self.resource_id,
+            compute_leaves=True,
+            domain=domain)[self.resource_id.id]
+        return calendar_intervals
+
+    # ---------------------------------------------------------
+    # Messaging
+    # ---------------------------------------------------------
+
+    def _message_log(self, **kwargs):
+        return super(HrEmployeePrivate, self._post_author())._message_log(**kwargs)
+
+    @api.returns('mail.message', lambda value: value.id)
+    def message_post(self, **kwargs):
+        return super(HrEmployeePrivate, self._post_author()).message_post(**kwargs)
+
+    def _sms_get_partner_fields(self):
+        return ['user_partner_id']
+
+    def _sms_get_number_fields(self):
+        return ['mobile_phone']

odoo-bringout-oca-ocb-hr/hr/models/hr_employee_base.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from ast import literal_eval
+
+from pytz import timezone, UTC, utc
+from datetime import timedelta
+
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError
+from odoo.tools import clean_context, format_time
+
+
+class HrEmployeeBase(models.AbstractModel):
+    _name = "hr.employee.base"
+    _description = "Basic Employee"
+    _order = 'name'
+
+    name = fields.Char()
+    active = fields.Boolean("Active")
+    color = fields.Integer('Color Index', default=0)
+    department_id = fields.Many2one('hr.department', 'Department', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    member_of_department = fields.Boolean("Member of department", compute='_compute_part_of_department', search='_search_part_of_department',
+        help="Whether the employee is a member of the active user's department or one of it's child department.")
+    job_id = fields.Many2one('hr.job', 'Job Position', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    job_title = fields.Char("Job Title", compute="_compute_job_title", store=True, readonly=False)
+    company_id = fields.Many2one('res.company', 'Company')
+    address_id = fields.Many2one('res.partner', 'Work Address', compute="_compute_address_id", store=True, readonly=False,
+        domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    work_phone = fields.Char('Work Phone', compute="_compute_phones", store=True, readonly=False)
+    mobile_phone = fields.Char('Work Mobile', compute="_compute_work_contact_details", store=True, inverse='_inverse_work_contact_details')
+    work_email = fields.Char('Work Email', compute="_compute_work_contact_details", store=True, inverse='_inverse_work_contact_details')
+    work_contact_id = fields.Many2one('res.partner', 'Work Contact', copy=False)
+    related_contact_ids = fields.Many2many('res.partner', string='Related Contacts', compute='_compute_related_contacts')
+    related_contacts_count = fields.Integer('Number of related contacts', compute='_compute_related_contacts_count')
+    work_location_id = fields.Many2one('hr.work.location', 'Work Location', compute="_compute_work_location_id", store=True, readonly=False,
+    domain="[('address_id', '=', address_id), '|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    user_id = fields.Many2one('res.users')
+    resource_id = fields.Many2one('resource.resource')
+    resource_calendar_id = fields.Many2one('resource.calendar', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    parent_id = fields.Many2one('hr.employee', 'Manager', compute="_compute_parent_id", store=True, readonly=False,
+        domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    coach_id = fields.Many2one(
+        'hr.employee', 'Coach', compute='_compute_coach', store=True, readonly=False,
+        domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
+        help='Select the "Employee" who is the coach of this employee.\n'
+             'The "Coach" has no specific rights or responsibilities by default.')
+    tz = fields.Selection(
+        string='Timezone', related='resource_id.tz', readonly=False,
+        help="This field is used in order to define in which timezone the resources will work.")
+    hr_presence_state = fields.Selection([
+        ('present', 'Present'),
+        ('absent', 'Absent'),
+        ('to_define', 'To Define')], compute='_compute_presence_state', default='to_define')
+    last_activity = fields.Date(compute="_compute_last_activity")
+    last_activity_time = fields.Char(compute="_compute_last_activity")
+    hr_icon_display = fields.Selection([
+        ('presence_present', 'Present'),
+        ('presence_absent_active', 'Present but not active'),
+        ('presence_absent', 'Absent'),
+        ('presence_to_define', 'To define'),
+        ('presence_undetermined', 'Undetermined')], compute='_compute_presence_icon')
+    show_hr_icon_display = fields.Boolean(compute='_compute_presence_icon')
+    employee_type = fields.Selection([
+        ('employee', 'Employee'),
+        ('student', 'Student'),
+        ('trainee', 'Trainee'),
+        ('contractor', 'Contractor'),
+        ('freelance', 'Freelancer'),
+        ], string='Employee Type', default='employee', required=True,
+        help="The employee type. Although the primary purpose may seem to categorize employees, this field has also an impact in the Contract History. Only Employee type is supposed to be under contract and will have a Contract History.")
+
+
+    def _get_valid_employee_for_user(self):
+        user = self.env.user
+        # retrieve the employee of the current active company for the user
+        employee = user.employee_id
+        if not employee:
+            # search for all employees as superadmin to not get blocked by multi-company rules
+            user_employees = user.employee_id.sudo().search([
+                ('user_id', '=', user.id)
+            ])
+            # the default company employee is most likely the correct one, but fallback to the first if not available
+            employee = user_employees.filtered(lambda r: r.company_id == user.company_id) or user_employees[:1]
+        return employee
+
+    @api.depends_context('uid', 'company')
+    @api.depends('department_id')
+    def _compute_part_of_department(self):
+        user_employee = self._get_valid_employee_for_user()
+        active_department = user_employee.department_id
+        if not active_department:
+            self.member_of_department = False
+        else:
+            def get_all_children(department):
+                children = department.child_ids
+                if not children:
+                    return self.env['hr.department']
+                return children + get_all_children(children)
+
+            child_departments = active_department + get_all_children(active_department)
+            for employee in self:
+                employee.member_of_department = employee.department_id in child_departments
+
+    def _search_part_of_department(self, operator, value):
+        if operator not in ('=', '!=') or not isinstance(value, bool):
+            raise UserError(_('Operation not supported'))
+
+        user_employee = self._get_valid_employee_for_user()
+        # Double negation
+        if not value:
+            operator = '!=' if operator == '=' else '='
+        if not user_employee.department_id:
+            return [('id', operator, user_employee.id)]
+        return (['!'] if operator == '!=' else []) + [('department_id', 'child_of', user_employee.department_id.id)]
+
+    @api.depends('user_id.im_status')
+    def _compute_presence_state(self):
+        """
+        This method is overritten in several other modules which add additional
+        presence criterions. e.g. hr_attendance, hr_holidays
+        """
+        # Check on login
+        check_login = literal_eval(self.env['ir.config_parameter'].sudo().get_param('hr.hr_presence_control_login', 'False'))
+        employee_to_check_working = self.filtered(lambda e: e.user_id.im_status == 'offline')
+        working_now_list = employee_to_check_working._get_employee_working_now()
+        for employee in self:
+            state = 'to_define'
+            if check_login:
+                if employee.user_id.im_status in ['online', 'leave_online']:
+                    state = 'present'
+                elif employee.user_id.im_status in ['offline', 'leave_offline'] and employee.id not in working_now_list:
+                    state = 'absent'
+            employee.hr_presence_state = state
+
+    @api.depends('user_id')
+    def _compute_last_activity(self):
+        presences = self.env['bus.presence'].search_read([('user_id', 'in', self.mapped('user_id').ids)], ['user_id', 'last_presence'])
+        # transform the result to a dict with this format {user.id: last_presence}
+        presences = {p['user_id'][0]: p['last_presence'] for p in presences}
+
+        for employee in self:
+            tz = employee.tz
+            last_presence = presences.get(employee.user_id.id, False)
+            if last_presence:
+                last_activity_datetime = last_presence.replace(tzinfo=UTC).astimezone(timezone(tz)).replace(tzinfo=None)
+                employee.last_activity = last_activity_datetime.date()
+                if employee.last_activity == fields.Date.today():
+                    employee.last_activity_time = format_time(self.env, last_presence, time_format='short')
+                else:
+                    employee.last_activity_time = False
+            else:
+                employee.last_activity = False
+                employee.last_activity_time = False
+
+    @api.depends('parent_id')
+    def _compute_coach(self):
+        for employee in self:
+            manager = employee.parent_id
+            previous_manager = employee._origin.parent_id
+            if manager and (employee.coach_id == previous_manager or not employee.coach_id):
+                employee.coach_id = manager
+            elif not employee.coach_id:
+                employee.coach_id = False
+
+    @api.depends('job_id')
+    def _compute_job_title(self):
+        for employee in self.filtered('job_id'):
+            employee.job_title = employee.job_id.name
+
+    @api.depends('address_id')
+    def _compute_phones(self):
+        for employee in self:
+            if employee.address_id and employee.address_id.phone:
+                employee.work_phone = employee.address_id.phone
+            else:
+                employee.work_phone = False
+
+    @api.depends('work_contact_id', 'work_contact_id.mobile', 'work_contact_id.email')
+    def _compute_work_contact_details(self):
+        for employee in self:
+            if employee.work_contact_id:
+                employee.mobile_phone = employee.work_contact_id.mobile
+                employee.work_email = employee.work_contact_id.email
+
+    def _inverse_work_contact_details(self):
+        for employee in self:
+            if not employee.work_contact_id:
+                employee.work_contact_id = self.env['res.partner'].sudo().with_context(clean_context(self._context)).create({
+                    'email': employee.work_email,
+                    'mobile': employee.mobile_phone,
+                    'name': employee.name,
+                    'image_1920': employee.image_1920,
+                    'company_id': employee.company_id.id
+                })
+            else:
+                employee.work_contact_id.sudo().write({
+                    'email': employee.work_email,
+                    'mobile': employee.mobile_phone,
+                })
+
+    @api.depends('work_contact_id')
+    def _compute_related_contacts(self):
+        for employee in self:
+            employee.related_contact_ids = employee.work_contact_id
+
+    @api.depends('related_contact_ids')
+    def _compute_related_contacts_count(self):
+        for employee in self:
+            employee.related_contacts_count = len(employee.related_contact_ids)
+
+    def action_related_contacts(self):
+        self.ensure_one()
+        return {
+            'name': _("Related Contacts"),
+            'type': 'ir.actions.act_window',
+            'view_mode': 'kanban,tree,form',
+            'res_model': 'res.partner',
+            'domain': [('id', 'in', self.related_contact_ids.ids)]
+        }
+
+    @api.depends('company_id')
+    def _compute_address_id(self):
+        for employee in self:
+            address = employee.company_id.partner_id.address_get(['default'])
+            employee.address_id = address['default'] if address else False
+
+    @api.depends('department_id')
+    def _compute_parent_id(self):
+        for employee in self.filtered('department_id.manager_id'):
+            employee.parent_id = employee.department_id.manager_id
+
+    @api.depends('resource_calendar_id', 'hr_presence_state')
+    def _compute_presence_icon(self):
+        """
+        This method compute the state defining the display icon in the kanban view.
+        It can be overriden to add other possibilities, like time off or attendances recordings.
+        """
+        working_now_list = self.filtered(lambda e: e.hr_presence_state == 'present')._get_employee_working_now()
+        for employee in self:
+            show_icon = True
+            if employee.hr_presence_state == 'present':
+                if employee.id in working_now_list:
+                    icon = 'presence_present'
+                else:
+                    icon = 'presence_absent_active'
+            elif employee.hr_presence_state == 'absent':
+                # employee is not in the working_now_list and he has a user_id
+                icon = 'presence_absent'
+            else:
+                # without attendance, default employee state is 'to_define' without confirmed presence/absence
+                # we need to check why they are not there
+                # Display an orange icon on internal users.
+                icon = 'presence_to_define'
+                if not employee.user_id:
+                    # We don't want non-user employee to have icon.
+                    show_icon = False
+            employee.hr_icon_display = icon
+            employee.show_hr_icon_display = show_icon
+
+    @api.depends('address_id')
+    def _compute_work_location_id(self):
+        to_reset = self.filtered(lambda e: e.address_id != e.work_location_id.address_id)
+        to_reset.work_location_id = False
+
+    @api.model
+    def _get_employee_working_now(self):
+        working_now = []
+        # We loop over all the employee tz and the resource calendar_id to detect working hours in batch.
+        all_employee_tz = set(self.mapped('tz'))
+        for tz in all_employee_tz:
+            employee_ids = self.filtered(lambda e: e.tz == tz)
+            resource_calendar_ids = employee_ids.mapped('resource_calendar_id')
+            for calendar_id in resource_calendar_ids:
+                res_employee_ids = employee_ids.filtered(lambda e: e.resource_calendar_id.id == calendar_id.id)
+                start_dt = fields.Datetime.now()
+                stop_dt = start_dt + timedelta(hours=1)
+                from_datetime = utc.localize(start_dt).astimezone(timezone(tz or 'UTC'))
+                to_datetime = utc.localize(stop_dt).astimezone(timezone(tz or 'UTC'))
+                # Getting work interval of the first is working. Functions called on resource_calendar_id
+                # are waiting for singleton
+                work_interval = res_employee_ids[0].resource_calendar_id._work_intervals_batch(from_datetime, to_datetime)[False]
+                # Employee that is not supposed to work have empty items.
+                if len(work_interval._items) > 0:
+                    # The employees should be working now according to their work schedule
+                    working_now += res_employee_ids.ids
+        return working_now

odoo-bringout-oca-ocb-hr/hr/models/hr_employee_category.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from random import randint
+
+from odoo import fields, models
+
+
+class EmployeeCategory(models.Model):
+
+    _name = "hr.employee.category"
+    _description = "Employee Category"
+
+    def _get_default_color(self):
+        return randint(1, 11)
+
+    name = fields.Char(string="Tag Name", required=True)
+    color = fields.Integer(string='Color Index', default=_get_default_color)
+    employee_ids = fields.Many2many('hr.employee', 'employee_category_rel', 'category_id', 'emp_id', string='Employees')
+
+    _sql_constraints = [
+        ('name_uniq', 'unique (name)', "Tag name already exists !"),
+    ]

odoo-bringout-oca-ocb-hr/hr/models/hr_employee_public.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, tools
+
+
+class HrEmployeePublic(models.Model):
+    _name = "hr.employee.public"
+    _inherit = ["hr.employee.base"]
+    _description = 'Public Employee'
+    _order = 'name'
+    _auto = False
+    _log_access = True # Include magic fields
+
+    # Fields coming from hr.employee.base
+    create_date = fields.Datetime(readonly=True)
+    name = fields.Char(readonly=True)
+    active = fields.Boolean(readonly=True)
+    department_id = fields.Many2one(readonly=True)
+    job_id = fields.Many2one(readonly=True)
+    job_title = fields.Char(readonly=True)
+    company_id = fields.Many2one(readonly=True)
+    address_id = fields.Many2one(readonly=True)
+    mobile_phone = fields.Char(readonly=True)
+    work_phone = fields.Char(readonly=True)
+    work_email = fields.Char(readonly=True)
+    work_contact_id = fields.Many2one(readonly=True)
+    related_contact_ids = fields.Many2many(readonly=True)
+    work_location_id = fields.Many2one(readonly=True)
+    user_id = fields.Many2one(readonly=True)
+    resource_id = fields.Many2one(readonly=True)
+    resource_calendar_id = fields.Many2one(readonly=True)
+    tz = fields.Selection(readonly=True)
+    color = fields.Integer(readonly=True)
+    employee_type = fields.Selection(readonly=True)
+
+    employee_id = fields.Many2one('hr.employee', 'Employee', compute="_compute_employee_id", search="_search_employee_id", compute_sudo=True)
+    # hr.employee.public specific fields
+    child_ids = fields.One2many('hr.employee.public', 'parent_id', string='Direct subordinates', readonly=True)
+    image_1920 = fields.Image("Image", related='employee_id.image_1920', compute_sudo=True)
+    image_1024 = fields.Image("Image 1024", related='employee_id.image_1024', compute_sudo=True)
+    image_512 = fields.Image("Image 512", related='employee_id.image_512', compute_sudo=True)
+    image_256 = fields.Image("Image 256", related='employee_id.image_256', compute_sudo=True)
+    image_128 = fields.Image("Image 128", related='employee_id.image_128', compute_sudo=True)
+    avatar_1920 = fields.Image("Avatar", related='employee_id.avatar_1920', compute_sudo=True)
+    avatar_1024 = fields.Image("Avatar 1024", related='employee_id.avatar_1024', compute_sudo=True)
+    avatar_512 = fields.Image("Avatar 512", related='employee_id.avatar_512', compute_sudo=True)
+    avatar_256 = fields.Image("Avatar 256", related='employee_id.avatar_256', compute_sudo=True)
+    avatar_128 = fields.Image("Avatar 128", related='employee_id.avatar_128', compute_sudo=True)
+    parent_id = fields.Many2one('hr.employee.public', 'Manager', readonly=True)
+    coach_id = fields.Many2one('hr.employee.public', 'Coach', readonly=True)
+    user_partner_id = fields.Many2one(related='user_id.partner_id', related_sudo=False, string="User's partner")
+
+    def _search_employee_id(self, operator, value):
+        return [('id', operator, value)]
+
+    def _compute_employee_id(self):
+        for employee in self:
+            employee.employee_id = self.env['hr.employee'].browse(employee.id)
+
+    @api.depends('user_partner_id')
+    def _compute_related_contacts(self):
+        super()._compute_related_contacts()
+        for employee in self:
+            employee.related_contact_ids |= employee.user_partner_id
+
+    @api.model
+    def _get_fields(self):
+        return ','.join('emp.%s' % name for name, field in self._fields.items() if field.store and field.type not in ['many2many', 'one2many'])
+
+    def init(self):
+        tools.drop_view_if_exists(self.env.cr, self._table)
+        self.env.cr.execute("""CREATE or REPLACE VIEW %s as (
+            SELECT
+                %s
+            FROM hr_employee emp
+        )""" % (self._table, self._get_fields()))

odoo-bringout-oca-ocb-hr/hr/models/hr_job.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.addons.web_editor.controllers.main import handle_history_divergence
+
+
+class Job(models.Model):
+
+    _name = "hr.job"
+    _description = "Job Position"
+    _inherit = ['mail.thread']
+    _order = 'sequence'
+
+    active = fields.Boolean(default=True)
+    name = fields.Char(string='Job Position', required=True, index='trigram', translate=True)
+    sequence = fields.Integer(default=10)
+    expected_employees = fields.Integer(compute='_compute_employees', string='Total Forecasted Employees', store=True,
+        help='Expected number of employees for this job position after new recruitment.')
+    no_of_employee = fields.Integer(compute='_compute_employees', string="Current Number of Employees", store=True,
+        help='Number of employees currently occupying this job position.')
+    no_of_recruitment = fields.Integer(string='Target', copy=False,
+        help='Number of new employees you expect to recruit.', default=1)
+    no_of_hired_employee = fields.Integer(string='Hired Employees', copy=False,
+        help='Number of hired employees for this job position during recruitment phase.')
+    employee_ids = fields.One2many('hr.employee', 'job_id', string='Employees', groups='base.group_user')
+    description = fields.Html(string='Job Description', sanitize_attributes=False)
+    requirements = fields.Text('Requirements')
+    department_id = fields.Many2one('hr.department', string='Department', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    company_id = fields.Many2one('res.company', string='Company', default=lambda self: self.env.company)
+    contract_type_id = fields.Many2one('hr.contract.type', string='Employment Type')
+
+    _sql_constraints = [
+        ('name_company_uniq', 'unique(name, company_id, department_id)', 'The name of the job position must be unique per department in company!'),
+        ('no_of_recruitment_positive', 'CHECK(no_of_recruitment >= 0)', 'The expected number of new employees must be positive.')
+    ]
+
+    @api.depends('no_of_recruitment', 'employee_ids.job_id', 'employee_ids.active')
+    def _compute_employees(self):
+        employee_data = self.env['hr.employee']._read_group([('job_id', 'in', self.ids)], ['job_id'], ['job_id'])
+        result = dict((data['job_id'][0], data['job_id_count']) for data in employee_data)
+        for job in self:
+            job.no_of_employee = result.get(job.id, 0)
+            job.expected_employees = result.get(job.id, 0) + job.no_of_recruitment
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        """ We don't want the current user to be follower of all created job """
+        return super(Job, self.with_context(mail_create_nosubscribe=True)).create(vals_list)
+
+    @api.returns('self', lambda value: value.id)
+    def copy(self, default=None):
+        self.ensure_one()
+        default = dict(default or {})
+        if 'name' not in default:
+            default['name'] = _("%s (copy)") % (self.name)
+        return super(Job, self).copy(default=default)
+
+    def write(self, vals):
+        if len(self) == 1:
+            handle_history_divergence(self, 'description', vals)
+        return super(Job, self).write(vals)

odoo-bringout-oca-ocb-hr/hr/models/hr_plan.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models
+
+
+class HrPlan(models.Model):
+    _name = 'hr.plan'
+    _description = 'plan'
+
+    name = fields.Char('Name', required=True)
+    company_id = fields.Many2one(
+        'res.company', default=lambda self: self.env.company)
+    department_id = fields.Many2one('hr.department', check_company=True)
+    plan_activity_type_ids = fields.One2many(
+        'hr.plan.activity.type', 'plan_id',
+        string='Activities',
+        domain="[('company_id', '=', company_id)]")
+    active = fields.Boolean(default=True)
+    steps_count = fields.Integer(compute='_compute_steps_count')
+
+    @api.depends('plan_activity_type_ids')
+    def _compute_steps_count(self):
+        activity_type_data = self.env['hr.plan.activity.type']._read_group([('plan_id', 'in', self.ids)], ['plan_id'], ['plan_id'])
+        steps_count = {x['plan_id'][0]: x['plan_id_count'] for x in activity_type_data}
+        for plan in self:
+            plan.steps_count = steps_count.get(plan.id, 0)

odoo-bringout-oca-ocb-hr/hr/models/hr_plan_activity_type.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import UserError
+
+
+class HrPlanActivityType(models.Model):
+    _name = 'hr.plan.activity.type'
+    _description = 'Plan activity type'
+    _rec_name = 'summary'
+    _check_company_auto = True
+
+    company_id = fields.Many2one('res.company', default=lambda self: self.env.company)
+    activity_type_id = fields.Many2one(
+        'mail.activity.type', 'Activity Type',
+        default=lambda self: self.env.ref('mail.mail_activity_data_todo'),
+        domain=lambda self: ['|', ('res_model', '=', False), ('res_model', '=', 'hr.employee')],
+        ondelete='restrict'
+    )
+    summary = fields.Char('Summary', compute="_compute_default_summary", store=True, readonly=False)
+    responsible = fields.Selection([
+        ('coach', 'Coach'),
+        ('manager', 'Manager'),
+        ('employee', 'Employee'),
+        ('other', 'Other')], default='employee', string='Responsible', required=True)
+    responsible_id = fields.Many2one(
+        'res.users',
+        'Other Responsible',
+        check_company=True,
+        help='Specific responsible of activity if not linked to the employee.')
+    plan_id = fields.Many2one('hr.plan')
+    note = fields.Html('Note')
+
+    @api.depends('activity_type_id')
+    def _compute_default_summary(self):
+        for plan_type in self:
+            if plan_type.activity_type_id and plan_type.activity_type_id.summary:
+                plan_type.summary = plan_type.activity_type_id.summary
+            else:
+                plan_type.summary = False
+
+    def get_responsible_id(self, employee):
+        warning = False
+        if self.responsible == 'coach':
+            if not employee.coach_id:
+                warning = _('Coach of employee %s is not set.', employee.name)
+            responsible = employee.coach_id.user_id
+            if employee.coach_id and not responsible:
+                warning = _("The user of %s's coach is not set.", employee.name)
+        elif self.responsible == 'manager':
+            if not employee.parent_id:
+                warning = _('Manager of employee %s is not set.', employee.name)
+            responsible = employee.parent_id.user_id
+            if employee.parent_id and not responsible:
+                warning = _("The manager of %s should be linked to a user.", employee.name)
+        elif self.responsible == 'employee':
+            responsible = employee.user_id
+            if not responsible:
+                warning = _('The employee %s should be linked to a user.', employee.name)
+        elif self.responsible == 'other':
+            responsible = self.responsible_id
+            if not responsible:
+                warning = _('No specific user given on activity %s.', self.activity_type_id.name)
+        return {
+            'responsible': responsible,
+            'warning': warning,
+        }

odoo-bringout-oca-ocb-hr/hr/models/hr_work_location.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models
+
+
+class WorkLocation(models.Model):
+    _name = "hr.work.location"
+    _description = "Work Location"
+    _order = 'name'
+
+    active = fields.Boolean(default=True)
+    name = fields.Char(string="Work Location", required=True)
+    company_id = fields.Many2one('res.company', required=True, default=lambda self: self.env.company)
+    address_id = fields.Many2one('res.partner', required=True, string="Work Address", domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
+    location_number = fields.Char()

odoo-bringout-oca-ocb-hr/hr/models/ir_ui_menu.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models, api, tools
+
+
+class IrUiMenu(models.Model):
+    _inherit = 'ir.ui.menu'
+
+    def _load_menus_blacklist(self):
+        res = super()._load_menus_blacklist()
+        emp_menu = self.env.ref('hr.menu_hr_employee', raise_if_not_found=False)
+        if emp_menu and self.env.user.has_group('hr.group_hr_user'):
+            res.append(emp_menu.id)
+        return res

odoo-bringout-oca-ocb-hr/hr/models/mail_alias.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models, _
+
+
+class Alias(models.Model):
+    _inherit = 'mail.alias'
+
+    alias_contact = fields.Selection(selection_add=[
+        ('employees', 'Authenticated Employees'),
+    ], ondelete={'employees': 'cascade'})
+
+    def _get_alias_contact_description(self):
+        if self.alias_contact == 'employees':
+            return _('addresses linked to registered employees')
+        return super(Alias, self)._get_alias_contact_description()

odoo-bringout-oca-ocb-hr/hr/models/mail_channel.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError
+
+
+class Channel(models.Model):
+    _inherit = 'mail.channel'
+
+    subscription_department_ids = fields.Many2many(
+        'hr.department', string='HR Departments',
+        help='Automatically subscribe members of those departments to the channel.')
+
+    @api.constrains('subscription_department_ids')
+    def _constraint_subscription_department_ids_channel(self):
+        failing_channels = self.sudo().filtered(lambda channel: channel.channel_type != 'channel' and channel.subscription_department_ids)
+        if failing_channels:
+            raise ValidationError(_("For %(channels)s, channel_type should be 'channel' to have the department auto-subscription.", channels=', '.join([ch.name for ch in failing_channels])))
+
+    def _subscribe_users_automatically_get_members(self):
+        """ Auto-subscribe members of a department to a channel """
+        new_members = super(Channel, self)._subscribe_users_automatically_get_members()
+        for channel in self:
+            new_members[channel.id] = list(
+                set(new_members[channel.id]) |
+                set((channel.subscription_department_ids.member_ids.user_id.partner_id.filtered(lambda p: p.active) - channel.channel_partner_ids).ids)
+            )
+        return new_members
+
+    def write(self, vals):
+        res = super(Channel, self).write(vals)
+        if vals.get('subscription_department_ids'):
+            self._subscribe_users_automatically()
+        return res

odoo-bringout-oca-ocb-hr/hr/models/models.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models, tools, _
+
+
+class BaseModel(models.AbstractModel):
+    _inherit = 'base'
+
+    def _alias_get_error_message(self, message, message_dict, alias):
+        if alias.alias_contact == 'employees':
+            email_from = tools.decode_message_header(message, 'From')
+            email_address = tools.email_split(email_from)[0]
+            employee = self.env['hr.employee'].search([('work_email', 'ilike', email_address)], limit=1)
+            if not employee:
+                employee = self.env['hr.employee'].search([('user_id.email', 'ilike', email_address)], limit=1)
+            if not employee:
+                return _('restricted to employees')
+            return False
+        return super(BaseModel, self)._alias_get_error_message(message, message_dict, alias)

odoo-bringout-oca-ocb-hr/hr/models/res_company.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models
+
+
+class Company(models.Model):
+    _inherit = 'res.company'
+
+    hr_presence_control_email_amount = fields.Integer(string="# emails to send")
+    hr_presence_control_ip_list = fields.Char(string="Valid IP addresses")

odoo-bringout-oca-ocb-hr/hr/models/res_config_settings.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+import threading
+from odoo import fields, models, api, _
+from odoo.exceptions import ValidationError
+
+
+class ResConfigSettings(models.TransientModel):
+    _inherit = 'res.config.settings'
+
+    resource_calendar_id = fields.Many2one(
+        'resource.calendar', 'Company Working Hours',
+        related='company_id.resource_calendar_id', readonly=False)
+    module_hr_presence = fields.Boolean(string="Advanced Presence Control")
+    module_hr_skills = fields.Boolean(string="Skills Management")
+    module_hr_homeworking = fields.Boolean(string="Homeworking")
+    hr_presence_control_login = fields.Boolean(string="Based on user status in system", config_parameter='hr.hr_presence_control_login')
+    hr_presence_control_email = fields.Boolean(string="Based on number of emails sent", config_parameter='hr_presence.hr_presence_control_email')
+    hr_presence_control_ip = fields.Boolean(string="Based on IP Address", config_parameter='hr_presence.hr_presence_control_ip')
+    module_hr_attendance = fields.Boolean(string="Based on attendances")
+    hr_presence_control_email_amount = fields.Integer(related="company_id.hr_presence_control_email_amount", readonly=False)
+    hr_presence_control_ip_list = fields.Char(related="company_id.hr_presence_control_ip_list", readonly=False)
+    hr_employee_self_edit = fields.Boolean(string="Employee Editing", config_parameter='hr.hr_employee_self_edit')
+
+    @api.constrains('module_hr_presence', 'hr_presence_control_email', 'hr_presence_control_ip')
+    def _check_advanced_presence(self):
+        test_mode = self.env.registry.in_test_mode() or getattr(threading.current_thread(), 'testing', False)
+        if self.env.context.get('install_mode', False) or test_mode:
+            return
+
+        for settings in self:
+            if settings.module_hr_presence and not (settings.hr_presence_control_email or settings.hr_presence_control_ip):
+                raise ValidationError(_('You should select at least one Advanced Presence Control option.'))

odoo-bringout-oca-ocb-hr/hr/models/res_partner.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import AccessError
+
+
+class Partner(models.Model):
+    _inherit = ['res.partner']
+
+    employee_ids = fields.One2many(
+        'hr.employee', 'address_home_id', string='Employees', groups="hr.group_hr_user",
+        help="Related employees based on their private address")
+    employees_count = fields.Integer(compute='_compute_employees_count', groups="hr.group_hr_user")
+
+    def name_get(self):
+        """ Override to allow an employee to see its private address in his profile.
+            This avoids to relax access rules on `res.parter` and to add an `ir.rule`.
+            (advantage in both security and performance).
+            Use a try/except instead of systematically checking to minimize the impact on performance.
+            """
+        try:
+            return super(Partner, self).name_get()
+        except AccessError as e:
+            if len(self) == 1 and self in self.env.user.employee_ids.mapped('address_home_id'):
+                return super(Partner, self.sudo()).name_get()
+            raise e
+
+    def _compute_employees_count(self):
+        for partner in self:
+            partner.employees_count = len(partner.employee_ids)
+
+    def action_open_employees(self):
+        self.ensure_one()
+        return {
+            'name': _('Related Employees'),
+            'type': 'ir.actions.act_window',
+            'res_model': 'hr.employee',
+            'view_mode': 'kanban,tree,form',
+            'domain': [('id', 'in', self.employee_ids.ids)],
+        }
+
+class ResPartnerBank(models.Model):
+    _inherit = ['res.partner.bank']
+
+    @api.depends_context('uid')
+    def _compute_display_name(self):
+        account_employee = self.browse()
+        if not self.user_has_groups('hr.group_hr_user'):
+            account_employee = self.sudo().filtered("partner_id.employee_ids")
+            for account in account_employee:
+                account.sudo(self.env.su).display_name = \
+                    account.acc_number[:2] + "*" * len(account.acc_number[2:-4]) + account.acc_number[-4:]
+        super(ResPartnerBank, self - account_employee)._compute_display_name()

odoo-bringout-oca-ocb-hr/hr/models/res_users.py

@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, models, fields, _, SUPERUSER_ID
+from odoo.exceptions import AccessError
+from odoo.tools.misc import clean_context
+
+
+HR_READABLE_FIELDS = [
+    'active',
+    'child_ids',
+    'employee_id',
+    'address_home_id',
+    'employee_ids',
+    'employee_parent_id',
+    'hr_presence_state',
+    'last_activity',
+    'last_activity_time',
+    'can_edit',
+    'is_system',
+    'employee_resource_calendar_id',
+]
+
+HR_WRITABLE_FIELDS = [
+    'additional_note',
+    'private_street',
+    'private_street2',
+    'private_city',
+    'private_state_id',
+    'private_zip',
+    'private_country_id',
+    'address_id',
+    'barcode',
+    'birthday',
+    'category_ids',
+    'children',
+    'coach_id',
+    'country_of_birth',
+    'department_id',
+    'display_name',
+    'emergency_contact',
+    'emergency_phone',
+    'employee_bank_account_id',
+    'employee_country_id',
+    'gender',
+    'identification_id',
+    'is_address_home_a_company',
+    'job_title',
+    'private_email',
+    'km_home_work',
+    'marital',
+    'mobile_phone',
+    'notes',
+    'employee_parent_id',
+    'passport_id',
+    'permit_no',
+    'employee_phone',
+    'pin',
+    'place_of_birth',
+    'spouse_birthdate',
+    'spouse_complete_name',
+    'visa_expire',
+    'visa_no',
+    'work_email',
+    'work_location_id',
+    'work_phone',
+    'certificate',
+    'study_field',
+    'study_school',
+    'private_lang',
+    'employee_type',
+]
+
+
+class User(models.Model):
+    _inherit = ['res.users']
+
+    def _employee_ids_domain(self):
+        # employee_ids is considered a safe field and as such will be fetched as sudo.
+        # So try to enforce the security rules on the field to make sure we do not load employees outside of active companies
+        return [('company_id', 'in', self.env.company.ids + self.env.context.get('allowed_company_ids', []))]
+
+    # note: a user can only be linked to one employee per company (see sql constraint in ´hr.employee´)
+    employee_ids = fields.One2many('hr.employee', 'user_id', string='Related employee', domain=_employee_ids_domain)
+    employee_id = fields.Many2one('hr.employee', string="Company employee",
+        compute='_compute_company_employee', search='_search_company_employee', store=False)
+
+    job_title = fields.Char(related='employee_id.job_title', readonly=False, related_sudo=False)
+    work_phone = fields.Char(related='employee_id.work_phone', readonly=False, related_sudo=False)
+    mobile_phone = fields.Char(related='employee_id.mobile_phone', readonly=False, related_sudo=False)
+    employee_phone = fields.Char(related='employee_id.phone', readonly=False, related_sudo=False)
+    work_email = fields.Char(related='employee_id.work_email', readonly=False, related_sudo=False)
+    category_ids = fields.Many2many(related='employee_id.category_ids', string="Employee Tags", readonly=False, related_sudo=False)
+    department_id = fields.Many2one(related='employee_id.department_id', readonly=False, related_sudo=False)
+    address_id = fields.Many2one(related='employee_id.address_id', readonly=False, related_sudo=False)
+    work_location_id = fields.Many2one(related='employee_id.work_location_id', readonly=False, related_sudo=False)
+    employee_parent_id = fields.Many2one(related='employee_id.parent_id', readonly=False, related_sudo=False)
+    coach_id = fields.Many2one(related='employee_id.coach_id', readonly=False, related_sudo=False)
+    address_home_id = fields.Many2one(related='employee_id.address_home_id', readonly=False, related_sudo=False)
+    private_street = fields.Char(related='address_home_id.street', string="Private Street", readonly=False, related_sudo=False)
+    private_street2 = fields.Char(related='address_home_id.street2', string="Private Street2", readonly=False, related_sudo=False)
+    private_city = fields.Char(related='address_home_id.city', string="Private City", readonly=False, related_sudo=False)
+    private_state_id = fields.Many2one(
+        related='address_home_id.state_id', string="Private State", readonly=False, related_sudo=False,
+        domain="[('country_id', '=?', private_country_id)]")
+    private_zip = fields.Char(related='address_home_id.zip', readonly=False, string="Private Zip", related_sudo=False)
+    private_country_id = fields.Many2one(related='address_home_id.country_id', string="Private Country", readonly=False, related_sudo=False)
+    is_address_home_a_company = fields.Boolean(related='employee_id.is_address_home_a_company', readonly=False, related_sudo=False)
+    private_email = fields.Char(related='address_home_id.email', string="Private Email", readonly=False)
+    private_lang = fields.Selection(related='address_home_id.lang', string="Employee Lang", readonly=False)
+    km_home_work = fields.Integer(related='employee_id.km_home_work', readonly=False, related_sudo=False)
+    # res.users already have a field bank_account_id and country_id from the res.partner inheritance: don't redefine them
+    employee_bank_account_id = fields.Many2one(related='employee_id.bank_account_id', string="Employee's Bank Account Number", related_sudo=False, readonly=False)
+    employee_country_id = fields.Many2one(related='employee_id.country_id', string="Employee's Country", readonly=False, related_sudo=False)
+    identification_id = fields.Char(related='employee_id.identification_id', readonly=False, related_sudo=False)
+    passport_id = fields.Char(related='employee_id.passport_id', readonly=False, related_sudo=False)
+    gender = fields.Selection(related='employee_id.gender', readonly=False, related_sudo=False)
+    birthday = fields.Date(related='employee_id.birthday', readonly=False, related_sudo=False)
+    place_of_birth = fields.Char(related='employee_id.place_of_birth', readonly=False, related_sudo=False)
+    country_of_birth = fields.Many2one(related='employee_id.country_of_birth', readonly=False, related_sudo=False)
+    marital = fields.Selection(related='employee_id.marital', readonly=False, related_sudo=False)
+    spouse_complete_name = fields.Char(related='employee_id.spouse_complete_name', readonly=False, related_sudo=False)
+    spouse_birthdate = fields.Date(related='employee_id.spouse_birthdate', readonly=False, related_sudo=False)
+    children = fields.Integer(related='employee_id.children', readonly=False, related_sudo=False)
+    emergency_contact = fields.Char(related='employee_id.emergency_contact', readonly=False, related_sudo=False)
+    emergency_phone = fields.Char(related='employee_id.emergency_phone', readonly=False, related_sudo=False)
+    visa_no = fields.Char(related='employee_id.visa_no', readonly=False, related_sudo=False)
+    permit_no = fields.Char(related='employee_id.permit_no', readonly=False, related_sudo=False)
+    visa_expire = fields.Date(related='employee_id.visa_expire', readonly=False, related_sudo=False)
+    additional_note = fields.Text(related='employee_id.additional_note', readonly=False, related_sudo=False)
+    barcode = fields.Char(related='employee_id.barcode', readonly=False, related_sudo=False)
+    pin = fields.Char(related='employee_id.pin', readonly=False, related_sudo=False)
+    certificate = fields.Selection(related='employee_id.certificate', readonly=False, related_sudo=False)
+    study_field = fields.Char(related='employee_id.study_field', readonly=False, related_sudo=False)
+    study_school = fields.Char(related='employee_id.study_school', readonly=False, related_sudo=False)
+    employee_count = fields.Integer(compute='_compute_employee_count')
+    hr_presence_state = fields.Selection(related='employee_id.hr_presence_state')
+    last_activity = fields.Date(related='employee_id.last_activity')
+    last_activity_time = fields.Char(related='employee_id.last_activity_time')
+    employee_type = fields.Selection(related='employee_id.employee_type', readonly=False, related_sudo=False)
+    employee_resource_calendar_id = fields.Many2one(related='employee_id.resource_calendar_id', string="Employee's Working Hours", readonly=True)
+
+    create_employee = fields.Boolean(store=False, default=True, copy=False, string="Technical field, whether to create an employee")
+    create_employee_id = fields.Many2one('hr.employee', store=False, copy=False, string="Technical field, bind user to this employee on create")
+
+    can_edit = fields.Boolean(compute='_compute_can_edit')
+    is_system = fields.Boolean(compute="_compute_is_system")
+
+    @api.depends_context('uid')
+    def _compute_is_system(self):
+        self.is_system = self.env.user._is_system()
+
+    def _compute_can_edit(self):
+        can_edit = self.env['ir.config_parameter'].sudo().get_param('hr.hr_employee_self_edit') or self.env.user.has_group('hr.group_hr_user')
+        for user in self:
+            user.can_edit = can_edit
+
+    @api.depends('employee_ids')
+    def _compute_employee_count(self):
+        for user in self.with_context(active_test=False):
+            user.employee_count = len(user.employee_ids)
+
+    @property
+    def SELF_READABLE_FIELDS(self):
+        return super().SELF_READABLE_FIELDS + HR_READABLE_FIELDS + HR_WRITABLE_FIELDS
+
+    @property
+    def SELF_WRITEABLE_FIELDS(self):
+        return super().SELF_WRITEABLE_FIELDS + HR_WRITABLE_FIELDS
+
+    @api.model
+    def get_views(self, views, options=None):
+        # Requests the My Profile form view as last.
+        # Otherwise the fields of the 'search' view will take precedence
+        # and will omit the fields that are requested as SUPERUSER
+        # in `get_view()`.
+        profile_view = self.env.ref("hr.res_users_view_form_profile")
+        profile_form = profile_view and [profile_view.id, 'form']
+        if profile_form and profile_form in views:
+            views.remove(profile_form)
+            views.append(profile_form)
+        result = super().get_views(views, options)
+        return result
+
+    @api.model
+    def get_view(self, view_id=None, view_type='form', **options):
+        # When the front-end loads the views it gets the list of available fields
+        # for the user (according to its access rights). Later, when the front-end wants to
+        # populate the view with data, it only asks to read those available fields.
+        # However, in this case, we want the user to be able to read/write its own data,
+        # even if they are protected by groups.
+        # We make the front-end aware of those fields by sending all field definitions.
+        # Note: limit the `sudo` to the only action of "editing own profile" action in order to
+        # avoid breaking `groups` mecanism on res.users form view.
+        profile_view = self.env.ref("hr.res_users_view_form_profile")
+        if profile_view and view_id == profile_view.id:
+            self = self.with_user(SUPERUSER_ID)
+        result = super(User, self).get_view(view_id, view_type, **options)
+        return result
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        res = super().create(vals_list)
+        employee_create_vals = []
+        for user, vals in zip(res, vals_list):
+            if not vals.get('create_employee') and not vals.get('create_employee_id'):
+                continue
+            if vals.get('create_employee_id'):
+                self.env['hr.employee'].browse(vals.get('create_employee_id')).user_id = user
+            else:
+                employee_create_vals.append(dict(
+                    name=user.name,
+                    company_id=user.env.company.id,
+                    **self.env['hr.employee']._sync_user(user)
+                ))
+        if employee_create_vals:
+            self.env['hr.employee'].with_context(clean_context(self.env.context)).create(employee_create_vals)
+        return res
+
+    def _get_employee_fields_to_sync(self):
+        """Get values to sync to the related employee when the User is changed.
+        """
+        return ['name', 'email', 'image_1920', 'tz']
+
+    def write(self, vals):
+        """
+        Synchronize user and its related employee
+        and check access rights if employees are not allowed to update
+        their own data (otherwise sudo is applied for self data).
+        """
+        hr_fields = {
+            field
+            for field_name, field in self._fields.items()
+            if field.related_field and field.related_field.model_name == 'hr.employee' and field_name in vals
+        }
+        can_edit_self = self.env['ir.config_parameter'].sudo().get_param('hr.hr_employee_self_edit') or self.env.user.has_group('hr.group_hr_user')
+        if hr_fields and not can_edit_self:
+            # Raise meaningful error message
+            raise AccessError(_("You are only allowed to update your preferences. Please contact a HR officer to update other information."))
+
+        result = super(User, self).write(vals)
+
+        employee_values = {}
+        for fname in [f for f in self._get_employee_fields_to_sync() if f in vals]:
+            employee_values[fname] = vals[fname]
+
+        if employee_values:
+            if 'email' in employee_values:
+                employee_values['work_email'] = employee_values.pop('email')
+            if 'image_1920' in vals:
+                without_image = self.env['hr.employee'].sudo().search([('user_id', 'in', self.ids), ('image_1920', '=', False)])
+                with_image = self.env['hr.employee'].sudo().search([('user_id', 'in', self.ids), ('image_1920', '!=', False)])
+                without_image.write(employee_values)
+                if not can_edit_self:
+                    employee_values.pop('image_1920')
+                with_image.write(employee_values)
+            else:
+                employees = self.env['hr.employee'].sudo().search([('user_id', 'in', self.ids)])
+                if employees:
+                    employees.write(employee_values)
+        return result
+
+    @api.model
+    def action_get(self):
+        if self.env.user.employee_id:
+            return self.env['ir.actions.act_window']._for_xml_id('hr.res_users_action_my')
+        return super(User, self).action_get()
+
+    @api.depends('employee_ids')
+    @api.depends_context('company')
+    def _compute_company_employee(self):
+        employee_per_user = {
+            employee.user_id: employee
+            for employee in self.env['hr.employee'].search([('user_id', 'in', self.ids), ('company_id', '=', self.env.company.id)])
+        }
+        for user in self:
+            user.employee_id = employee_per_user.get(user)
+
+    def _search_company_employee(self, operator, value):
+        return [('employee_ids', operator, value)]
+
+    def action_create_employee(self):
+        self.ensure_one()
+        self.env['hr.employee'].create(dict(
+            name=self.name,
+            company_id=self.env.company.id,
+            **self.env['hr.employee']._sync_user(self)
+        ))

odoo-bringout-oca-ocb-hr/hr/models/resource.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+from pytz import utc, timezone
+from datetime import datetime
+
+from odoo import fields, models
+from odoo.addons.resource.models.resource import Intervals
+
+
+class ResourceResource(models.Model):
+    _inherit = "resource.resource"
+
+    user_id = fields.Many2one(copy=False)
+    employee_id = fields.One2many('hr.employee', 'resource_id', domain="[('company_id', '=', company_id)]")