mirror of
https://github.com/bringout/oca-ocb-hr.git
synced 2026-04-27 01:52:08 +02:00
Initial commit: Hr packages
This commit is contained in:
Ernad Husremovic
commit
62531cd146
2820 changed files with 1432848 additions and 0 deletions
|
|
@ -0,0 +1,11 @@
|
|||
from . import hr_department
|
||||
from . import hr_recruitment
|
||||
from . import hr_employee
|
||||
from . import hr_job
|
||||
from . import res_config_settings
|
||||
from . import calendar
|
||||
from . import digest
|
||||
from . import utm_campaign
|
||||
from . import utm_source
|
||||
from . import res_users
|
||||
from . import ir_ui_menu
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import api, fields, models
|
||||
|
||||
|
||||
class CalendarEvent(models.Model):
|
||||
""" Model for Calendar Event """
|
||||
_inherit = 'calendar.event'
|
||||
|
||||
@api.model
|
||||
def default_get(self, fields):
|
||||
if self.env.context.get('default_applicant_id'):
|
||||
self = self.with_context(
|
||||
default_res_model='hr.applicant', #res_model seems to be lost without this
|
||||
default_res_model_id=self.env.ref('hr_recruitment.model_hr_applicant').id,
|
||||
default_res_id=self.env.context.get('default_applicant_id'),
|
||||
default_partner_ids=self.env.context.get('default_partner_ids'),
|
||||
default_name=self.env.context.get('default_name')
|
||||
)
|
||||
|
||||
defaults = super(CalendarEvent, self).default_get(fields)
|
||||
|
||||
# sync res_model / res_id to opportunity id (aka creating meeting from lead chatter)
|
||||
if 'applicant_id' not in defaults:
|
||||
res_model = defaults.get('res_model', False) or self.env.context.get('default_res_model')
|
||||
res_model_id = defaults.get('res_model_id', False) or self.env.context.get('default_res_model_id')
|
||||
if (res_model and res_model == 'hr.applicant') or (res_model_id and self.env['ir.model'].sudo().browse(res_model_id).model == 'hr.applicant'):
|
||||
defaults['applicant_id'] = defaults.get('res_id', False) or self.env.context.get('default_res_id', False)
|
||||
|
||||
return defaults
|
||||
|
||||
def _compute_is_highlighted(self):
|
||||
super(CalendarEvent, self)._compute_is_highlighted()
|
||||
applicant_id = self.env.context.get('active_id')
|
||||
if self.env.context.get('active_model') == 'hr.applicant' and applicant_id:
|
||||
for event in self:
|
||||
if event.applicant_id.id == applicant_id:
|
||||
event.is_highlighted = True
|
||||
|
||||
applicant_id = fields.Many2one('hr.applicant', string="Applicant", index='btree_not_null', ondelete='set null')
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import fields, models, _
|
||||
from odoo.exceptions import AccessError
|
||||
|
||||
|
||||
class Digest(models.Model):
|
||||
_inherit = 'digest.digest'
|
||||
|
||||
kpi_hr_recruitment_new_colleagues = fields.Boolean('New Employees')
|
||||
kpi_hr_recruitment_new_colleagues_value = fields.Integer(compute='_compute_kpi_hr_recruitment_new_colleagues_value')
|
||||
|
||||
def _compute_kpi_hr_recruitment_new_colleagues_value(self):
|
||||
if not self.env.user.has_group('hr_recruitment.group_hr_recruitment_user'):
|
||||
raise AccessError(_("Do not have access, skip this data for user's digest email"))
|
||||
for record in self:
|
||||
start, end, company = record._get_kpi_compute_parameters()
|
||||
new_colleagues = self.env['hr.employee'].search_count([
|
||||
('create_date', '>=', start),
|
||||
('create_date', '<', end),
|
||||
('company_id', '=', company.id)
|
||||
])
|
||||
record.kpi_hr_recruitment_new_colleagues_value = new_colleagues
|
||||
|
||||
def _compute_kpis_actions(self, company, user):
|
||||
res = super(Digest, self)._compute_kpis_actions(company, user)
|
||||
res['kpi_hr_recruitment_new_colleagues'] = 'hr.open_view_employee_list_my&menu_id=%s' % self.env.ref('hr.menu_hr_root').id
|
||||
return res
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
from odoo import api, fields, models
|
||||
|
||||
|
||||
class HrDepartment(models.Model):
|
||||
_inherit = 'hr.department'
|
||||
|
||||
new_applicant_count = fields.Integer(
|
||||
compute='_compute_new_applicant_count', string='New Applicant', compute_sudo=True)
|
||||
new_hired_employee = fields.Integer(
|
||||
compute='_compute_recruitment_stats', string='New Hired Employee')
|
||||
expected_employee = fields.Integer(
|
||||
compute='_compute_recruitment_stats', string='Expected Employee')
|
||||
|
||||
def _compute_new_applicant_count(self):
|
||||
if self.env.user.has_group('hr_recruitment.group_hr_recruitment_interviewer'):
|
||||
applicant_data = self.env['hr.applicant']._read_group(
|
||||
[('department_id', 'in', self.ids), ('stage_id.sequence', '<=', '1')],
|
||||
['department_id'], ['department_id'])
|
||||
result = dict((data['department_id'][0], data['department_id_count']) for data in applicant_data)
|
||||
for department in self:
|
||||
department.new_applicant_count = result.get(department.id, 0)
|
||||
else:
|
||||
self.new_applicant_count = 0
|
||||
|
||||
def _compute_recruitment_stats(self):
|
||||
job_data = self.env['hr.job']._read_group(
|
||||
[('department_id', 'in', self.ids)],
|
||||
['no_of_hired_employee', 'no_of_recruitment', 'department_id'], ['department_id'])
|
||||
new_emp = dict((data['department_id'][0], data['no_of_hired_employee']) for data in job_data)
|
||||
expected_emp = dict((data['department_id'][0], data['no_of_recruitment']) for data in job_data)
|
||||
for department in self:
|
||||
department.new_hired_employee = new_emp.get(department.id, 0)
|
||||
department.expected_employee = expected_emp.get(department.id, 0)
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import api, fields, models
|
||||
from odoo.tools.translate import _
|
||||
from datetime import timedelta
|
||||
|
||||
|
||||
class HrEmployee(models.Model):
|
||||
_inherit = "hr.employee"
|
||||
|
||||
newly_hired_employee = fields.Boolean('Newly hired employee', compute='_compute_newly_hired_employee',
|
||||
search='_search_newly_hired_employee')
|
||||
applicant_id = fields.One2many('hr.applicant', 'emp_id', 'Applicant')
|
||||
|
||||
def _compute_newly_hired_employee(self):
|
||||
now = fields.Datetime.now()
|
||||
for employee in self:
|
||||
employee.newly_hired_employee = bool(employee.create_date > (now - timedelta(days=90)))
|
||||
|
||||
def _search_newly_hired_employee(self, operator, value):
|
||||
employees = self.env['hr.employee'].search([
|
||||
('create_date', '>', fields.Datetime.now() - timedelta(days=90))
|
||||
])
|
||||
return [('id', 'in', employees.ids)]
|
||||
|
||||
@api.model_create_multi
|
||||
def create(self, vals_list):
|
||||
employees = super().create(vals_list)
|
||||
for employee in employees:
|
||||
if employee.applicant_id:
|
||||
employee.applicant_id._message_log_with_view(
|
||||
'hr_recruitment.applicant_hired_template',
|
||||
values={'applicant': employee.applicant_id},
|
||||
subtype_id=self.env.ref("hr_recruitment.mt_applicant_hired").id)
|
||||
return employees
|
||||
|
|
@ -0,0 +1,324 @@
|
|||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
import ast
|
||||
from collections import defaultdict
|
||||
|
||||
from odoo import api, fields, models, SUPERUSER_ID, _
|
||||
|
||||
|
||||
class Job(models.Model):
|
||||
_name = "hr.job"
|
||||
_inherit = ["mail.alias.mixin", "hr.job"]
|
||||
_order = "sequence, name asc"
|
||||
|
||||
@api.model
|
||||
def _default_address_id(self):
|
||||
last_used_address = self.env['hr.job'].search([('company_id', 'in', self.env.companies.ids)], order='id desc', limit=1)
|
||||
if last_used_address:
|
||||
return last_used_address.address_id
|
||||
else:
|
||||
return self.env.company.partner_id
|
||||
|
||||
def _address_id_domain(self):
|
||||
return ['|', '&', '&', ('type', '!=', 'contact'), ('type', '!=', 'private'),
|
||||
('id', 'in', self.sudo().env.companies.partner_id.child_ids.ids),
|
||||
('id', 'in', self.sudo().env.companies.partner_id.ids)]
|
||||
|
||||
def _get_default_favorite_user_ids(self):
|
||||
return [(6, 0, [self.env.uid])]
|
||||
|
||||
address_id = fields.Many2one(
|
||||
'res.partner', "Job Location", default=_default_address_id,
|
||||
domain=lambda self: self._address_id_domain(),
|
||||
help="Address where employees are working")
|
||||
application_ids = fields.One2many('hr.applicant', 'job_id', "Job Applications")
|
||||
application_count = fields.Integer(compute='_compute_application_count', string="Application Count")
|
||||
all_application_count = fields.Integer(compute='_compute_all_application_count', string="All Application Count")
|
||||
new_application_count = fields.Integer(
|
||||
compute='_compute_new_application_count', string="New Application",
|
||||
help="Number of applications that are new in the flow (typically at first step of the flow)")
|
||||
old_application_count = fields.Integer(
|
||||
compute='_compute_old_application_count', string="Old Application")
|
||||
applicant_hired = fields.Integer(compute='_compute_applicant_hired', string="Applicants Hired")
|
||||
manager_id = fields.Many2one(
|
||||
'hr.employee', related='department_id.manager_id', string="Department Manager",
|
||||
readonly=True, store=True)
|
||||
user_id = fields.Many2one('res.users', "Recruiter", domain="[('share', '=', False), ('company_ids', 'in', company_id)]", tracking=True, help="The Recruiter will be the default value for all Applicants Recruiter's field in this job position. The Recruiter is automatically added to all meetings with the Applicant.")
|
||||
hr_responsible_id = fields.Many2one(
|
||||
'res.users', "HR Responsible", tracking=True,
|
||||
help="Person responsible of validating the employee's contracts.")
|
||||
document_ids = fields.One2many('ir.attachment', compute='_compute_document_ids', string="Documents", readonly=True)
|
||||
documents_count = fields.Integer(compute='_compute_document_ids', string="Document Count")
|
||||
alias_id = fields.Many2one(
|
||||
'mail.alias', "Alias", ondelete="restrict", required=True,
|
||||
help="Email alias for this job position. New emails will automatically create new applicants for this job position.")
|
||||
color = fields.Integer("Color Index")
|
||||
is_favorite = fields.Boolean(compute='_compute_is_favorite', inverse='_inverse_is_favorite')
|
||||
favorite_user_ids = fields.Many2many('res.users', 'job_favorite_user_rel', 'job_id', 'user_id', default=_get_default_favorite_user_ids)
|
||||
interviewer_ids = fields.Many2many('res.users', string='Interviewers', domain="[('share', '=', False), ('company_ids', 'in', company_id)]", help="The Interviewers set on the job position can see all Applicants in it. They have access to the information, the attachments, the meeting management and they can refuse him. You don't need to have Recruitment rights to be set as an interviewer.")
|
||||
extended_interviewer_ids = fields.Many2many('res.users', 'hr_job_extended_interviewer_res_users', compute='_compute_extended_interviewer_ids', store=True)
|
||||
|
||||
activities_overdue = fields.Integer(compute='_compute_activities')
|
||||
activities_today = fields.Integer(compute='_compute_activities')
|
||||
|
||||
@api.depends_context('uid')
|
||||
def _compute_activities(self):
|
||||
self.env.cr.execute("""
|
||||
SELECT
|
||||
app.job_id,
|
||||
COUNT(*) AS act_count,
|
||||
CASE
|
||||
WHEN %(today)s::date - act.date_deadline::date = 0 THEN 'today'
|
||||
WHEN %(today)s::date - act.date_deadline::date > 0 THEN 'overdue'
|
||||
END AS act_state
|
||||
FROM mail_activity act
|
||||
JOIN hr_applicant app ON app.id = act.res_id
|
||||
JOIN hr_recruitment_stage sta ON app.stage_id = sta.id
|
||||
WHERE act.user_id = %(user_id)s AND act.res_model = 'hr.applicant'
|
||||
AND act.date_deadline <= %(today)s::date AND app.active
|
||||
AND app.job_id IN %(job_ids)s
|
||||
AND sta.hired_stage IS NOT TRUE
|
||||
GROUP BY app.job_id, act_state
|
||||
""", {
|
||||
'today': fields.Date.context_today(self),
|
||||
'user_id': self.env.uid,
|
||||
'job_ids': tuple(self.ids),
|
||||
})
|
||||
job_activities = defaultdict(dict)
|
||||
for activity in self.env.cr.dictfetchall():
|
||||
job_activities[activity['job_id']][activity['act_state']] = activity['act_count']
|
||||
for job in self:
|
||||
job.activities_overdue = job_activities[job.id].get('overdue', 0)
|
||||
job.activities_today = job_activities[job.id].get('today', 0)
|
||||
|
||||
@api.depends('application_ids.interviewer_ids')
|
||||
def _compute_extended_interviewer_ids(self):
|
||||
# Use SUPERUSER_ID as the search_read is protected in hr_referral
|
||||
results_raw = self.env['hr.applicant'].with_user(SUPERUSER_ID).search_read([
|
||||
('job_id', 'in', self.ids),
|
||||
('interviewer_ids', '!=', False)
|
||||
], ['interviewer_ids', 'job_id'])
|
||||
interviewers_by_job = defaultdict(set)
|
||||
for result_raw in results_raw:
|
||||
interviewers_by_job[result_raw['job_id'][0]] |= set(result_raw['interviewer_ids'])
|
||||
for job in self:
|
||||
job.extended_interviewer_ids = [(6, 0, list(interviewers_by_job[job.id]))]
|
||||
|
||||
def _compute_is_favorite(self):
|
||||
for job in self:
|
||||
job.is_favorite = self.env.user in job.favorite_user_ids
|
||||
|
||||
def _inverse_is_favorite(self):
|
||||
unfavorited_jobs = favorited_jobs = self.env['hr.job']
|
||||
for job in self:
|
||||
if self.env.user in job.favorite_user_ids:
|
||||
unfavorited_jobs |= job
|
||||
else:
|
||||
favorited_jobs |= job
|
||||
favorited_jobs.write({'favorite_user_ids': [(4, self.env.uid)]})
|
||||
unfavorited_jobs.write({'favorite_user_ids': [(3, self.env.uid)]})
|
||||
|
||||
def _compute_document_ids(self):
|
||||
applicants = self.mapped('application_ids').filtered(lambda self: not self.emp_id)
|
||||
app_to_job = dict((applicant.id, applicant.job_id.id) for applicant in applicants)
|
||||
attachments = self.env['ir.attachment'].search([
|
||||
'|',
|
||||
'&', ('res_model', '=', 'hr.job'), ('res_id', 'in', self.ids),
|
||||
'&', ('res_model', '=', 'hr.applicant'), ('res_id', 'in', applicants.ids)])
|
||||
result = dict.fromkeys(self.ids, self.env['ir.attachment'])
|
||||
for attachment in attachments:
|
||||
if attachment.res_model == 'hr.applicant':
|
||||
result[app_to_job[attachment.res_id]] |= attachment
|
||||
else:
|
||||
result[attachment.res_id] |= attachment
|
||||
|
||||
for job in self:
|
||||
job.document_ids = result.get(job.id, False)
|
||||
job.documents_count = len(job.document_ids)
|
||||
|
||||
def _compute_all_application_count(self):
|
||||
read_group_result = self.env['hr.applicant'].with_context(active_test=False)._read_group([
|
||||
('job_id', 'in', self.ids),
|
||||
'|',
|
||||
('active', '=', True),
|
||||
'&',
|
||||
('active', '=', False), ('refuse_reason_id', '!=', False),
|
||||
], ['job_id'], ['job_id'])
|
||||
result = dict((data['job_id'][0], data['job_id_count']) for data in read_group_result)
|
||||
for job in self:
|
||||
job.all_application_count = result.get(job.id, 0)
|
||||
|
||||
def _compute_application_count(self):
|
||||
read_group_result = self.env['hr.applicant']._read_group([('job_id', 'in', self.ids)], ['job_id'], ['job_id'])
|
||||
result = dict((data['job_id'][0], data['job_id_count']) for data in read_group_result)
|
||||
for job in self:
|
||||
job.application_count = result.get(job.id, 0)
|
||||
|
||||
def _get_first_stage(self):
|
||||
self.ensure_one()
|
||||
return self.env['hr.recruitment.stage'].search([
|
||||
'|',
|
||||
('job_ids', '=', False),
|
||||
('job_ids', '=', self.id)], order='sequence asc', limit=1)
|
||||
|
||||
def _compute_new_application_count(self):
|
||||
self.env.cr.execute(
|
||||
"""
|
||||
WITH job_stage AS (
|
||||
SELECT DISTINCT ON (j.id) j.id AS job_id, s.id AS stage_id, s.sequence AS sequence
|
||||
FROM hr_job j
|
||||
LEFT JOIN hr_job_hr_recruitment_stage_rel rel
|
||||
ON rel.hr_job_id = j.id
|
||||
JOIN hr_recruitment_stage s
|
||||
ON s.id = rel.hr_recruitment_stage_id
|
||||
OR s.id NOT IN (
|
||||
SELECT "hr_recruitment_stage_id"
|
||||
FROM "hr_job_hr_recruitment_stage_rel"
|
||||
WHERE "hr_recruitment_stage_id" IS NOT NULL
|
||||
)
|
||||
WHERE j.id in %s
|
||||
ORDER BY 1, 3 asc
|
||||
)
|
||||
SELECT s.job_id, COUNT(a.id) AS new_applicant
|
||||
FROM hr_applicant a
|
||||
JOIN job_stage s
|
||||
ON s.job_id = a.job_id
|
||||
AND a.stage_id = s.stage_id
|
||||
AND a.active IS TRUE
|
||||
WHERE a.company_id in %s
|
||||
GROUP BY s.job_id
|
||||
""", [tuple(self.ids), tuple(self.env.companies.ids)]
|
||||
)
|
||||
|
||||
new_applicant_count = dict(self.env.cr.fetchall())
|
||||
for job in self:
|
||||
job.new_application_count = new_applicant_count.get(job.id, 0)
|
||||
|
||||
def _compute_applicant_hired(self):
|
||||
hired_stages = self.env['hr.recruitment.stage'].search([('hired_stage', '=', True)])
|
||||
hired_data = self.env['hr.applicant']._read_group([
|
||||
('job_id', 'in', self.ids),
|
||||
('stage_id', 'in', hired_stages.ids),
|
||||
], ['job_id'], ['job_id'])
|
||||
job_hires = {data['job_id'][0]: data['job_id_count'] for data in hired_data}
|
||||
for job in self:
|
||||
job.applicant_hired = job_hires.get(job.id, 0)
|
||||
|
||||
@api.depends('application_count', 'new_application_count')
|
||||
def _compute_old_application_count(self):
|
||||
for job in self:
|
||||
job.old_application_count = job.application_count - job.new_application_count
|
||||
|
||||
def _alias_get_creation_values(self):
|
||||
values = super(Job, self)._alias_get_creation_values()
|
||||
values['alias_model_id'] = self.env['ir.model']._get('hr.applicant').id
|
||||
if self.id:
|
||||
values['alias_defaults'] = defaults = ast.literal_eval(self.alias_defaults or "{}")
|
||||
defaults.update({
|
||||
'job_id': self.id,
|
||||
'department_id': self.department_id.id,
|
||||
'company_id': self.department_id.company_id.id if self.department_id else self.company_id.id,
|
||||
'user_id': self.user_id.id,
|
||||
})
|
||||
return values
|
||||
|
||||
@api.model_create_multi
|
||||
def create(self, vals_list):
|
||||
for vals in vals_list:
|
||||
vals['favorite_user_ids'] = vals.get('favorite_user_ids', []) + [(4, self.env.uid)]
|
||||
if vals.get('alias_name'):
|
||||
vals['alias_user_id'] = False
|
||||
jobs = super().create(vals_list)
|
||||
utm_linkedin = self.env.ref("utm.utm_source_linkedin", raise_if_not_found=False)
|
||||
if utm_linkedin:
|
||||
source_vals = [{
|
||||
'source_id': utm_linkedin.id,
|
||||
'job_id': job.id,
|
||||
} for job in jobs]
|
||||
self.env['hr.recruitment.source'].create(source_vals)
|
||||
jobs.sudo().interviewer_ids._create_recruitment_interviewers()
|
||||
return jobs
|
||||
|
||||
def write(self, vals):
|
||||
old_interviewers = self.interviewer_ids
|
||||
if 'active' in vals and not vals['active']:
|
||||
self.application_ids.active = False
|
||||
res = super().write(vals)
|
||||
if 'interviewer_ids' in vals:
|
||||
interviewers_to_clean = old_interviewers - self.interviewer_ids
|
||||
interviewers_to_clean._remove_recruitment_interviewers()
|
||||
self.sudo().interviewer_ids._create_recruitment_interviewers()
|
||||
|
||||
# Since the alias is created upon record creation, the default values do not reflect the current values unless
|
||||
# specifically rewritten
|
||||
# List of fields to keep synched with the alias
|
||||
alias_fields = {'department_id', 'user_id'}
|
||||
if any(field for field in alias_fields if field in vals):
|
||||
for job in self:
|
||||
alias_default_vals = job._alias_get_creation_values().get('alias_defaults', '{}')
|
||||
job.alias_defaults = alias_default_vals
|
||||
return res
|
||||
|
||||
def _creation_subtype(self):
|
||||
return self.env.ref('hr_recruitment.mt_job_new')
|
||||
|
||||
def action_open_attachments(self):
|
||||
return {
|
||||
'type': 'ir.actions.act_window',
|
||||
'res_model': 'ir.attachment',
|
||||
'name': _('Documents'),
|
||||
'context': {
|
||||
'default_res_model': self._name,
|
||||
'default_res_id': self.ids[0],
|
||||
'show_partner_name': 1,
|
||||
},
|
||||
'view_mode': 'tree',
|
||||
'views': [
|
||||
(self.env.ref('hr_recruitment.ir_attachment_hr_recruitment_list_view').id, 'tree')
|
||||
],
|
||||
'search_view_id': self.env.ref('hr_recruitment.ir_attachment_view_search_inherit_hr_recruitment').ids,
|
||||
'domain': ['|',
|
||||
'&', ('res_model', '=', 'hr.job'), ('res_id', 'in', self.ids),
|
||||
'&', ('res_model', '=', 'hr.applicant'), ('res_id', 'in', self.application_ids.ids),
|
||||
],
|
||||
}
|
||||
|
||||
def action_open_activities(self):
|
||||
action = self.env["ir.actions.actions"]._for_xml_id("hr_recruitment.action_hr_job_applications")
|
||||
views = ['activity'] + [view for view in action['view_mode'].split(',') if view != 'activity']
|
||||
action['view_mode'] = ','.join(views)
|
||||
action['views'] = [(False, view) for view in views]
|
||||
return action
|
||||
|
||||
def action_open_late_activities(self):
|
||||
action = self.action_open_activities()
|
||||
action['context'] = {
|
||||
'default_job_id': self.id,
|
||||
'search_default_job_id': self.id,
|
||||
'search_default_activities_overdue': True,
|
||||
'search_default_running_applicant_activities': True,
|
||||
}
|
||||
return action
|
||||
|
||||
def action_open_today_activities(self):
|
||||
action = self.action_open_activities()
|
||||
action['context'] = {
|
||||
'default_job_id': self.id,
|
||||
'search_default_job_id': self.id,
|
||||
'search_default_activities_today': True,
|
||||
}
|
||||
return action
|
||||
|
||||
def close_dialog(self):
|
||||
return {'type': 'ir.actions.act_window_close'}
|
||||
|
||||
def edit_dialog(self):
|
||||
form_view = self.env.ref('hr.view_hr_job_form')
|
||||
return {
|
||||
'name': _('Job'),
|
||||
'res_model': 'hr.job',
|
||||
'res_id': self.id,
|
||||
'views': [(form_view.id, 'form'),],
|
||||
'type': 'ir.actions.act_window',
|
||||
'target': 'inline'
|
||||
}
|
||||
|
|
@ -0,0 +1,779 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from random import randint
|
||||
|
||||
from odoo import api, fields, models, tools, SUPERUSER_ID
|
||||
from odoo.exceptions import AccessError, UserError
|
||||
from odoo.tools import Query
|
||||
from odoo.tools.translate import _
|
||||
|
||||
from dateutil.relativedelta import relativedelta
|
||||
|
||||
from lxml import etree
|
||||
|
||||
AVAILABLE_PRIORITIES = [
|
||||
('0', 'Normal'),
|
||||
('1', 'Good'),
|
||||
('2', 'Very Good'),
|
||||
('3', 'Excellent')
|
||||
]
|
||||
|
||||
|
||||
class RecruitmentSource(models.Model):
|
||||
_name = "hr.recruitment.source"
|
||||
_description = "Source of Applicants"
|
||||
_inherit = ['utm.source.mixin']
|
||||
|
||||
email = fields.Char(related='alias_id.display_name', string="Email", readonly=True)
|
||||
has_domain = fields.Char(compute='_compute_has_domain')
|
||||
job_id = fields.Many2one('hr.job', "Job", ondelete='cascade')
|
||||
alias_id = fields.Many2one('mail.alias', "Alias ID")
|
||||
medium_id = fields.Many2one('utm.medium', default=lambda self: self.env.ref('utm.utm_medium_website'))
|
||||
|
||||
def _compute_has_domain(self):
|
||||
self.has_domain = bool(self.env["ir.config_parameter"].sudo().get_param("mail.catchall.domain"))
|
||||
|
||||
def create_alias(self):
|
||||
campaign = self.env.ref('hr_recruitment.utm_campaign_job')
|
||||
medium = self.env.ref('utm.utm_medium_email')
|
||||
for source in self:
|
||||
vals = {
|
||||
'alias_parent_thread_id': source.job_id.id,
|
||||
'alias_model_id': self.env['ir.model']._get('hr.applicant').id,
|
||||
'alias_parent_model_id': self.env['ir.model']._get('hr.job').id,
|
||||
'alias_name': "%s+%s" % (source.job_id.alias_name or source.job_id.name, source.name),
|
||||
'alias_defaults': {
|
||||
'job_id': source.job_id.id,
|
||||
'campaign_id': campaign.id,
|
||||
'medium_id': medium.id,
|
||||
'source_id': source.source_id.id,
|
||||
},
|
||||
}
|
||||
|
||||
# check that you can create source before to call mail.alias in sudo with known/controlled vals
|
||||
source.check_access_rights('create')
|
||||
source.check_access_rule('create')
|
||||
source.alias_id = self.env['mail.alias'].sudo().create(vals)
|
||||
|
||||
@api.model
|
||||
def _get_view(self, view_id=None, view_type='form', **options):
|
||||
arch, view = super()._get_view(view_id, view_type, **options)
|
||||
if view_type == 'tree' and not bool(self.env["ir.config_parameter"].sudo().get_param("mail.catchall.domain")):
|
||||
email = arch.xpath("//field[@name='email']")[0]
|
||||
email.getparent().remove(email)
|
||||
return arch, view
|
||||
|
||||
class RecruitmentStage(models.Model):
|
||||
_name = "hr.recruitment.stage"
|
||||
_description = "Recruitment Stages"
|
||||
_order = 'sequence'
|
||||
|
||||
name = fields.Char("Stage Name", required=True, translate=True)
|
||||
sequence = fields.Integer(
|
||||
"Sequence", default=10)
|
||||
job_ids = fields.Many2many(
|
||||
'hr.job', string='Job Specific',
|
||||
help='Specific jobs that uses this stage. Other jobs will not use this stage.')
|
||||
requirements = fields.Text("Requirements")
|
||||
template_id = fields.Many2one(
|
||||
'mail.template', "Email Template",
|
||||
help="If set, a message is posted on the applicant using the template when the applicant is set to the stage.")
|
||||
fold = fields.Boolean(
|
||||
"Folded in Kanban",
|
||||
help="This stage is folded in the kanban view when there are no records in that stage to display.")
|
||||
hired_stage = fields.Boolean('Hired Stage',
|
||||
help="If checked, this stage is used to determine the hire date of an applicant")
|
||||
legend_blocked = fields.Char(
|
||||
'Red Kanban Label', default=lambda self: _('Blocked'), translate=True, required=True)
|
||||
legend_done = fields.Char(
|
||||
'Green Kanban Label', default=lambda self: _('Ready for Next Stage'), translate=True, required=True)
|
||||
legend_normal = fields.Char(
|
||||
'Grey Kanban Label', default=lambda self: _('In Progress'), translate=True, required=True)
|
||||
is_warning_visible = fields.Boolean(compute='_compute_is_warning_visible')
|
||||
|
||||
@api.model
|
||||
def default_get(self, fields):
|
||||
if self._context and self._context.get('default_job_id') and not self._context.get('hr_recruitment_stage_mono', False):
|
||||
context = dict(self._context)
|
||||
context.pop('default_job_id')
|
||||
self = self.with_context(context)
|
||||
return super(RecruitmentStage, self).default_get(fields)
|
||||
|
||||
@api.depends('hired_stage')
|
||||
def _compute_is_warning_visible(self):
|
||||
applicant_data = self.env['hr.applicant']._read_group([('stage_id', 'in', self.ids)], ['stage_id'], 'stage_id')
|
||||
applicants = dict((data['stage_id'][0], data['stage_id_count']) for data in applicant_data)
|
||||
for stage in self:
|
||||
if stage._origin.hired_stage and not stage.hired_stage and applicants.get(stage._origin.id):
|
||||
stage.is_warning_visible = True
|
||||
else:
|
||||
stage.is_warning_visible = False
|
||||
|
||||
class RecruitmentDegree(models.Model):
|
||||
_name = "hr.recruitment.degree"
|
||||
_description = "Applicant Degree"
|
||||
_sql_constraints = [
|
||||
('name_uniq', 'unique (name)', 'The name of the Degree of Recruitment must be unique!')
|
||||
]
|
||||
|
||||
name = fields.Char("Degree Name", required=True, translate=True)
|
||||
sequence = fields.Integer("Sequence", default=1)
|
||||
|
||||
|
||||
class Applicant(models.Model):
|
||||
_name = "hr.applicant"
|
||||
_description = "Applicant"
|
||||
_order = "priority desc, id desc"
|
||||
_inherit = ['mail.thread.cc', 'mail.activity.mixin', 'utm.mixin']
|
||||
_mailing_enabled = True
|
||||
|
||||
name = fields.Char("Subject / Application", required=True, help="Email subject for applications sent via email", index='trigram')
|
||||
active = fields.Boolean("Active", default=True, help="If the active field is set to false, it will allow you to hide the case without removing it.")
|
||||
description = fields.Html("Description")
|
||||
email_from = fields.Char("Email", size=128, compute='_compute_partner_phone_email',
|
||||
inverse='_inverse_partner_email', store=True)
|
||||
probability = fields.Float("Probability")
|
||||
partner_id = fields.Many2one('res.partner', "Contact", copy=False)
|
||||
create_date = fields.Datetime("Creation Date", readonly=True)
|
||||
stage_id = fields.Many2one('hr.recruitment.stage', 'Stage', ondelete='restrict', tracking=True,
|
||||
compute='_compute_stage', store=True, readonly=False,
|
||||
domain="['|', ('job_ids', '=', False), ('job_ids', '=', job_id)]",
|
||||
copy=False, index=True,
|
||||
group_expand='_read_group_stage_ids')
|
||||
last_stage_id = fields.Many2one('hr.recruitment.stage', "Last Stage",
|
||||
help="Stage of the applicant before being in the current stage. Used for lost cases analysis.")
|
||||
categ_ids = fields.Many2many('hr.applicant.category', string="Tags")
|
||||
company_id = fields.Many2one('res.company', "Company", compute='_compute_company', store=True, readonly=False, tracking=True)
|
||||
user_id = fields.Many2one(
|
||||
'res.users', "Recruiter", compute='_compute_user', domain="[('share', '=', False), ('company_ids', 'in', company_id)]",
|
||||
tracking=True, store=True, readonly=False)
|
||||
date_closed = fields.Datetime("Hire Date", compute='_compute_date_closed', store=True, readonly=False, tracking=True, copy=False)
|
||||
date_open = fields.Datetime("Assigned", readonly=True)
|
||||
date_last_stage_update = fields.Datetime("Last Stage Update", index=True, default=fields.Datetime.now)
|
||||
priority = fields.Selection(AVAILABLE_PRIORITIES, "Evaluation", default='0')
|
||||
job_id = fields.Many2one('hr.job', "Applied Job", domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]", tracking=True, index=True)
|
||||
salary_proposed_extra = fields.Char("Proposed Salary Extra", help="Salary Proposed by the Organisation, extra advantages", tracking=True, groups="hr_recruitment.group_hr_recruitment_user")
|
||||
salary_expected_extra = fields.Char("Expected Salary Extra", help="Salary Expected by Applicant, extra advantages", tracking=True, groups="hr_recruitment.group_hr_recruitment_user")
|
||||
salary_proposed = fields.Float("Proposed Salary", group_operator="avg", help="Salary Proposed by the Organisation", tracking=True, groups="hr_recruitment.group_hr_recruitment_user")
|
||||
salary_expected = fields.Float("Expected Salary", group_operator="avg", help="Salary Expected by Applicant", tracking=True, groups="hr_recruitment.group_hr_recruitment_user")
|
||||
availability = fields.Date("Availability", help="The date at which the applicant will be available to start working", tracking=True)
|
||||
partner_name = fields.Char("Applicant's Name")
|
||||
partner_phone = fields.Char("Phone", size=32, compute='_compute_partner_phone_email',
|
||||
inverse='_inverse_partner_phone', store=True)
|
||||
partner_mobile = fields.Char("Mobile", size=32, compute='_compute_partner_phone_email',
|
||||
inverse='_inverse_partner_mobile', store=True)
|
||||
type_id = fields.Many2one('hr.recruitment.degree', "Degree")
|
||||
department_id = fields.Many2one(
|
||||
'hr.department', "Department", compute='_compute_department', store=True, readonly=False,
|
||||
domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]", tracking=True)
|
||||
day_open = fields.Float(compute='_compute_day', string="Days to Open", compute_sudo=True)
|
||||
day_close = fields.Float(compute='_compute_day', string="Days to Close", compute_sudo=True)
|
||||
delay_close = fields.Float(compute="_compute_day", string='Delay to Close', readonly=True, group_operator="avg", help="Number of days to close", store=True)
|
||||
color = fields.Integer("Color Index", default=0)
|
||||
emp_id = fields.Many2one('hr.employee', string="Employee", help="Employee linked to the applicant.", copy=False)
|
||||
user_email = fields.Char(related='user_id.email', string="User Email", readonly=True)
|
||||
attachment_number = fields.Integer(compute='_get_attachment_number', string="Number of Attachments")
|
||||
employee_name = fields.Char(related='emp_id.name', string="Employee Name", readonly=False, tracking=False)
|
||||
attachment_ids = fields.One2many('ir.attachment', 'res_id', domain=[('res_model', '=', 'hr.applicant')], string='Attachments')
|
||||
kanban_state = fields.Selection([
|
||||
('normal', 'Grey'),
|
||||
('done', 'Green'),
|
||||
('blocked', 'Red')], string='Kanban State',
|
||||
copy=False, default='normal', required=True)
|
||||
legend_blocked = fields.Char(related='stage_id.legend_blocked', string='Kanban Blocked')
|
||||
legend_done = fields.Char(related='stage_id.legend_done', string='Kanban Valid')
|
||||
legend_normal = fields.Char(related='stage_id.legend_normal', string='Kanban Ongoing')
|
||||
application_count = fields.Integer(compute='_compute_application_count', help='Applications with the same email or phone or mobile')
|
||||
refuse_reason_id = fields.Many2one('hr.applicant.refuse.reason', string='Refuse Reason', tracking=True)
|
||||
meeting_ids = fields.One2many('calendar.event', 'applicant_id', 'Meetings')
|
||||
meeting_display_text = fields.Char(compute='_compute_meeting_display')
|
||||
meeting_display_date = fields.Date(compute='_compute_meeting_display')
|
||||
# UTMs - enforcing the fact that we want to 'set null' when relation is unlinked
|
||||
campaign_id = fields.Many2one(ondelete='set null')
|
||||
medium_id = fields.Many2one(ondelete='set null')
|
||||
source_id = fields.Many2one(ondelete='set null')
|
||||
interviewer_ids = fields.Many2many('res.users', 'hr_applicant_res_users_interviewers_rel',
|
||||
string='Interviewers', index=True, tracking=True, copy=False,
|
||||
domain="[('share', '=', False), ('company_ids', 'in', company_id)]")
|
||||
linkedin_profile = fields.Char('LinkedIn Profile')
|
||||
application_status = fields.Selection([
|
||||
('ongoing', 'Ongoing'),
|
||||
('hired', 'Hired'),
|
||||
('refused', 'Refused'),
|
||||
], compute="_compute_application_status")
|
||||
|
||||
@api.onchange('job_id')
|
||||
def _onchange_job_id(self):
|
||||
for applicant in self:
|
||||
if applicant.job_id.name:
|
||||
applicant.name = applicant.job_id.name
|
||||
|
||||
@api.depends('date_open', 'date_closed')
|
||||
def _compute_day(self):
|
||||
for applicant in self:
|
||||
if applicant.date_open:
|
||||
date_create = applicant.create_date
|
||||
date_open = applicant.date_open
|
||||
applicant.day_open = (date_open - date_create).total_seconds() / (24.0 * 3600)
|
||||
else:
|
||||
applicant.day_open = False
|
||||
if applicant.date_closed:
|
||||
date_create = applicant.create_date
|
||||
date_closed = applicant.date_closed
|
||||
applicant.day_close = (date_closed - date_create).total_seconds() / (24.0 * 3600)
|
||||
applicant.delay_close = applicant.day_close - applicant.day_open
|
||||
else:
|
||||
applicant.day_close = False
|
||||
applicant.delay_close = False
|
||||
|
||||
@api.depends('email_from', 'partner_phone', 'partner_mobile')
|
||||
def _compute_application_count(self):
|
||||
self.flush_model(['email_from'])
|
||||
applicants = self.env['hr.applicant']
|
||||
for applicant in self:
|
||||
if applicant.email_from or applicant.partner_phone or applicant.partner_mobile:
|
||||
applicants |= applicant
|
||||
# Done via SQL since read_group does not support grouping by lowercase field
|
||||
if applicants.ids:
|
||||
query = Query(self.env.cr, self._table, self._table_query)
|
||||
query.add_where('hr_applicant.id in %s', [tuple(applicants.ids)])
|
||||
# Count into the companies that are selected from the multi-company widget
|
||||
company_ids = self.env.context.get('allowed_company_ids')
|
||||
if company_ids:
|
||||
query.add_where('other.company_id in %s', [tuple(company_ids)])
|
||||
self._apply_ir_rules(query)
|
||||
from_clause, where_clause, where_clause_params = query.get_sql()
|
||||
# In case the applicant phone or mobile is configured in wrong field
|
||||
query_str = """
|
||||
SELECT hr_applicant.id as appl_id,
|
||||
COUNT(other.id) as count
|
||||
FROM hr_applicant
|
||||
JOIN hr_applicant other ON LOWER(other.email_from) = LOWER(hr_applicant.email_from)
|
||||
OR other.partner_phone = hr_applicant.partner_phone OR other.partner_phone = hr_applicant.partner_mobile
|
||||
OR other.partner_mobile = hr_applicant.partner_mobile OR other.partner_mobile = hr_applicant.partner_phone
|
||||
%(where)s
|
||||
GROUP BY hr_applicant.id
|
||||
""" % {
|
||||
'where': ('WHERE %s' % where_clause) if where_clause else '',
|
||||
}
|
||||
self.env.cr.execute(query_str, where_clause_params)
|
||||
application_data_mapped = dict((data['appl_id'], data['count']) for data in self.env.cr.dictfetchall())
|
||||
else:
|
||||
application_data_mapped = dict()
|
||||
for applicant in applicants:
|
||||
applicant.application_count = application_data_mapped.get(applicant.id, 1) - 1
|
||||
(self - applicants).application_count = False
|
||||
|
||||
@api.depends_context('lang')
|
||||
@api.depends('meeting_ids', 'meeting_ids.start')
|
||||
def _compute_meeting_display(self):
|
||||
applicant_with_meetings = self.filtered('meeting_ids')
|
||||
(self - applicant_with_meetings).update({
|
||||
'meeting_display_text': _('No Meeting'),
|
||||
'meeting_display_date': ''
|
||||
})
|
||||
today = fields.Date.today()
|
||||
for applicant in applicant_with_meetings:
|
||||
count = len(applicant.meeting_ids)
|
||||
dates = applicant.meeting_ids.mapped('start')
|
||||
min_date, max_date = min(dates).date(), max(dates).date()
|
||||
if min_date >= today:
|
||||
applicant.meeting_display_date = min_date
|
||||
else:
|
||||
applicant.meeting_display_date = max_date
|
||||
if count == 1:
|
||||
applicant.meeting_display_text = _('1 Meeting')
|
||||
elif applicant.meeting_display_date >= today:
|
||||
applicant.meeting_display_text = _('Next Meeting')
|
||||
else:
|
||||
applicant.meeting_display_text = _('Last Meeting')
|
||||
|
||||
@api.depends('refuse_reason_id', 'date_closed')
|
||||
def _compute_application_status(self):
|
||||
for applicant in self:
|
||||
if applicant.refuse_reason_id:
|
||||
applicant.application_status = 'refused'
|
||||
elif applicant.date_closed:
|
||||
applicant.application_status = 'hired'
|
||||
else:
|
||||
applicant.application_status = 'ongoing'
|
||||
|
||||
def _get_attachment_number(self):
|
||||
read_group_res = self.env['ir.attachment']._read_group(
|
||||
[('res_model', '=', 'hr.applicant'), ('res_id', 'in', self.ids)],
|
||||
['res_id'], ['res_id'])
|
||||
attach_data = dict((res['res_id'], res['res_id_count']) for res in read_group_res)
|
||||
for record in self:
|
||||
record.attachment_number = attach_data.get(record.id, 0)
|
||||
|
||||
@api.model
|
||||
def _read_group_stage_ids(self, stages, domain, order):
|
||||
# retrieve job_id from the context and write the domain: ids + contextual columns (job or default)
|
||||
job_id = self._context.get('default_job_id')
|
||||
search_domain = [('job_ids', '=', False)]
|
||||
if job_id:
|
||||
search_domain = ['|', ('job_ids', '=', job_id)] + search_domain
|
||||
if stages:
|
||||
search_domain = ['|', ('id', 'in', stages.ids)] + search_domain
|
||||
|
||||
stage_ids = stages._search(search_domain, order=order, access_rights_uid=SUPERUSER_ID)
|
||||
return stages.browse(stage_ids)
|
||||
|
||||
@api.depends('job_id', 'department_id')
|
||||
def _compute_company(self):
|
||||
for applicant in self:
|
||||
company_id = False
|
||||
if applicant.department_id:
|
||||
company_id = applicant.department_id.company_id.id
|
||||
if not company_id and applicant.job_id:
|
||||
company_id = applicant.job_id.company_id.id
|
||||
applicant.company_id = company_id or self.env.company.id
|
||||
|
||||
@api.depends('job_id')
|
||||
def _compute_department(self):
|
||||
for applicant in self:
|
||||
applicant.department_id = applicant.job_id.department_id.id
|
||||
|
||||
@api.depends('job_id')
|
||||
def _compute_stage(self):
|
||||
for applicant in self:
|
||||
if applicant.job_id:
|
||||
if not applicant.stage_id:
|
||||
stage_ids = self.env['hr.recruitment.stage'].search([
|
||||
'|',
|
||||
('job_ids', '=', False),
|
||||
('job_ids', '=', applicant.job_id.id),
|
||||
('fold', '=', False)
|
||||
], order='sequence asc', limit=1).ids
|
||||
applicant.stage_id = stage_ids[0] if stage_ids else False
|
||||
else:
|
||||
applicant.stage_id = False
|
||||
|
||||
@api.depends('job_id')
|
||||
def _compute_user(self):
|
||||
for applicant in self:
|
||||
applicant.user_id = applicant.job_id.user_id.id or self.env.uid
|
||||
|
||||
@api.depends('partner_id')
|
||||
def _compute_partner_phone_email(self):
|
||||
for applicant in self:
|
||||
if applicant.partner_id:
|
||||
applicant.partner_phone = applicant.partner_id.phone
|
||||
applicant.partner_mobile = applicant.partner_id.mobile
|
||||
applicant.email_from = applicant.partner_id.email
|
||||
|
||||
def _inverse_partner_email(self):
|
||||
for applicant in self.filtered(lambda a: a.partner_id and a.email_from and not a.partner_id.email):
|
||||
applicant.partner_id.email = applicant.email_from
|
||||
|
||||
def _inverse_partner_phone(self):
|
||||
for applicant in self.filtered(lambda a: a.partner_id and a.partner_phone and not a.partner_id.phone):
|
||||
applicant.partner_id.phone = applicant.partner_phone
|
||||
|
||||
def _inverse_partner_mobile(self):
|
||||
for applicant in self.filtered(lambda a: a.partner_id and a.partner_mobile and not a.partner_id.mobile):
|
||||
applicant.partner_id.mobile = applicant.partner_mobile
|
||||
|
||||
@api.depends('stage_id.hired_stage')
|
||||
def _compute_date_closed(self):
|
||||
for applicant in self:
|
||||
if applicant.stage_id and applicant.stage_id.hired_stage and not applicant.date_closed:
|
||||
applicant.date_closed = fields.datetime.now()
|
||||
if not applicant.stage_id.hired_stage:
|
||||
applicant.date_closed = False
|
||||
|
||||
def _check_interviewer_access(self):
|
||||
if self.user_has_groups('hr_recruitment.group_hr_recruitment_interviewer'):
|
||||
raise AccessError(_('You are not allowed to perform this action.'))
|
||||
|
||||
@api.model_create_multi
|
||||
def create(self, vals_list):
|
||||
for vals in vals_list:
|
||||
if vals.get('user_id'):
|
||||
vals['date_open'] = fields.Datetime.now()
|
||||
if vals.get('email_from'):
|
||||
vals['email_from'] = vals['email_from'].strip()
|
||||
applicants = super().create(vals_list)
|
||||
applicants.sudo().interviewer_ids._create_recruitment_interviewers()
|
||||
# Record creation through calendar, creates the calendar event directly, it will also create the activity.
|
||||
if 'default_activity_date_deadline' in self.env.context:
|
||||
deadline = fields.Datetime.to_datetime(self.env.context.get('default_activity_date_deadline'))
|
||||
category = self.env.ref('hr_recruitment.categ_meet_interview')
|
||||
for applicant in applicants:
|
||||
partners = applicant.partner_id | applicant.user_id.partner_id | applicant.department_id.manager_id.user_id.partner_id
|
||||
self.env['calendar.event'].sudo().with_context(default_applicant_id=applicant.id).create({
|
||||
'applicant_id': applicant.id,
|
||||
'partner_ids': [(6, 0, partners.ids)],
|
||||
'user_id': self.env.uid,
|
||||
'name': applicant.name,
|
||||
'categ_ids': [category.id],
|
||||
'start': deadline,
|
||||
'stop': deadline + relativedelta(minutes=30),
|
||||
})
|
||||
return applicants
|
||||
|
||||
def write(self, vals):
|
||||
# user_id change: update date_open
|
||||
if vals.get('user_id'):
|
||||
vals['date_open'] = fields.Datetime.now()
|
||||
if vals.get('email_from'):
|
||||
vals['email_from'] = vals['email_from'].strip()
|
||||
old_interviewers = self.interviewer_ids
|
||||
# stage_id: track last stage before update
|
||||
if 'stage_id' in vals:
|
||||
vals['date_last_stage_update'] = fields.Datetime.now()
|
||||
if 'kanban_state' not in vals:
|
||||
vals['kanban_state'] = 'normal'
|
||||
for applicant in self:
|
||||
vals['last_stage_id'] = applicant.stage_id.id
|
||||
res = super(Applicant, self).write(vals)
|
||||
else:
|
||||
res = super(Applicant, self).write(vals)
|
||||
if 'interviewer_ids' in vals:
|
||||
interviewers_to_clean = old_interviewers - self.interviewer_ids
|
||||
interviewers_to_clean._remove_recruitment_interviewers()
|
||||
self.sudo().interviewer_ids._create_recruitment_interviewers()
|
||||
if vals.get('emp_id'):
|
||||
self._update_employee_from_applicant()
|
||||
return res
|
||||
|
||||
def get_empty_list_help(self, help):
|
||||
if 'active_id' in self.env.context and self.env.context.get('active_model') == 'hr.job':
|
||||
alias_id = self.env['hr.job'].browse(self.env.context['active_id']).alias_id
|
||||
else:
|
||||
alias_id = False
|
||||
|
||||
nocontent_values = {
|
||||
'help_title': _("No application found. Let's create one !"),
|
||||
'para_1': _('People can also apply by email to save time.'),
|
||||
'para_2': _("You can search into attachment's content, like resumes, with the searchbar."),
|
||||
}
|
||||
nocontent_body = """
|
||||
<p class="o_view_nocontent_smiling_face">%(help_title)s</p>
|
||||
<p>%(para_1)s<br/>%(para_2)s</p>"""
|
||||
|
||||
if alias_id and alias_id.alias_domain and alias_id.alias_name:
|
||||
email = alias_id.display_name
|
||||
email_link = "<a href='mailto:%s'>%s</a>" % (email, email)
|
||||
nocontent_values['email_link'] = email_link
|
||||
nocontent_body += """<p class="o_copy_paste_email">%(email_link)s</p>"""
|
||||
|
||||
return nocontent_body % nocontent_values
|
||||
|
||||
@api.model
|
||||
def get_view(self, view_id=None, view_type='form', **options):
|
||||
if view_type == 'form' and self.user_has_groups('hr_recruitment.group_hr_recruitment_interviewer'):
|
||||
view_id = self.env.ref('hr_recruitment.hr_applicant_view_form_interviewer').id
|
||||
return super().get_view(view_id, view_type, **options)
|
||||
|
||||
def _notify_get_recipients(self, message, msg_vals, **kwargs):
|
||||
"""
|
||||
Do not notify members of the Recruitment Interviewer group, as this
|
||||
might leak some data they shouldn't have access to.
|
||||
"""
|
||||
recipients = super()._notify_get_recipients(message, msg_vals, **kwargs)
|
||||
interviewer_group = self.env.ref('hr_recruitment.group_hr_recruitment_interviewer').id
|
||||
return [recipient for recipient in recipients if interviewer_group not in recipient['groups']]
|
||||
|
||||
def action_makeMeeting(self):
|
||||
""" This opens Meeting's calendar view to schedule meeting on current applicant
|
||||
@return: Dictionary value for created Meeting view
|
||||
"""
|
||||
self.ensure_one()
|
||||
|
||||
if not self.partner_id:
|
||||
if not self.partner_name:
|
||||
raise UserError(_('You must define a Contact Name for this applicant.'))
|
||||
self.partner_id = self.env['res.partner'].create({
|
||||
'is_company': False,
|
||||
'type': 'private',
|
||||
'name': self.partner_name,
|
||||
'email': self.email_from,
|
||||
'phone': self.partner_phone,
|
||||
'mobile': self.partner_mobile
|
||||
})
|
||||
|
||||
partners = self.partner_id | self.user_id.partner_id | self.department_id.manager_id.user_id.partner_id
|
||||
|
||||
category = self.env.ref('hr_recruitment.categ_meet_interview')
|
||||
res = self.env['ir.actions.act_window']._for_xml_id('calendar.action_calendar_event')
|
||||
res['context'] = {
|
||||
'default_applicant_id': self.id,
|
||||
'default_partner_ids': partners.ids,
|
||||
'default_user_id': self.env.uid,
|
||||
'default_name': self.name,
|
||||
'default_categ_ids': category and [category.id] or False,
|
||||
}
|
||||
return res
|
||||
|
||||
def action_open_attachments(self):
|
||||
return {
|
||||
'type': 'ir.actions.act_window',
|
||||
'res_model': 'ir.attachment',
|
||||
'name': _('Documents'),
|
||||
'context': {
|
||||
'default_res_model': 'hr.applicant',
|
||||
'default_res_id': self.ids[0],
|
||||
'show_partner_name': 1,
|
||||
},
|
||||
'view_mode': 'tree,form',
|
||||
'views': [
|
||||
(self.env.ref('hr_recruitment.ir_attachment_hr_recruitment_list_view').id, 'tree'),
|
||||
(False, 'form'),
|
||||
],
|
||||
'search_view_id': self.env.ref('hr_recruitment.ir_attachment_view_search_inherit_hr_recruitment').ids,
|
||||
'domain': [('res_model', '=', 'hr.applicant'), ('res_id', 'in', self.ids), ],
|
||||
}
|
||||
|
||||
def action_applications_email(self):
|
||||
self.ensure_one()
|
||||
self.env.cr.execute("""
|
||||
SELECT other.id
|
||||
FROM hr_applicant
|
||||
JOIN hr_applicant other ON LOWER(other.email_from) = LOWER(hr_applicant.email_from)
|
||||
OR other.partner_phone = hr_applicant.partner_phone OR other.partner_phone = hr_applicant.partner_mobile
|
||||
OR other.partner_mobile = hr_applicant.partner_mobile OR other.partner_mobile = hr_applicant.partner_phone
|
||||
WHERE hr_applicant.id in %s
|
||||
""", (tuple(self.ids),)
|
||||
)
|
||||
ids = [res['id'] for res in self.env.cr.dictfetchall()]
|
||||
return {
|
||||
'type': 'ir.actions.act_window',
|
||||
'name': _('Job Applications'),
|
||||
'res_model': self._name,
|
||||
'view_mode': 'tree,kanban,form,pivot,graph,calendar,activity',
|
||||
'domain': [('id', 'in', ids)],
|
||||
'context': {
|
||||
'active_test': False,
|
||||
'search_default_stage': 1,
|
||||
},
|
||||
}
|
||||
|
||||
def action_open_employee(self):
|
||||
self.ensure_one()
|
||||
return {
|
||||
'name': _('Employee'),
|
||||
'type': 'ir.actions.act_window',
|
||||
'res_model': 'hr.employee',
|
||||
'view_mode': 'form',
|
||||
'res_id': self.emp_id.id,
|
||||
}
|
||||
|
||||
def _track_template(self, changes):
|
||||
res = super(Applicant, self)._track_template(changes)
|
||||
applicant = self[0]
|
||||
if 'stage_id' in changes and applicant.stage_id.template_id:
|
||||
res['stage_id'] = (applicant.stage_id.template_id, {
|
||||
'auto_delete_message': True,
|
||||
'subtype_id': self.env['ir.model.data']._xmlid_to_res_id('mail.mt_note'),
|
||||
'email_layout_xmlid': 'mail.mail_notification_light'
|
||||
})
|
||||
return res
|
||||
|
||||
def _creation_subtype(self):
|
||||
return self.env.ref('hr_recruitment.mt_applicant_new')
|
||||
|
||||
def _track_subtype(self, init_values):
|
||||
record = self[0]
|
||||
if 'stage_id' in init_values and record.stage_id:
|
||||
return self.env.ref('hr_recruitment.mt_applicant_stage_changed')
|
||||
return super(Applicant, self)._track_subtype(init_values)
|
||||
|
||||
def _notify_get_reply_to(self, default=None):
|
||||
""" Override to set alias of applicants to their job definition if any. """
|
||||
aliases = self.mapped('job_id')._notify_get_reply_to(default=default)
|
||||
res = {app.id: aliases.get(app.job_id.id) for app in self}
|
||||
leftover = self.filtered(lambda rec: not rec.job_id)
|
||||
if leftover:
|
||||
res.update(super(Applicant, leftover)._notify_get_reply_to(default=default))
|
||||
return res
|
||||
|
||||
def _message_get_suggested_recipients(self):
|
||||
recipients = super(Applicant, self)._message_get_suggested_recipients()
|
||||
for applicant in self:
|
||||
if applicant.partner_id:
|
||||
applicant._message_add_suggested_recipient(recipients, partner=applicant.partner_id.sudo(), reason=_('Contact'))
|
||||
elif applicant.email_from:
|
||||
email_from = tools.email_normalize(applicant.email_from)
|
||||
if email_from and applicant.partner_name:
|
||||
email_from = tools.formataddr((applicant.partner_name, email_from))
|
||||
applicant._message_add_suggested_recipient(recipients, email=email_from, reason=_('Contact Email'))
|
||||
return recipients
|
||||
|
||||
def name_get(self):
|
||||
if self.env.context.get('show_partner_name'):
|
||||
return [
|
||||
(applicant.id, applicant.partner_name or applicant.name)
|
||||
for applicant in self
|
||||
]
|
||||
return super().name_get()
|
||||
|
||||
@api.model
|
||||
def message_new(self, msg, custom_values=None):
|
||||
""" Overrides mail_thread message_new that is called by the mailgateway
|
||||
through message_process.
|
||||
This override updates the document according to the email.
|
||||
"""
|
||||
# remove default author when going through the mail gateway. Indeed we
|
||||
# do not want to explicitly set user_id to False; however we do not
|
||||
# want the gateway user to be responsible if no other responsible is
|
||||
# found.
|
||||
self = self.with_context(default_user_id=False)
|
||||
stage = False
|
||||
if custom_values and 'job_id' in custom_values:
|
||||
stage = self.env['hr.job'].browse(custom_values['job_id'])._get_first_stage()
|
||||
partner_name, email_from = self.env['res.partner']._parse_partner_name(msg.get('from'))
|
||||
defaults = {
|
||||
'name': msg.get('subject') or _("No Subject"),
|
||||
'partner_name': partner_name or email_from,
|
||||
'email_from': email_from,
|
||||
'partner_id': msg.get('author_id', False),
|
||||
}
|
||||
if msg.get('priority'):
|
||||
defaults['priority'] = msg.get('priority')
|
||||
if stage and stage.id:
|
||||
defaults['stage_id'] = stage.id
|
||||
if custom_values:
|
||||
defaults.update(custom_values)
|
||||
return super(Applicant, self).message_new(msg, custom_values=defaults)
|
||||
|
||||
def _message_post_after_hook(self, message, msg_vals):
|
||||
if self.email_from and not self.partner_id:
|
||||
# we consider that posting a message with a specified recipient (not a follower, a specific one)
|
||||
# on a document without customer means that it was created through the chatter using
|
||||
# suggested recipients. This heuristic allows to avoid ugly hacks in JS.
|
||||
email_normalized = tools.email_normalize(self.email_from)
|
||||
new_partner = message.partner_ids.filtered(
|
||||
lambda partner: partner.email == self.email_from or (email_normalized and partner.email_normalized == email_normalized)
|
||||
)
|
||||
if new_partner:
|
||||
if new_partner[0].create_date.date() == fields.Date.today():
|
||||
new_partner[0].write({
|
||||
'type': 'private',
|
||||
'name': self.partner_name or self.email_from,
|
||||
'phone': self.partner_phone,
|
||||
'mobile': self.partner_mobile,
|
||||
})
|
||||
if new_partner[0].email_normalized:
|
||||
email_domain = ('email_from', 'in', [new_partner[0].email, new_partner[0].email_normalized])
|
||||
else:
|
||||
email_domain = ('email_from', '=', new_partner[0].email)
|
||||
self.search([
|
||||
('partner_id', '=', False), email_domain, ('stage_id.fold', '=', False)
|
||||
]).write({'partner_id': new_partner[0].id})
|
||||
return super(Applicant, self)._message_post_after_hook(message, msg_vals)
|
||||
|
||||
def create_employee_from_applicant(self):
|
||||
""" Create an employee from applicant """
|
||||
self.ensure_one()
|
||||
self._check_interviewer_access()
|
||||
|
||||
contact_name = False
|
||||
if self.partner_id:
|
||||
address_id = self.partner_id.address_get(['contact'])['contact']
|
||||
contact_name = self.partner_id.display_name
|
||||
else:
|
||||
if not self.partner_name:
|
||||
raise UserError(_('You must define a Contact Name for this applicant.'))
|
||||
new_partner_id = self.env['res.partner'].create({
|
||||
'is_company': False,
|
||||
'type': 'private',
|
||||
'name': self.partner_name,
|
||||
'email': self.email_from,
|
||||
'phone': self.partner_phone,
|
||||
'mobile': self.partner_mobile
|
||||
})
|
||||
self.partner_id = new_partner_id
|
||||
address_id = new_partner_id.address_get(['contact'])['contact']
|
||||
employee_data = {
|
||||
'default_name': self.partner_name or contact_name,
|
||||
'default_job_id': self.job_id.id,
|
||||
'default_job_title': self.job_id.name,
|
||||
'default_address_home_id': address_id,
|
||||
'default_department_id': self.department_id.id,
|
||||
'default_address_id': self.company_id.partner_id.id,
|
||||
'default_work_email': self.department_id.company_id.email or self.email_from, # To have a valid email address by default
|
||||
'default_work_phone': self.department_id.company_id.phone,
|
||||
'form_view_initial_mode': 'edit',
|
||||
'default_applicant_id': self.ids,
|
||||
}
|
||||
dict_act_window = self.env['ir.actions.act_window']._for_xml_id('hr.open_view_employee_list')
|
||||
dict_act_window['context'] = employee_data
|
||||
return dict_act_window
|
||||
|
||||
def _update_employee_from_applicant(self):
|
||||
# This method is to be overriden
|
||||
return
|
||||
|
||||
def archive_applicant(self):
|
||||
return {
|
||||
'type': 'ir.actions.act_window',
|
||||
'name': _('Refuse Reason'),
|
||||
'res_model': 'applicant.get.refuse.reason',
|
||||
'view_mode': 'form',
|
||||
'target': 'new',
|
||||
'context': {'default_applicant_ids': self.ids, 'active_test': False},
|
||||
'views': [[False, 'form']]
|
||||
}
|
||||
|
||||
def reset_applicant(self):
|
||||
""" Reinsert the applicant into the recruitment pipe in the first stage"""
|
||||
default_stage = dict()
|
||||
for job_id in self.mapped('job_id'):
|
||||
default_stage[job_id.id] = self.env['hr.recruitment.stage'].search(
|
||||
['|',
|
||||
('job_ids', '=', False),
|
||||
('job_ids', '=', job_id.id),
|
||||
('fold', '=', False)
|
||||
], order='sequence asc', limit=1).id
|
||||
for applicant in self:
|
||||
applicant.write(
|
||||
{'stage_id': applicant.job_id.id and default_stage[applicant.job_id.id],
|
||||
'refuse_reason_id': False})
|
||||
|
||||
def toggle_active(self):
|
||||
res = super(Applicant, self).toggle_active()
|
||||
applicant_active = self.filtered(lambda applicant: applicant.active)
|
||||
if applicant_active:
|
||||
applicant_active.reset_applicant()
|
||||
applicant_inactive = self.filtered(lambda applicant: not applicant.active)
|
||||
if applicant_inactive:
|
||||
return applicant_inactive.archive_applicant()
|
||||
return res
|
||||
|
||||
def action_send_email(self):
|
||||
return {
|
||||
'name': _('Send Email'),
|
||||
'type': 'ir.actions.act_window',
|
||||
'target': 'new',
|
||||
'view_mode': 'form',
|
||||
'res_model': 'applicant.send.mail',
|
||||
'context': {
|
||||
'default_applicant_ids': self.ids,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class ApplicantCategory(models.Model):
|
||||
_name = "hr.applicant.category"
|
||||
_description = "Category of applicant"
|
||||
|
||||
def _get_default_color(self):
|
||||
return randint(1, 11)
|
||||
|
||||
name = fields.Char("Tag Name", required=True)
|
||||
color = fields.Integer(string='Color Index', default=_get_default_color)
|
||||
|
||||
_sql_constraints = [
|
||||
('name_uniq', 'unique (name)', "Tag name already exists !"),
|
||||
]
|
||||
|
||||
|
||||
class ApplicantRefuseReason(models.Model):
|
||||
_name = "hr.applicant.refuse.reason"
|
||||
_description = 'Refuse Reason of Applicant'
|
||||
|
||||
name = fields.Char('Description', required=True, translate=True)
|
||||
template_id = fields.Many2one('mail.template', string='Email Template', domain="[('model', '=', 'hr.applicant')]")
|
||||
active = fields.Boolean('Active', default=True)
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import models
|
||||
|
||||
|
||||
class IrUiMenu(models.Model):
|
||||
_inherit = 'ir.ui.menu'
|
||||
|
||||
def _load_menus_blacklist(self):
|
||||
res = super()._load_menus_blacklist()
|
||||
job_menu = self.env.ref('hr_recruitment.menu_hr_job_position', raise_if_not_found=False)
|
||||
if job_menu and self.env.user.has_group('hr_recruitment.group_hr_recruitment_interviewer'):
|
||||
res.append(job_menu.id)
|
||||
return res
|
||||
|
|
@ -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 ResConfigSettings(models.TransientModel):
|
||||
_inherit = ['res.config.settings']
|
||||
|
||||
module_website_hr_recruitment = fields.Boolean(string='Online Posting')
|
||||
module_hr_recruitment_survey = fields.Boolean(string='Interview Forms')
|
||||
group_applicant_cv_display = fields.Boolean(implied_group="hr_recruitment.group_applicant_cv_display")
|
||||
module_hr_recruitment_extract = fields.Boolean(string='Send CV to OCR to fill applications')
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import models
|
||||
|
||||
class ResUsers(models.Model):
|
||||
_inherit = 'res.users'
|
||||
|
||||
def _create_recruitment_interviewers(self):
|
||||
if not self:
|
||||
return
|
||||
interviewer_group = self.env.ref('hr_recruitment.group_hr_recruitment_interviewer')
|
||||
recruitment_group = self.env.ref('hr_recruitment.group_hr_recruitment_user')
|
||||
|
||||
interviewers = self - recruitment_group.users
|
||||
interviewers.sudo().write({
|
||||
'groups_id': [(4, interviewer_group.id)]
|
||||
})
|
||||
|
||||
def _remove_recruitment_interviewers(self):
|
||||
if not self:
|
||||
return
|
||||
interviewer_group = self.env.ref('hr_recruitment.group_hr_recruitment_interviewer')
|
||||
recruitment_group = self.env.ref('hr_recruitment.group_hr_recruitment_user')
|
||||
|
||||
job_interviewers = self.env['hr.job']._read_group([('interviewer_ids', 'in', self.ids)], ['interviewer_ids'], ['interviewer_ids'])
|
||||
user_ids = {j['interviewer_ids'][0] for j in job_interviewers}
|
||||
|
||||
application_interviewers = self.env['hr.applicant']._read_group([('interviewer_ids', 'in', self.ids)], ['interviewer_ids'], ['interviewer_ids'])
|
||||
user_ids |= {a['interviewer_ids'][0] for a in application_interviewers}
|
||||
|
||||
# Remove users that are no longer interviewers on at least a job or an application
|
||||
users_to_remove = set(self.ids) - (user_ids | set(recruitment_group.users.ids))
|
||||
self.env['res.users'].browse(users_to_remove).sudo().write({
|
||||
'groups_id': [(3, interviewer_group.id)]
|
||||
})
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
# -*- coding:utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import _, api, models
|
||||
|
||||
from odoo.exceptions import UserError
|
||||
|
||||
|
||||
class UtmCampaign(models.Model):
|
||||
_inherit = 'utm.campaign'
|
||||
|
||||
@api.ondelete(at_uninstall=False)
|
||||
def _unlink_except_utm_campaign_job(self):
|
||||
utm_campaign_job = self.env.ref('hr_recruitment.utm_campaign_job', raise_if_not_found=False)
|
||||
if utm_campaign_job and utm_campaign_job in self:
|
||||
raise UserError(_(
|
||||
"The UTM campaign '%s' cannot be deleted as it is used in the recruitment process.",
|
||||
utm_campaign_job.name
|
||||
))
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
# -*- coding:utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import _, api, models
|
||||
|
||||
from odoo.exceptions import UserError
|
||||
|
||||
|
||||
class UtmSource(models.Model):
|
||||
_inherit = 'utm.source'
|
||||
|
||||
@api.ondelete(at_uninstall=False)
|
||||
def _unlink_except_linked_recruitment_sources(self):
|
||||
""" Already handled by ondelete='restrict', but let's show a nice error message """
|
||||
linked_recruitment_sources = self.env['hr.recruitment.source'].sudo().search([
|
||||
('source_id', 'in', self.ids)
|
||||
])
|
||||
|
||||
if linked_recruitment_sources:
|
||||
raise UserError(_(
|
||||
"You cannot delete these UTM Sources as they are linked to the following recruitment sources in "
|
||||
"Recruitment:\n%(recruitment_sources)s",
|
||||
recruitment_sources=', '.join(['"%s"' % name for name in linked_recruitment_sources.job_id.mapped('name')])))
|
||||
Loading…
Add table
Add a link
Reference in a new issue