Odoo18-Base/addons/sale_timesheet/models/sale_order_line.py
2025-01-06 10:57:38 +07:00

203 lines
10 KiB
Python

# Part of Odoo. See LICENSE file for full copyright and licensing details.
from odoo import api, fields, models, _
from odoo.osv import expression
from odoo.tools import format_duration
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
qty_delivered_method = fields.Selection(selection_add=[('timesheet', 'Timesheets')])
analytic_line_ids = fields.One2many(domain=[('project_id', '=', False)]) # only analytic lines, not timesheets (since this field determine if SO line came from expense)
remaining_hours_available = fields.Boolean(compute='_compute_remaining_hours_available', compute_sudo=True)
remaining_hours = fields.Float('Time Remaining on SO', compute='_compute_remaining_hours', compute_sudo=True, store=True)
has_displayed_warning_upsell = fields.Boolean('Has Displayed Warning Upsell', copy=False, export_string_translation=False)
timesheet_ids = fields.One2many('account.analytic.line', 'so_line', domain=[('project_id', '!=', False)], string='Timesheets', export_string_translation=False)
@api.depends('remaining_hours_available', 'remaining_hours')
@api.depends_context('with_remaining_hours', 'company')
def _compute_display_name(self):
super()._compute_display_name()
with_remaining_hours = self.env.context.get('with_remaining_hours')
if with_remaining_hours and any(line.remaining_hours_available for line in self):
company = self.env.company
encoding_uom = company.timesheet_encode_uom_id
is_hour = is_day = False
unit_label = ''
if encoding_uom == self.env.ref('uom.product_uom_hour'):
is_hour = True
unit_label = _('remaining')
elif encoding_uom == self.env.ref('uom.product_uom_day'):
is_day = True
unit_label = _('days remaining')
for line in self:
if line.remaining_hours_available:
remaining_time = ''
if is_hour:
remaining_time = f' ({format_duration(line.remaining_hours)} {unit_label})'
elif is_day:
remaining_days = company.project_time_mode_id._compute_quantity(line.remaining_hours, encoding_uom, round=False)
remaining_time = f' ({remaining_days:.02f} {unit_label})'
name = f'{line.display_name}{remaining_time}'
line.display_name = name
@api.depends('product_id.service_policy')
def _compute_remaining_hours_available(self):
uom_hour = self.env.ref('uom.product_uom_hour')
for line in self:
is_ordered_prepaid = line.product_id.service_policy == 'ordered_prepaid'
is_time_product = line.product_uom.category_id == uom_hour.category_id
line.remaining_hours_available = is_ordered_prepaid and is_time_product
@api.depends('qty_delivered', 'product_uom_qty', 'analytic_line_ids')
def _compute_remaining_hours(self):
uom_hour = self.env.ref('uom.product_uom_hour')
for line in self:
remaining_hours = None
if line.remaining_hours_available:
qty_left = line.product_uom_qty - line.qty_delivered
remaining_hours = line.product_uom._compute_quantity(qty_left, uom_hour)
line.remaining_hours = remaining_hours
@api.depends('product_id')
def _compute_qty_delivered_method(self):
""" Sale Timesheet module compute delivered qty for product [('type', 'in', ['service']), ('service_type', '=', 'timesheet')] """
super()._compute_qty_delivered_method()
for line in self:
if not line.is_expense and line.product_id.type == 'service' and line.product_id.service_type == 'timesheet':
line.qty_delivered_method = 'timesheet'
@api.depends('analytic_line_ids.project_id', 'project_id.pricing_type')
def _compute_qty_delivered(self):
super()._compute_qty_delivered()
lines_by_timesheet = self.filtered(lambda sol: sol.qty_delivered_method == 'timesheet')
domain = lines_by_timesheet._timesheet_compute_delivered_quantity_domain()
mapping = lines_by_timesheet.sudo()._get_delivered_quantity_by_analytic(domain)
for line in lines_by_timesheet:
line.qty_delivered = mapping.get(line.id or line._origin.id, 0.0)
def _timesheet_compute_delivered_quantity_domain(self):
""" Hook for validated timesheet in addionnal module """
domain = [('project_id', '!=', False)]
if self._context.get('accrual_entry_date'):
domain += [('date', '<=', self._context['accrual_entry_date'])]
return domain
###########################################
# Service : Project and task generation
###########################################
def _convert_qty_company_hours(self, dest_company):
company_time_uom_id = dest_company.project_time_mode_id
allocated_hours = 0.0
product_uom = self.product_uom
if product_uom == self.env.ref('uom.product_uom_unit'):
product_uom = self.env.ref('uom.product_uom_hour')
if product_uom.category_id == company_time_uom_id.category_id:
if product_uom != company_time_uom_id:
allocated_hours = product_uom._compute_quantity(self.product_uom_qty, company_time_uom_id)
else:
allocated_hours = self.product_uom_qty
return allocated_hours
def _timesheet_create_project(self):
project = super()._timesheet_create_project()
# we can skip all the allocated hours calculation if allocated hours is already set on the template project
if self.product_id.project_template_id.allocated_hours:
project.write({
'allocated_hours': self.product_id.project_template_id.allocated_hours,
'allow_timesheets': True,
})
return project
project_uom = self.company_id.project_time_mode_id
uom_unit = self.env.ref('uom.product_uom_unit')
uom_hour = self.env.ref('uom.product_uom_hour')
# dict of inverse factors for each relevant UoM found in SO
factor_inv_per_id = {
uom.id: uom.factor_inv
for uom in self.order_id.order_line.product_uom
if uom.category_id == project_uom.category_id
}
# if sold as units, assume hours for time allocation
factor_inv_per_id[uom_unit.id] = uom_hour.factor_inv
allocated_hours = 0.0
# method only called once per project, so also allocate hours for
# all lines in SO that will share the same project
for line in self.order_id.order_line:
if line.is_service \
and line.product_id.service_tracking in ['task_in_project', 'project_only'] \
and line.product_id.project_template_id == self.product_id.project_template_id \
and line.product_uom.id in factor_inv_per_id:
uom_factor = project_uom.factor * factor_inv_per_id[line.product_uom.id]
allocated_hours += line.product_uom_qty * uom_factor
project.write({
'allocated_hours': allocated_hours,
'allow_timesheets': True,
})
return project
def _timesheet_create_project_prepare_values(self):
"""Generate project values"""
values = super()._timesheet_create_project_prepare_values()
values['allow_billable'] = True
return values
def _recompute_qty_to_invoice(self, start_date, end_date):
""" Recompute the qty_to_invoice field for product containing timesheets
Search the existed timesheets between the given period in parameter.
Retrieve the unit_amount of this timesheet and then recompute
the qty_to_invoice for each current product.
:param start_date: the start date of the period
:param end_date: the end date of the period
"""
lines_by_timesheet = self.filtered(lambda sol: sol.product_id and sol.product_id._is_delivered_timesheet())
domain = lines_by_timesheet._timesheet_compute_delivered_quantity_domain()
refund_account_moves = self.order_id.invoice_ids.filtered(lambda am: am.state == 'posted' and am.move_type == 'out_refund').reversed_entry_id
timesheet_domain = [
'|',
('timesheet_invoice_id', '=', False),
('timesheet_invoice_id.state', '=', 'cancel')]
if refund_account_moves:
credited_timesheet_domain = [('timesheet_invoice_id.state', '=', 'posted'), ('timesheet_invoice_id', 'in', refund_account_moves.ids)]
timesheet_domain = expression.OR([timesheet_domain, credited_timesheet_domain])
domain = expression.AND([domain, timesheet_domain])
if start_date:
domain = expression.AND([domain, [('date', '>=', start_date)]])
if end_date:
domain = expression.AND([domain, [('date', '<=', end_date)]])
mapping = lines_by_timesheet.sudo()._get_delivered_quantity_by_analytic(domain)
for line in lines_by_timesheet:
qty_to_invoice = mapping.get(line.id, 0.0)
if qty_to_invoice:
line.qty_to_invoice = qty_to_invoice
else:
prev_inv_status = line.invoice_status
line.qty_to_invoice = qty_to_invoice
line.invoice_status = prev_inv_status
def _get_action_per_item(self):
""" Get action per Sales Order Item
When the Sales Order Item contains a service product then the action will be View Timesheets.
:returns: Dict containing id of SOL as key and the action as value
"""
action_per_sol = super()._get_action_per_item()
timesheet_action = self.env.ref('sale_timesheet.timesheet_action_from_sales_order_item').id
timesheet_ids_per_sol = {}
if self.env.user.has_group('hr_timesheet.group_hr_timesheet_user'):
timesheet_read_group = self.env['account.analytic.line']._read_group([('so_line', 'in', self.ids), ('project_id', '!=', False)], ['so_line'], ['id:array_agg'])
timesheet_ids_per_sol = {so_line.id: ids for so_line, ids in timesheet_read_group}
for sol in self:
timesheet_ids = timesheet_ids_per_sol.get(sol.id, [])
if sol.is_service and len(timesheet_ids) > 0:
action_per_sol[sol.id] = timesheet_action, timesheet_ids[0] if len(timesheet_ids) == 1 else False
return action_per_sol