Files
enterprise-addons/sale_renting_planning/models/planning_slot.py
T

199 lines
9.1 KiB
Python

import pytz
from ast import literal_eval
from collections import defaultdict
from random import shuffle
from odoo import Command, api, fields, models
from odoo.exceptions import ValidationError
from odoo.tools import float_compare
from odoo.tools.intervals import Intervals
class PlanningSlot(models.Model):
_inherit = 'planning.slot'
role_sync_shift_rental = fields.Boolean(related='role_id.sync_shift_rental')
def write(self, vals):
res = super().write(vals)
if (
not self.env.context.get('rental_order_updated')
and any(vals.get(k) for k in ['start_datetime', 'end_datetime'])
and (rental_slots := self.exists().filtered('role_sync_shift_rental'))
):
if rental_slots.filtered('overlap_slot_count'):
raise ValidationError(self.env._('Shift not rescheduled due to conflicts'))
rental_orders = rental_slots.sale_order_id.filtered('is_rental_order')
if not rental_orders:
return res
order_vals = dict()
if start_datetime := vals.get('start_datetime'):
order_vals['rental_start_date'] = start_datetime
if end_datetime := vals.get('end_datetime'):
order_vals['rental_return_date'] = end_datetime
update_sale_orders = rental_orders.filtered(lambda so:
start_datetime and so.rental_start_date != start_datetime
or end_datetime and so.rental_return_date != end_datetime
)
if update_sale_orders:
update_sale_orders.write(order_vals)
SaleOrderLine = self.env['sale.order.line']
self.env.add_to_compute(
SaleOrderLine._fields['name'],
update_sale_orders.order_line.filtered('is_rental')
)
return res
@api.ondelete(at_uninstall=False)
def _update_order_line_count(self):
for line, slots in self.grouped('sale_line_id').items():
if line:
line.update_product_uom_qty(line.planning_slot_ids - slots)
def action_create_order(self):
self.ensure_one()
if self.overlap_slot_count:
raise ValidationError(self.env._('Impossible to generate a rental order for a shift in conflict.'))
action = self.env['ir.actions.actions']._for_xml_id('sale_renting.rental_order_action')
context = literal_eval(action.get('context', '{}'))
context.update(
default_is_rental_order=True,
default_rental_start_date=self.start_datetime,
default_rental_return_date=self.end_datetime,
)
if products := self.role_id.product_ids.filtered('rent_ok'):
uom_hour = self.env.ref('uom.product_uom_hour')
context['default_order_line'] = [
Command.create({
'product_id': products[0].product_variant_id.id,
'is_rental': True,
'product_uom_qty': self.allocated_hours if products[:1].uom_id == uom_hour else 1,
'planning_slot_ids': self.ids,
}),
]
return {
**action,
'view_mode': 'form',
'views': [(view_id, view_type) for view_id, view_type in action['views'] if view_type == 'form'],
'target': 'current',
'context': context,
}
def action_add_last_order(self):
self.ensure_one()
if self.overlap_slot_count:
raise ValidationError(self.env._('The shift should not be in conflict to be able to correctly add it to an existing rental order.'))
order = self.env['sale.order'].search([
('is_rental_order', '=', True),
('user_id', '=', self.env.uid),
('state', '=', 'sale'),
], limit=1)
if not order:
raise ValidationError(self.env._('No Rental Order is found.'))
products = self.role_id.product_ids.filtered('rent_ok')
for sol in order.order_line:
if sol.product_template_id in products and float_compare(sol.planning_hours_to_plan, 0, precision_rounding=sol.product_uom_id.rounding) == 0:
self.sale_line_id = sol
break
if self.role_sync_shift_rental:
if order.rental_start_date != self.start_datetime or order.rental_return_date != self.end_datetime:
self.write({
'start_datetime': order.rental_start_date,
'end_datetime': order.rental_return_date,
})
if not self.sale_line_id:
sale_line = order.order_line.filtered(
lambda l: l.is_rental and l.product_template_id in products
)[:1]
if sale_line:
self.sale_line_id = sale_line
else:
uom_hour = self.env.ref('uom.product_uom_hour')
product = products[:1]
self.sale_line_id = self.env['sale.order.line'].with_context(planning_slot_generation=False).create({
'product_id': product.product_variant_id.id,
'is_rental': True,
'product_uom_qty': self.allocated_hours if product.uom_id == uom_hour else 1,
'order_id': order.id,
'planning_slot_ids': self.ids,
})
self.state = 'published'
if not self.resource_id:
self._set_slot_resource()
self.sale_line_id.update_product_uom_qty(self.sale_line_id.planning_slot_ids)
if not (order.rental_start_date == self.start_datetime and order.rental_return_date == self.end_datetime):
min_start_datetime, max_end_datetime = self.env['planning.slot']._read_group(
[('sale_order_id', '=', order.id)],
[],
['start_datetime:min', 'end_datetime:max'],
)[0]
order.with_context(slots_rescheduled=True).write({'rental_start_date': min_start_datetime, 'rental_return_date': max_end_datetime})
SaleOrderLine = self.env['sale.order.line']
self.env.add_to_compute(
SaleOrderLine._fields['name'],
order.order_line.filtered('is_rental')
)
return {
'type': 'ir.actions.client',
'tag': 'display_notification',
'params': {
'type': 'success',
'message': self.env._('Shift added to last order'),
},
}
def _set_slot_resource(self):
# ensure role id is correctly set
for slot in self:
if not slot.role_id and slot.sale_line_id:
slot.role_id = slot.sale_line_id.sudo().product_id.planning_role_id
available_resources = self.role_id.resource_ids
if not available_resources:
return
resources_per_role = dict(
self.env['resource.resource']._read_group(
[('role_ids', 'in', self.role_id.ids)],
['role_ids'],
['id:recordset'],
)
)
def get_utc_timezone(utc_datetime):
return pytz.utc.localize(utc_datetime)
min_start_datetime = min(self.mapped('start_datetime'))
max_end_datetime = max(self.mapped('end_datetime'))
slots_per_resource = self.env['planning.slot']._read_group([
('resource_id', 'in', available_resources.ids),
('start_datetime', '<=', max_end_datetime),
('end_datetime', '>=', min_start_datetime),
], ['resource_id'], ['id:recordset'])
unavailable_intervals_per_resource = defaultdict(Intervals)
for resource, slots in slots_per_resource:
unavailable_intervals_per_resource[resource.id] |= Intervals([(get_utc_timezone(s.start_datetime), get_utc_timezone(s.end_datetime), s) for s in slots])
work_intervals_per_resource, _dummy = available_resources._get_valid_work_intervals(get_utc_timezone(min_start_datetime), get_utc_timezone(max_end_datetime))
problematic_shifts = self.env['planning.slot']
for slot in self:
slot_interval = Intervals([(get_utc_timezone(slot.start_datetime), get_utc_timezone(slot.end_datetime), slot)])
resources = resources_per_role.get(slot.role_id, self.env['resource.resource'])
shuffle(order := list(range(len(resources))))
for i in order:
resource = resources[i]
work_intervals = work_intervals_per_resource[resource.id]
unavailable_intervals = unavailable_intervals_per_resource.get(resource.id, Intervals())
if not (unavailable_intervals & slot_interval) and (work_intervals & slot_interval):
slot.resource_id = resource
unavailable_intervals_per_resource[resource.id] |= slot_interval
break
if not slot.resource_id:
problematic_shifts += slot
if problematic_shifts:
raise ValidationError(
self.env._(
"No resources are available for the shifts in: %s.",
", ".join(problematic_shifts.sale_line_id.product_id.mapped('name'))
)
)