You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

408 lines
13 KiB

import logging
from datetime import timedelta
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
_logger = logging.getLogger(__name__)
def add_days_delta(date_from, days_delta):
if not date_from:
return date_from
next_date = date_from + timedelta(days=days_delta)
return next_date
class ExemptReason(models.Model):
_name = "cooperative.exempt.reason"
_description = "cooperative.exempt.reason"
name = fields.Char(required=True)
class HistoryStatus(models.Model):
_name = "cooperative.status.history"
_description = "cooperative.status.history"
_order = "create_date desc"
status_id = fields.Many2one("cooperative.status")
cooperator_id = fields.Many2one("res.partner")
change = fields.Char()
type = fields.Selection(
[("status", "Status Change"), ("counter", "Counter Change")]
)
user_id = fields.Many2one("res.users", string="User")
class CooperativeStatus(models.Model):
_name = "cooperative.status"
_description = "cooperative.status"
_rec_name = "cooperator_id"
_order = "cooperator_id"
_period = 28
def _get_status(self):
return [
("ok", "Up to Date"),
("holiday", "Holidays"),
("alert", "Alerte"),
("extension", "Extension"),
("suspended", "Suspended"),
("exempted", "Exempted"),
("unsubscribed", "Unsubscribed"),
("resigning", "Resigning"),
]
today = fields.Date(
help="Field that allow to compute field and store them even if they "
"are based on the current date",
default=fields.Date.today,
)
cooperator_id = fields.Many2one("res.partner")
active = fields.Boolean(
related="cooperator_id.active", store=True, index=True
)
info_session = fields.Boolean("Information Session ?")
info_session_date = fields.Date("Information Session Date")
super = fields.Boolean("Super Cooperative")
sr = fields.Integer("Regular shifts counter", default=0)
sc = fields.Integer("Compensation shifts counter", default=0)
time_extension = fields.Integer(
"Extension Days NB",
default=0,
help="Addtional days to the automatic extension, 5 mean that you have "
"a total of 15 extension days of default one is set to 10",
)
holiday_start_time = fields.Date("Holidays Start Day")
holiday_end_time = fields.Date("Holidays End Day")
alert_start_time = fields.Date("Alert Start Day")
extension_start_time = fields.Date("Extension Start Day")
working_mode = fields.Selection(
[
("regular", "Regular worker"),
("irregular", "Irregular worker"),
("exempt", "Exempted"),
],
string="Working mode",
)
exempt_reason_id = fields.Many2one(
comodel_name="cooperative.exempt.reason", string="Exempt Reason"
)
status = fields.Selection(
selection=lambda x: x._get_status(),
compute="_compute_status",
string="Cooperative Status",
store=True,
)
can_shop = fields.Boolean(compute="_compute_can_shop", store=True)
history_ids = fields.One2many(
"cooperative.status.history", "status_id", readonly=True
)
unsubscribed = fields.Boolean(default=False, help="Manually unsubscribed")
resigning = fields.Boolean(
default=False, help="Want to leave the beescoop"
)
# Specific to irregular
irregular_start_date = fields.Date()
irregular_absence_date = fields.Date()
irregular_absence_counter = fields.Integer()
future_alert_date = fields.Date(compute="_compute_future_alert_date")
next_countdown_date = fields.Date(compute="_compute_next_countdown_date")
temporary_exempt_reason_id = fields.Many2one(
comodel_name="cooperative.exempt.reason",
string="Temporary Exempt Reason",
)
temporary_exempt_start_date = fields.Date()
temporary_exempt_end_date = fields.Date()
@api.depends("status")
def _compute_can_shop(self):
for rec in self:
rec.can_shop = rec.status in self._can_shop_status()
@api.depends(
"today",
"sr",
"sc",
"holiday_end_time",
"holiday_start_time",
"time_extension",
"alert_start_time",
"extension_start_time",
"unsubscribed",
"irregular_absence_date",
"irregular_absence_counter",
"temporary_exempt_start_date",
"temporary_exempt_end_date",
"resigning",
"cooperator_id.subscribed_shift_ids",
)
def _compute_status(self):
update = int(
self.env["ir.config_parameter"]
.sudo()
.get_param("always_update", False)
)
for rec in self:
if update or not rec.today:
rec.status = "ok"
continue
if rec.resigning:
rec.status = "resigning"
continue
if rec.working_mode == "regular":
rec.status = rec._get_regular_status()
elif rec.working_mode == "irregular":
rec.status = rec._get_irregular_status()
elif rec.working_mode == "exempt":
rec.status = "ok"
_sql_constraints = [
(
"cooperator_uniq",
"unique (cooperator_id)",
_("You can only set one cooperator status per cooperator"),
)
]
@api.constrains("working_mode", "irregular_start_date")
def _constrains_irregular_start_date(self):
if self.working_mode == "irregular" and not self.irregular_start_date:
raise UserError(
_("Irregular workers must have an irregular start date.")
)
@api.multi
def write(self, vals):
"""
Overwrite write to historize the change
"""
for field in [
"sr",
"sc",
"time_extension",
"extension_start_time",
"alert_start_time",
"unsubscribed",
]:
if field not in vals:
continue
for rec in self:
data = {
"status_id": rec.id,
"cooperator_id": rec.cooperator_id.id,
"type": "counter",
"user_id": self.env.context.get("real_uid", self.env.uid),
}
if vals.get(field, rec[field]) != rec[field]:
data["change"] = "{}: {} -> {}".format(
field.upper(), rec[field], vals.get(field)
)
self.env["cooperative.status.history"].sudo().create(data)
return super(CooperativeStatus, self).write(vals)
@api.multi
def _write(self, vals):
"""
Overwrite write to historize the change of status
and make action on status change
"""
if "status" in vals:
self._cr.execute(
'select id, status, sr, sc from "%s" where id in %%s'
% self._table,
(self._ids,),
)
result = self._cr.dictfetchall()
old_status_per_id = {r["id"]: r for r in result}
for rec in self:
if old_status_per_id[rec.id]["status"] != vals["status"]:
data = {
"status_id": rec.id,
"cooperator_id": rec.cooperator_id.id,
"type": "status",
"change": "STATUS: %s -> %s"
% (
old_status_per_id[rec.id]["status"],
vals["status"],
),
"user_id": self.env.context.get(
"real_uid", self.env.uid
),
}
self.env["cooperative.status.history"].sudo().create(data)
rec._state_change(vals["status"])
return super(CooperativeStatus, self)._write(vals)
def get_status_value(self):
"""
Workararound to get translated selection value instead of key in mail
template.
"""
state_list = (
self.env["cooperative.status"]
._fields["status"]
._description_selection(self.env)
)
return dict(state_list)[self.status]
@api.model
def _set_today(self):
"""
Method call by the cron to update store value base on the date
"""
self.search([]).write({"today": fields.Date.today()})
@api.model
def _cron_compute_counter_irregular(self, today=False):
"""
Journal ensure that a irregular worker will be only check
once per day
"""
today = today or fields.Date.today()
journal = self.env["beesdoo.shift.journal"].search(
[("date", "=", today)]
)
if not journal:
journal = self.env["beesdoo.shift.journal"].create({"date": today})
domain = self._get_irregular_worker_domain(today)
irregular = self.search(domain)
for status in irregular:
delta = (today - status.irregular_start_date).days
if (
delta
and delta % self._period == 0
and status not in journal.line_ids
):
status._change_irregular_counter()
journal.line_ids |= status
@api.multi
def clear_history(self):
self.ensure_one()
self.history_ids.unlink()
########################################################
# Method to override #
# To define the behavior of the status #
# #
# By default: everyone is always up to date #
########################################################
##############################
# Computed field section #
##############################
@api.depends("today")
def _compute_future_alert_date(self):
"""
Compute date until the worker is up to date
for irregular worker
"""
for rec in self:
rec.future_alert_date = False
@api.depends("today")
def _compute_next_countdown_date(self):
"""
Compute the following countdown date. This date is the date when
the worker will see his counter changed due to the cron. This
date is like the birthday date of the worker that occurred each
_period.
"""
for rec in self:
rec.next_countdown_date = False
def _can_shop_status(self):
"""
return the list of status that give access
to active cooperator privilege
"""
return ["ok", "alert", "extension", "exempted"]
#####################################
# Status Change implementation #
#####################################
def _get_regular_status(self):
"""
Return the value of the status
for the regular worker
"""
return "ok"
def _get_irregular_status(self):
"""
Return the value of the status
for the irregular worker
"""
return "ok"
def _state_change(self, new_state):
"""
Hook to watch change in the state
"""
pass
def _change_counter(self, data):
"""
Call when a shift state is changed
use data generated by _get_counter_date_state_change
"""
pass
###############################################
# Irregular Cron implementation #
###############################################
def _get_irregular_worker_domain(self, today):
"""
return the domain the give the list
of valid irregular worker that should
get their counter changed by the cron
"""
return [(0, "=", 1)]
def _change_irregular_counter(self):
"""
Define how the counter will change
for the irregular worker
where today - start_date is a multiple of the period
by default 28 days
"""
pass
class ShiftCronJournal(models.Model):
_name = "beesdoo.shift.journal"
_description = "beesdoo.shift.journal"
_order = "date desc"
_rec_name = "date"
date = fields.Date()
line_ids = fields.Many2many("cooperative.status")
_sql_constraints = [
(
"one_entry_per_day",
"unique (date)",
_("You can only create one journal per day"),
)
]
@api.multi
def run(self):
self.ensure_one()
if not self.user_has_groups("beesdoo_shift.group_cooperative_admin"):
raise ValidationError(
_("You don't have the access to perform this action")
)
self.sudo().env["cooperative.status"]._cron_compute_counter_irregular(
today=self.date
)