class ResumeLine(models.Model):
_name = 'hr.resume.line'
_description = "Resumé line of an employee"
_order = "line_type_id, date_end desc, date_start desc"
employee_id = fields.Many2one('hr.employee',
required=True,
ondelete='cascade')
name = fields.Char(required=True)
date_start = fields.Date(required=True)
date_end = fields.Date()
description = fields.Text(string="Description")
line_type_id = fields.Many2one('hr.resume.line.type', string="Type")
# Used to apply specific template on a line
display_type = fields.Selection([('classic', 'Classic')],
string="Display Type",
default='classic')
_sql_constraints = [
('date_check', "CHECK ((date_start <= date_end OR date_end = NULL))",
"The start date must be anterior to the end date."),
]
class SaleOrder(models.Model):
_inherit = "sale.order"
date = fields.Date()
recipients_of_email = fields.Many2many(comodel_name='res.partner',
relation='customer',
column1='partner_id',
column2='partner_name',
string="Recipients of the Email")
subject = fields.Text('Subject')
email_content = fields.Text('Email Content')
@api.model
def send_email_from_customer(self):
today_date = date.today()
current_date = str(today_date)
obj = self.env['sale.order'].search([('state', 'in', ('sale', 'done'))
])
if obj:
context = self._context
current_uid = context.get('uid')
current_login_user = self.env['res.users'].browse(current_uid)
for order in obj:
email_to = []
order_date = str(order.date)
if order and current_date == order_date:
for record in order.recipients_of_email:
if record.email:
email_to.append(record)
if email_to:
mail = {
'subject': order.subject,
'email_from': order.partner_id.email,
'recipient_ids':
[(6, 0, [v.id for v in email_to])],
'body_html': order.email_content,
}
if mail:
mail_create = current_login_user.env[
'mail.mail'].create(mail)
if mail_create:
mail_create.send()
self.mail_id = mail_create
class TimesheetAttendance(models.Model):
_name = 'hr.timesheet.attendance.report'
_auto = False
_description = 'Timesheet Attendance Report'
user_id = fields.Many2one('res.users')
date = fields.Date()
total_timesheet = fields.Float()
total_attendance = fields.Float()
total_difference = fields.Float()
def init(self):
tools.drop_view_if_exists(self.env.cr, self._table)
self._cr.execute("""CREATE OR REPLACE VIEW %s AS (
SELECT
max(id) AS id,
t.user_id,
t.date,
coalesce(sum(t.attendance), 0) AS total_attendance,
coalesce(sum(t.timesheet), 0) AS total_timesheet,
coalesce(sum(t.attendance), 0) - coalesce(sum(t.timesheet), 0) as total_difference
FROM (
SELECT
-hr_attendance.id AS id,
resource_resource.user_id AS user_id,
hr_attendance.worked_hours AS attendance,
NULL AS timesheet,
hr_attendance.check_in::date AS date
FROM hr_attendance
LEFT JOIN hr_employee ON hr_employee.id = hr_attendance.employee_id
LEFT JOIN resource_resource on resource_resource.id = hr_employee.resource_id
UNION ALL
SELECT
ts.id AS id,
ts.user_id AS user_id,
NULL AS attendance,
ts.unit_amount AS timesheet,
ts.date AS date
FROM account_analytic_line AS ts
WHERE ts.project_id IS NOT NULL
) AS t
GROUP BY t.user_id, t.date
ORDER BY t.date
)
""" % self._table)
class CashmoveReport(models.Model):
_name = "lunch.cashmove.report"
_description = 'Cashmoves report'
_auto = False
_order = "date desc"
id = fields.Integer('ID')
amount = fields.Float('Amount')
date = fields.Date('Date')
currency_id = fields.Many2one('res.currency', string='Currency')
user_id = fields.Many2one('res.users', string='User')
description = fields.Text('Description')
def name_get(self):
return [(cashmove.id, '%s %s' % (_('Lunch Cashmove'), '#%d' % cashmove.id)) for cashmove in self]
def init(self):
tools.drop_view_if_exists(self._cr, self._table)
self._cr.execute("""
CREATE or REPLACE view %s as (
SELECT
lc.id as id,
lc.amount as amount,
lc.date as date,
lc.currency_id as currency_id,
lc.user_id as user_id,
lc.description as description
FROM lunch_cashmove lc
UNION ALL
SELECT
-lol.id as id,
-lol.price as amount,
lol.date as date,
lol.currency_id as currency_id,
lol.user_id as user_id,
format('Order: %%s x %%s %%s', lol.quantity::text, lp.name, lol.display_toppings) as description
FROM lunch_order lol
JOIN lunch_product lp ON lp.id = lol.product_id
WHERE
lol.state in ('ordered', 'confirmed')
AND lol.active = True
);
""" % self._table)
class StockInventory(models.Model):
_inherit = "stock.inventory"
accounting_date = fields.Date(
'Accounting Date',
help="Date at which the accounting entries will be created"
" in case of automated inventory valuation."
" If empty, the inventory date will be used.")
has_account_moves = fields.Boolean(compute='_compute_has_account_moves')
def _compute_has_account_moves(self):
for inventory in self:
if inventory.state == 'done' and inventory.move_ids:
account_move = self.env['account.move'].search_count([
('stock_move_id.id', 'in', inventory.move_ids.ids)
])
inventory.has_account_moves = account_move > 0
else:
inventory.has_account_moves = False
def action_get_account_moves(self):
self.ensure_one()
action_ref = self.env.ref('account.action_move_journal_line')
if not action_ref:
return False
action_data = action_ref.read()[0]
action_data['domain'] = [('stock_move_id.id', 'in', self.move_ids.ids)]
action_data['context'] = dict(self._context, create=False)
return action_data
def post_inventory(self):
res = True
acc_inventories = self.filtered(
lambda inventory: inventory.accounting_date)
for inventory in acc_inventories:
res = super(
StockInventory,
inventory.with_context(force_period_date=inventory.
accounting_date)).post_inventory()
other_inventories = self - acc_inventories
if other_inventories:
res = super(StockInventory, other_inventories).post_inventory()
return res
class LunchProduct(models.Model):
""" Products available to order. A product is linked to a specific vendor. """
_name = 'lunch.product'
_description = 'Lunch Product'
_inherit = 'image.mixin'
_order = 'name'
name = fields.Char('Product Name', required=True)
category_id = fields.Many2one('lunch.product.category', 'Product Category', required=True)
description = fields.Text('Description')
price = fields.Float('Price', digits='Account', required=True)
supplier_id = fields.Many2one('lunch.supplier', 'Vendor', required=True)
active = fields.Boolean(default=True)
company_id = fields.Many2one('res.company', related='supplier_id.company_id', store=True)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
new_until = fields.Date('New Until')
favorite_user_ids = fields.Many2many('res.users', 'lunch_product_favorite_user_rel', 'product_id', 'user_id')
class User(models.Model):
_inherit = ['res.users']
medic_exam = fields.Date(related="employee_id.medic_exam")
vehicle = fields.Char(related="employee_id.vehicle")
bank_account_id = fields.Many2one(related="employee_id.bank_account_id")
def __init__(self, pool, cr):
""" Override of __init__ to add access rights.
Access rights are disabled by default, but allowed
on some specific fields defined in self.SELF_{READ/WRITE}ABLE_FIELDS.
"""
contract_readable_fields = [
'medic_exam',
'vehicle',
'bank_account_id',
]
init_res = super(User, self).__init__(pool, cr)
# duplicate list to avoid modifying the original reference
type(self).SELF_READABLE_FIELDS = type(
self).SELF_READABLE_FIELDS + contract_readable_fields
return init_res
class ResPartner(models.Model):
_inherit = "res.partner"
date_localization = fields.Date(string='Geolocation Date')
@api.model
def _geo_localize(self, street='', zip='', city='', state='', country=''):
geo_obj = self.env['base.geocoder']
search = geo_obj.geo_query_address(street=street,
zip=zip,
city=city,
state=state,
country=country)
result = geo_obj.geo_find(search, force_country=country)
if result is None:
search = geo_obj.geo_query_address(city=city,
state=state,
country=country)
result = geo_obj.geo_find(search, force_country=country)
return result
def geo_localize(self):
# We need country names in English below
for partner in self.with_context(lang='en_US'):
result = self._geo_localize(partner.street, partner.zip,
partner.city, partner.state_id.name,
partner.country_id.name)
if result:
partner.write({
'partner_latitude':
result[0],
'partner_longitude':
result[1],
'date_localization':
fields.Date.context_today(partner)
})
return True
class HrEmployeeBase(models.AbstractModel):
_inherit = "hr.employee.base"
leave_manager_id = fields.Many2one(
'res.users',
string='Time Off',
help="User responsible of leaves approval.")
remaining_leaves = fields.Float(
compute='_compute_remaining_leaves',
string='Remaining Paid Time Off',
help=
'Total number of paid time off allocated to this employee, change this value to create allocation/time off request. '
'Total based on all the time off types without overriding limit.')
current_leave_state = fields.Selection(compute='_compute_leave_status',
string="Current Time Off Status",
selection=[
('draft', 'New'),
('confirm', 'Waiting Approval'),
('refuse', 'Refused'),
('validate1',
'Waiting Second Approval'),
('validate', 'Approved'),
('cancel', 'Cancelled')
])
current_leave_id = fields.Many2one('hr.leave.type',
compute='_compute_leave_status',
string="Current Time Off Type")
leave_date_from = fields.Date('From Date', compute='_compute_leave_status')
leave_date_to = fields.Date('To Date', compute='_compute_leave_status')
leaves_count = fields.Float('Number of Time Off',
compute='_compute_remaining_leaves')
allocation_count = fields.Float('Total number of days allocated.',
compute='_compute_allocation_count')
allocation_used_count = fields.Float(
'Total number of days off used',
compute='_compute_total_allocation_used')
show_leaves = fields.Boolean('Able to see Remaining Time Off',
compute='_compute_show_leaves')
is_absent = fields.Boolean('Absent Today',
compute='_compute_leave_status',
search='_search_absent_employee')
allocation_display = fields.Char(compute='_compute_allocation_count')
allocation_used_display = fields.Char(
compute='_compute_total_allocation_used')
def _get_date_start_work(self):
return self.create_date
def _get_remaining_leaves(self):
""" Helper to compute the remaining leaves for the current employees
:returns dict where the key is the employee id, and the value is the remain leaves
"""
self._cr.execute(
"""
SELECT
sum(h.number_of_days) AS days,
h.employee_id
FROM
(
SELECT holiday_status_id, number_of_days,
state, employee_id
FROM hr_leave_allocation
UNION ALL
SELECT holiday_status_id, (number_of_days * -1) as number_of_days,
state, employee_id
FROM hr_leave
) h
join hr_leave_type s ON (s.id=h.holiday_status_id)
WHERE
s.active = true AND h.state='validate' AND
(s.allocation_type='fixed' OR s.allocation_type='fixed_allocation') AND
h.employee_id in %s
GROUP BY h.employee_id""", (tuple(self.ids), ))
return dict((row['employee_id'], row['days'])
for row in self._cr.dictfetchall())
def _compute_remaining_leaves(self):
remaining = self._get_remaining_leaves()
for employee in self:
value = float_round(remaining.get(employee.id, 0.0),
precision_digits=2)
employee.leaves_count = value
employee.remaining_leaves = value
def _compute_allocation_count(self):
for employee in self:
allocations = self.env['hr.leave.allocation'].search([
('employee_id', '=', employee.id),
('holiday_status_id.active', '=', True),
('state', '=', 'validate'),
])
employee.allocation_count = sum(
allocations.mapped('number_of_days'))
employee.allocation_display = "%g" % employee.allocation_count
def _compute_total_allocation_used(self):
for employee in self:
employee.allocation_used_count = employee.allocation_count - employee.remaining_leaves
employee.allocation_used_display = "%g" % employee.allocation_used_count
def _compute_presence_state(self):
super()._compute_presence_state()
employees = self.filtered(lambda employee: employee.hr_presence_state
!= 'present' and employee.is_absent)
employees.update({'hr_presence_state': 'absent'})
def _compute_leave_status(self):
# Used SUPERUSER_ID to forcefully get status of other user's leave, to bypass record rule
holidays = self.env['hr.leave'].sudo().search([
('employee_id', 'in', self.ids),
('date_from', '<=', fields.Datetime.now()),
('date_to', '>=', fields.Datetime.now()),
('state', 'not in', ('cancel', 'refuse'))
])
leave_data = {}
for holiday in holidays:
leave_data[holiday.employee_id.id] = {}
leave_data[holiday.employee_id.
id]['leave_date_from'] = holiday.date_from.date()
leave_data[holiday.employee_id.
id]['leave_date_to'] = holiday.date_to.date()
leave_data[
holiday.employee_id.id]['current_leave_state'] = holiday.state
leave_data[holiday.employee_id.
id]['current_leave_id'] = holiday.holiday_status_id.id
for employee in self:
employee.leave_date_from = leave_data.get(
employee.id, {}).get('leave_date_from')
employee.leave_date_to = leave_data.get(employee.id,
{}).get('leave_date_to')
employee.current_leave_state = leave_data.get(
employee.id, {}).get('current_leave_state')
employee.current_leave_id = leave_data.get(
employee.id, {}).get('current_leave_id')
employee.is_absent = leave_data.get(
employee.id) and leave_data.get(
employee.id, {}).get('current_leave_state') not in [
'cancel', 'refuse', 'draft'
]
@api.onchange('parent_id')
def _onchange_parent_id(self):
super(HrEmployeeBase, self)._onchange_parent_id()
previous_manager = self._origin.parent_id.user_id
manager = self.parent_id.user_id
if manager and self.leave_manager_id == previous_manager or not self.leave_manager_id:
self.leave_manager_id = manager
def _compute_show_leaves(self):
show_leaves = self.env['res.users'].has_group(
'hr_holidays.group_hr_holidays_user')
for employee in self:
if show_leaves or employee.user_id == self.env.user:
employee.show_leaves = True
else:
employee.show_leaves = False
def _search_absent_employee(self, operator, value):
holidays = self.env['hr.leave'].sudo().search([
('employee_id', '!=', False),
('state', 'not in', ['cancel', 'refuse']),
('date_from', '<=', datetime.datetime.utcnow()),
('date_to', '>=', datetime.datetime.utcnow())
])
return [('id', 'in', holidays.mapped('employee_id').ids)]
@api.model
def create(self, values):
if 'parent_id' in values:
manager = self.env['hr.employee'].browse(
values['parent_id']).user_id
values['leave_manager_id'] = values.get('leave_manager_id',
manager.id)
if values.get('leave_manager_id', False):
approver_group = self.env.ref(
'hr_holidays.group_hr_holidays_responsible',
raise_if_not_found=False)
if approver_group:
approver_group.sudo().write(
{'users': [(4, values['leave_manager_id'])]})
return super(HrEmployeeBase, self).create(values)
def write(self, values):
if 'parent_id' in values:
manager = self.env['hr.employee'].browse(
values['parent_id']).user_id
if manager:
to_change = self.filtered(
lambda e: e.leave_manager_id == e.parent_id.user_id or
not e.leave_manager_id)
to_change.write({
'leave_manager_id':
values.get('leave_manager_id', manager.id)
})
old_managers = self.env['res.users']
if 'leave_manager_id' in values:
old_managers = self.mapped('leave_manager_id')
if values['leave_manager_id']:
old_managers -= self.env['res.users'].browse(
values['leave_manager_id'])
approver_group = self.env.ref(
'hr_holidays.group_hr_holidays_responsible',
raise_if_not_found=False)
if approver_group:
approver_group.sudo().write(
{'users': [(4, values['leave_manager_id'])]})
res = super(HrEmployeeBase, self).write(values)
# remove users from the Responsible group if they are no longer leave managers
old_managers._clean_leave_responsible_users()
if 'parent_id' in values or 'department_id' in values:
today_date = fields.Datetime.now()
hr_vals = {}
if values.get('parent_id') is not None:
hr_vals['manager_id'] = values['parent_id']
if values.get('department_id') is not None:
hr_vals['department_id'] = values['department_id']
holidays = self.env['hr.leave'].sudo().search([
'|', ('state', 'in', ['draft', 'confirm']),
('date_from', '>', today_date), ('employee_id', 'in', self.ids)
])
holidays.write(hr_vals)
allocations = self.env['hr.leave.allocation'].sudo().search([
('state', 'in', ['draft', 'confirm']),
('employee_id', 'in', self.ids)
])
allocations.write(hr_vals)
return res
class CrmLead(models.Model):
_inherit = "crm.lead"
partner_latitude = fields.Float('Geo Latitude', digits=(16, 5))
partner_longitude = fields.Float('Geo Longitude', digits=(16, 5))
partner_assigned_id = fields.Many2one(
'res.partner',
'Assigned Partner',
tracking=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
help="Partner this case has been forwarded/assigned to.",
index=True)
partner_declined_ids = fields.Many2many('res.partner',
'crm_lead_declined_partner',
'lead_id',
'partner_id',
string='Partner not interested')
date_assign = fields.Date(
'Partner Assignation Date',
help="Last date this case was forwarded/assigned to a partner")
def _merge_data(self, fields):
fields += [
'partner_latitude', 'partner_longitude', 'partner_assigned_id',
'date_assign'
]
return super(CrmLead, self)._merge_data(fields)
@api.onchange("partner_assigned_id")
def onchange_assign_id(self):
"""This function updates the "assignation date" automatically, when manually assign a partner in the geo assign tab
"""
partner_assigned = self.partner_assigned_id
if not partner_assigned:
self.date_assign = False
else:
self.date_assign = fields.Date.context_today(self)
self.user_id = partner_assigned.user_id
def assign_salesman_of_assigned_partner(self):
salesmans_leads = {}
for lead in self:
if (lead.probability > 0
and lead.probability < 100) or lead.stage_id.sequence == 1:
if lead.partner_assigned_id and lead.partner_assigned_id.user_id != lead.user_id:
salesmans_leads.setdefault(
lead.partner_assigned_id.user_id.id,
[]).append(lead.id)
for salesman_id, leads_ids in salesmans_leads.items():
leads = self.browse(leads_ids)
leads.write({'user_id': salesman_id})
def action_assign_partner(self):
return self.assign_partner(partner_id=False)
def assign_partner(self, partner_id=False):
partner_dict = {}
res = False
if not partner_id:
partner_dict = self.search_geo_partner()
for lead in self:
if not partner_id:
partner_id = partner_dict.get(lead.id, False)
if not partner_id:
tag_to_add = self.env.ref(
'website_crm_partner_assign.tag_portal_lead_partner_unavailable',
False)
lead.write({'tag_ids': [(4, tag_to_add.id, False)]})
continue
lead.assign_geo_localize(lead.partner_latitude,
lead.partner_longitude)
partner = self.env['res.partner'].browse(partner_id)
if partner.user_id:
lead.allocate_salesman(partner.user_id.ids,
team_id=partner.team_id.id)
values = {
'date_assign': fields.Date.context_today(lead),
'partner_assigned_id': partner_id
}
lead.write(values)
return res
def assign_geo_localize(self, latitude=False, longitude=False):
if latitude and longitude:
self.write({
'partner_latitude': latitude,
'partner_longitude': longitude
})
return True
# Don't pass context to browse()! We need country name in english below
for lead in self:
if lead.partner_latitude and lead.partner_longitude:
continue
if lead.country_id:
result = self.env['res.partner']._geo_localize(
lead.street, lead.zip, lead.city, lead.state_id.name,
lead.country_id.name)
if result:
lead.write({
'partner_latitude': result[0],
'partner_longitude': result[1]
})
return True
def search_geo_partner(self):
Partner = self.env['res.partner']
res_partner_ids = {}
self.assign_geo_localize()
for lead in self:
partner_ids = []
if not lead.country_id:
continue
latitude = lead.partner_latitude
longitude = lead.partner_longitude
if latitude and longitude:
# 1. first way: in the same country, small area
partner_ids = Partner.search([
('partner_weight', '>', 0),
('partner_latitude', '>', latitude - 2),
('partner_latitude', '<', latitude + 2),
('partner_longitude', '>', longitude - 1.5),
('partner_longitude', '<', longitude + 1.5),
('country_id', '=', lead.country_id.id),
('id', 'not in', lead.partner_declined_ids.mapped('id')),
])
# 2. second way: in the same country, big area
if not partner_ids:
partner_ids = Partner.search([
('partner_weight', '>', 0),
('partner_latitude', '>', latitude - 4),
('partner_latitude', '<', latitude + 4),
('partner_longitude', '>', longitude - 3),
('partner_longitude', '<', longitude + 3),
('country_id', '=', lead.country_id.id),
('id', 'not in',
lead.partner_declined_ids.mapped('id')),
])
# 3. third way: in the same country, extra large area
if not partner_ids:
partner_ids = Partner.search([
('partner_weight', '>', 0),
('partner_latitude', '>', latitude - 8),
('partner_latitude', '<', latitude + 8),
('partner_longitude', '>', longitude - 8),
('partner_longitude', '<', longitude + 8),
('country_id', '=', lead.country_id.id),
('id', 'not in',
lead.partner_declined_ids.mapped('id')),
])
# 5. fifth way: anywhere in same country
if not partner_ids:
# still haven't found any, let's take all partners in the country!
partner_ids = Partner.search([
('partner_weight', '>', 0),
('country_id', '=', lead.country_id.id),
('id', 'not in',
lead.partner_declined_ids.mapped('id')),
])
# 6. sixth way: closest partner whatsoever, just to have at least one result
if not partner_ids:
# warning: point() type takes (longitude, latitude) as parameters in this order!
self._cr.execute(
"""SELECT id, distance
FROM (select id, (point(partner_longitude, partner_latitude) <-> point(%s,%s)) AS distance FROM res_partner
WHERE active
AND partner_longitude is not null
AND partner_latitude is not null
AND partner_weight > 0
AND id not in (select partner_id from crm_lead_declined_partner where lead_id = %s)
) AS d
ORDER BY distance LIMIT 1""",
(longitude, latitude, lead.id))
res = self._cr.dictfetchone()
if res:
partner_ids = Partner.browse([res['id']])
total_weight = 0
toassign = []
for partner in partner_ids:
total_weight += partner.partner_weight
toassign.append((partner.id, total_weight))
random.shuffle(
toassign
) # avoid always giving the leads to the first ones in db natural order!
nearest_weight = random.randint(0, total_weight)
for partner_id, weight in toassign:
if nearest_weight <= weight:
res_partner_ids[lead.id] = partner_id
break
return res_partner_ids
def partner_interested(self, comment=False):
message = _('<p>I am interested by this lead.</p>')
if comment:
message += '<p>%s</p>' % html_escape(comment)
for lead in self:
lead.message_post(body=message)
lead.sudo().convert_opportunity(
lead.partner_id.id) # sudo required to convert partner data
def partner_desinterested(self,
comment=False,
contacted=False,
spam=False):
if contacted:
message = '<p>%s</p>' % _(
'I am not interested by this lead. I contacted the lead.')
else:
message = '<p>%s</p>' % _(
'I am not interested by this lead. I have not contacted the lead.'
)
partner_ids = self.env['res.partner'].search([
('id', 'child_of',
self.env.user.partner_id.commercial_partner_id.id)
])
self.message_unsubscribe(partner_ids=partner_ids.ids)
if comment:
message += '<p>%s</p>' % html_escape(comment)
self.message_post(body=message)
values = {
'partner_assigned_id': False,
}
if spam:
tag_spam = self.env.ref(
'website_crm_partner_assign.tag_portal_lead_is_spam', False)
if tag_spam and tag_spam not in self.tag_ids:
values['tag_ids'] = [(4, tag_spam.id, False)]
if partner_ids:
values['partner_declined_ids'] = [(4, p, 0)
for p in partner_ids.ids]
self.sudo().write(values)
def update_lead_portal(self, values):
self.check_access_rights('write')
for lead in self:
lead_values = {
'planned_revenue': values['planned_revenue'],
'probability': values['probability'],
'priority': values['priority'],
'date_deadline': values['date_deadline'] or False,
}
# As activities may belong to several users, only the current portal user activity
# will be modified by the portal form. If no activity exist we create a new one instead
# that we assign to the portal user.
user_activity = lead.sudo().activity_ids.filtered(
lambda activity: activity.user_id == self.env.user)[:1]
if values['activity_date_deadline']:
if user_activity:
user_activity.sudo().write({
'activity_type_id':
values['activity_type_id'],
'summary':
values['activity_summary'],
'date_deadline':
values['activity_date_deadline'],
})
else:
self.env['mail.activity'].sudo().create({
'res_model_id':
self.env.ref('crm.model_crm_lead').id,
'res_id':
lead.id,
'user_id':
self.env.user.id,
'activity_type_id':
values['activity_type_id'],
'summary':
values['activity_summary'],
'date_deadline':
values['activity_date_deadline'],
})
lead.write(lead_values)
@api.model
def create_opp_portal(self, values):
if not (self.env.user.partner_id.grade_id
or self.env.user.commercial_partner_id.grade_id):
raise AccessDenied()
user = self.env.user
self = self.sudo()
if not (values['contact_name'] and values['description']
and values['title']):
return {'errors': _('All fields are required !')}
tag_own = self.env.ref(
'website_crm_partner_assign.tag_portal_lead_own_opp', False)
values = {
'contact_name': values['contact_name'],
'name': values['title'],
'description': values['description'],
'priority': '2',
'partner_assigned_id': user.commercial_partner_id.id,
}
if tag_own:
values['tag_ids'] = [(4, tag_own.id, False)]
lead = self.create(values)
lead.assign_salesman_of_assigned_partner()
lead.convert_opportunity(lead.partner_id.id)
return {'id': lead.id}
#
# DO NOT FORWARD PORT IN MASTER
# instead, crm.lead should implement portal.mixin
#
def get_access_action(self, access_uid=None):
""" Instead of the classic form view, redirect to the online document for
portal users or if force_website=True in the context. """
self.ensure_one()
user, record = self.env.user, self
if access_uid:
try:
record.check_access_rights('read')
record.check_access_rule("read")
except AccessError:
return super(CrmLead, self).get_access_action(access_uid)
user = self.env['res.users'].sudo().browse(access_uid)
record = self.with_user(user)
if user.share or self.env.context.get('force_website'):
try:
record.check_access_rights('read')
record.check_access_rule('read')
except AccessError:
pass
else:
return {
'type': 'ir.actions.act_url',
'url': '/my/opportunity/%s' % record.id,
}
return super(CrmLead, self).get_access_action(access_uid)
def test_onchange_product_id(self):
uom_id = self.product_uom_model.search([('name', '=', 'Units')])[0]
partner_id = self.res_partner_model.create(dict(name="George"))
tax_include_id = self.tax_model.create(
dict(name="Include tax",
amount='21.00',
price_include=True,
type_tax_use='purchase'))
tax_exclude_id = self.tax_model.create(
dict(name="Exclude tax", amount='0.00', type_tax_use='purchase'))
supplierinfo_vals = {
'name': partner_id.id,
'price': 121.0,
}
supplierinfo = self.supplierinfo_model.create(supplierinfo_vals)
product_tmpl_id = self.product_tmpl_model.create(
dict(name="Voiture",
list_price=121,
seller_ids=[(6, 0, [supplierinfo.id])],
supplier_taxes_id=[(6, 0, [tax_include_id.id])]))
product_id = product_tmpl_id.product_variant_id
fp_id = self.fiscal_position_model.create(
dict(name="fiscal position", sequence=1))
fp_tax_id = self.fiscal_position_tax_model.create(
dict(position_id=fp_id.id,
tax_src_id=tax_include_id.id,
tax_dest_id=tax_exclude_id.id))
po_vals = {
'partner_id':
partner_id.id,
'fiscal_position_id':
fp_id.id,
'order_line': [(0, 0, {
'name':
product_id.name,
'product_id':
product_id.id,
'product_qty':
1.0,
'product_uom':
uom_id.id,
'price_unit':
121.0,
'date_planned':
datetime.today().strftime(DEFAULT_SERVER_DATETIME_FORMAT),
})],
}
po = self.po_model.create(po_vals)
po_line = po.order_line[0]
po_line.onchange_product_id()
self.assertEquals(100, po_line.price_unit,
"The included tax must be subtracted to the price")
supplierinfo.write({'min_qty': 24})
po_line.write({'product_qty': 20})
po_line._onchange_quantity()
self.assertEquals(
0, po_line.price_unit,
"Unit price should be reset to 0 since the supplier supplies minimum of 24 quantities"
)
po_line.write({
'product_qty': 3,
'product_uom': self.ref("uom.product_uom_dozen")
})
po_line._onchange_quantity()
self.assertEquals(1200, po_line.price_unit,
"Unit price should be 1200 for one Dozen")
product_ipad = self.env.ref('product.product_product_4')
po_line2 = self.po_line_model.create({
'name':
product_ipad.name,
'product_id':
product_ipad.id,
'order_id':
po.id,
'product_qty':
5,
'product_uom':
uom_id.id,
'price_unit':
100.0,
'date_planned':
fields.Date().today()
})
po_line2.onchange_product_id()
self.assertEquals(
0, po_line2.price_unit,
"No vendor supplies this product, hence unit price should be set to 0"
)
class GroupOnDate(models.Model):
_name = 'test_read_group.on_date'
_description = 'Group Test Read On Date'
date = fields.Date("Date")
value = fields.Integer("Value")
class MembershipLine(models.Model):
_name = 'membership.membership_line'
_rec_name = 'partner'
_order = 'id desc'
_description = 'Membership Line'
partner = fields.Many2one('res.partner',
string='Partner',
ondelete='cascade',
index=True)
membership_id = fields.Many2one('product.product',
string="Membership",
required=True)
date_from = fields.Date(string='From', readonly=True)
date_to = fields.Date(string='To', readonly=True)
date_cancel = fields.Date(string='Cancel date')
date = fields.Date(string='Join Date',
help="Date on which member has joined the membership")
member_price = fields.Float(string='Membership Fee',
digits='Product Price',
required=True,
help='Amount for the membership')
account_invoice_line = fields.Many2one('account.move.line',
string='Account Invoice line',
readonly=True,
ondelete='cascade')
account_invoice_id = fields.Many2one(
'account.move',
related='account_invoice_line.move_id',
string='Invoice',
readonly=True)
company_id = fields.Many2one(
'res.company',
related='account_invoice_line.move_id.company_id',
string="Company",
readonly=True,
store=True)
state = fields.Selection(
STATE,
compute='_compute_state',
string='Membership Status',
store=True,
help="It indicates the membership status.\n"
"-Non Member: A member who has not applied for any membership.\n"
"-Cancelled Member: A member who has cancelled his membership.\n"
"-Old Member: A member whose membership date has expired.\n"
"-Waiting Member: A member who has applied for the membership and whose invoice is going to be created.\n"
"-Invoiced Member: A member whose invoice has been created.\n"
"-Paid Member: A member who has paid the membership amount.")
@api.depends('account_invoice_id.state',
'account_invoice_id.amount_residual',
'account_invoice_id.invoice_payment_state')
def _compute_state(self):
"""Compute the state lines """
if not self:
return
self._cr.execute(
'''
SELECT reversed_entry_id, COUNT(id)
FROM account_move
WHERE reversed_entry_id IN %s
GROUP BY reversed_entry_id
''', [tuple(self.mapped('account_invoice_id.id'))])
reverse_map = dict(self._cr.fetchall())
for line in self:
move_state = line.account_invoice_id.state
payment_state = line.account_invoice_id.invoice_payment_state
line.state = 'none'
if move_state == 'draft':
line.state = 'waiting'
elif move_state == 'posted':
if payment_state == 'paid':
if reverse_map.get(line.account_invoice_id.id):
line.state = 'canceled'
else:
line.state = 'paid'
elif payment_state == 'in_payment':
line.state = 'paid'
elif payment_state == 'not_paid':
line.state = 'invoiced'
elif move_state == 'cancel':
line.state = 'canceled'
class SurveyQuestion(models.Model):
""" Questions that will be asked in a survey.
Each question can have one of more suggested answers (eg. in case of
dropdown choices, multi-answer checkboxes, radio buttons...).
Technical note:
survey.question is also the model used for the survey's pages (with the "is_page" field set to True).
A page corresponds to a "section" in the interface, and the fact that it separates the survey in
actual pages in the interface depends on the "questions_layout" parameter on the survey.survey model.
Pages are also used when randomizing questions. The randomization can happen within a "page".
Using the same model for questions and pages allows to put all the pages and questions together in a o2m field
(see survey.survey.question_and_page_ids) on the view side and easily reorganize your survey by dragging the
items around.
It also removes on level of encoding by directly having 'Add a page' and 'Add a question'
links on the tree view of questions, enabling a faster encoding.
However, this has the downside of making the code reading a little bit more complicated.
Efforts were made at the model level to create computed fields so that the use of these models
still seems somewhat logical. That means:
- A survey still has "page_ids" (question_and_page_ids filtered on is_page = True)
- These "page_ids" still have question_ids (questions located between this page and the next)
- These "question_ids" still have a "page_id"
That makes the use and display of these information at view and controller levels easier to understand.
"""
_name = 'survey.question'
_description = 'Survey Question'
_rec_name = 'question'
_order = 'sequence,id'
@api.model
def default_get(self, fields):
defaults = super(SurveyQuestion, self).default_get(fields)
if (not fields or 'question_type' in fields):
defaults['question_type'] = False if defaults.get(
'is_page') == True else 'free_text'
return defaults
# Question metadata
survey_id = fields.Many2one('survey.survey',
string='Survey',
ondelete='cascade')
page_id = fields.Many2one('survey.question',
string='Page',
compute="_compute_page_id",
store=True)
question_ids = fields.One2many('survey.question',
string='Questions',
compute="_compute_question_ids")
scoring_type = fields.Selection(related='survey_id.scoring_type',
string='Scoring Type',
readonly=True)
sequence = fields.Integer('Sequence', default=10)
# Question
is_page = fields.Boolean('Is a page?')
questions_selection = fields.Selection(
related='survey_id.questions_selection',
readonly=True,
help=
"If randomized is selected, add the number of random questions next to the section."
)
random_questions_count = fields.Integer(
'Random questions count',
default=1,
help=
"Used on randomized sections to take X random questions from all the questions of that section."
)
title = fields.Char('Title', required=True, translate=True)
question = fields.Char('Question', related="title")
description = fields.Html(
'Description',
help=
"Use this field to add additional explanations about your question",
translate=True)
question_type = fields.Selection(
[('free_text', 'Multiple Lines Text Box'),
('textbox', 'Single Line Text Box'),
('numerical_box', 'Numerical Value'), ('date', 'Date'),
('datetime', 'Datetime'),
('simple_choice', 'Multiple choice: only one answer'),
('multiple_choice', 'Multiple choice: multiple answers allowed'),
('matrix', 'Matrix')],
string='Question Type')
# simple choice / multiple choice / matrix
labels_ids = fields.One2many(
'survey.label',
'question_id',
string='Types of answers',
copy=True,
help=
'Labels used for proposed choices: simple choice, multiple choice and columns of matrix'
)
# matrix
matrix_subtype = fields.Selection(
[('simple', 'One choice per row'),
('multiple', 'Multiple choices per row')],
string='Matrix Type',
default='simple')
labels_ids_2 = fields.One2many(
'survey.label',
'question_id_2',
string='Rows of the Matrix',
copy=True,
help='Labels used for proposed choices: rows of matrix')
# Display options
column_nb = fields.Selection(
[('12', '1'), ('6', '2'), ('4', '3'), ('3', '4'), ('2', '6')],
string='Number of columns',
default='12',
help=
'These options refer to col-xx-[12|6|4|3|2] classes in Bootstrap for dropdown-based simple and multiple choice questions.'
)
display_mode = fields.Selection(
[('columns', 'Radio Buttons'), ('dropdown', 'Selection Box')],
string='Display Mode',
default='columns',
help='Display mode of simple choice questions.')
# Comments
comments_allowed = fields.Boolean('Show Comments Field')
comments_message = fields.Char(
'Comment Message',
translate=True,
default=lambda self: _("If other, please specify:"))
comment_count_as_answer = fields.Boolean(
'Comment Field is an Answer Choice')
# Validation
validation_required = fields.Boolean('Validate entry')
validation_email = fields.Boolean('Input must be an email')
validation_length_min = fields.Integer('Minimum Text Length')
validation_length_max = fields.Integer('Maximum Text Length')
validation_min_float_value = fields.Float('Minimum value')
validation_max_float_value = fields.Float('Maximum value')
validation_min_date = fields.Date('Minimum Date')
validation_max_date = fields.Date('Maximum Date')
validation_min_datetime = fields.Datetime('Minimum Datetime')
validation_max_datetime = fields.Datetime('Maximum Datetime')
validation_error_msg = fields.Char(
'Validation Error message',
translate=True,
default=lambda self: _("The answer you entered is not valid."))
# Constraints on number of answers (matrices)
constr_mandatory = fields.Boolean('Mandatory Answer')
constr_error_msg = fields.Char(
'Error message',
translate=True,
default=lambda self: _("This question requires an answer."))
# Answer
user_input_line_ids = fields.One2many('survey.user_input_line',
'question_id',
string='Answers',
domain=[('skipped', '=', False)],
groups='survey.group_survey_user')
_sql_constraints = [
('positive_len_min', 'CHECK (validation_length_min >= 0)',
'A length must be positive!'),
('positive_len_max', 'CHECK (validation_length_max >= 0)',
'A length must be positive!'),
('validation_length',
'CHECK (validation_length_min <= validation_length_max)',
'Max length cannot be smaller than min length!'),
('validation_float',
'CHECK (validation_min_float_value <= validation_max_float_value)',
'Max value cannot be smaller than min value!'),
('validation_date',
'CHECK (validation_min_date <= validation_max_date)',
'Max date cannot be smaller than min date!'),
('validation_datetime',
'CHECK (validation_min_datetime <= validation_max_datetime)',
'Max datetime cannot be smaller than min datetime!')
]
@api.onchange('validation_email')
def _onchange_validation_email(self):
if self.validation_email:
self.validation_required = False
@api.onchange('is_page')
def _onchange_is_page(self):
if self.is_page:
self.question_type = False
# Validation methods
def validate_question(self, post, answer_tag):
""" Validate question, depending on question type and parameters """
self.ensure_one()
try:
checker = getattr(self, 'validate_' + self.question_type)
except AttributeError:
_logger.warning(self.question_type +
": This type of question has no validation method")
return {}
else:
return checker(post, answer_tag)
def validate_free_text(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_textbox(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Email format validation
# Note: this validation is very basic:
# all the strings of the form
# <something>@<anything>.<extension>
# will be accepted
if answer and self.validation_email:
if not email_validator.match(answer):
errors.update(
{answer_tag: _('This answer must be an email address')})
# Answer validation (if properly defined)
# Length of the answer must be in a range
if answer and self.validation_required:
if not (self.validation_length_min <= len(answer) <=
self.validation_length_max):
errors.update({answer_tag: self.validation_error_msg})
return errors
def validate_numerical_box(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Checks if user input is a number
if answer:
try:
floatanswer = float(answer)
except ValueError:
errors.update({answer_tag: _('This is not a number')})
# Answer validation (if properly defined)
if answer and self.validation_required:
# Answer is not in the right range
with tools.ignore(Exception):
floatanswer = float(
answer) # check that it is a float has been done hereunder
if not (self.validation_min_float_value <= floatanswer <=
self.validation_max_float_value):
errors.update({answer_tag: self.validation_error_msg})
return errors
def date_validation(self, date_type, post, answer_tag, min_value,
max_value):
self.ensure_one()
errors = {}
if date_type not in ('date', 'datetime'):
raise ValueError("Unexpected date type value")
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Checks if user input is a date
if answer:
try:
if date_type == 'datetime':
dateanswer = fields.Datetime.from_string(answer)
else:
dateanswer = fields.Date.from_string(answer)
except ValueError:
errors.update({answer_tag: _('This is not a date')})
return errors
# Answer validation (if properly defined)
if answer and self.validation_required:
# Answer is not in the right range
try:
if date_type == 'datetime':
date_from_string = fields.Datetime.from_string
else:
date_from_string = fields.Date.from_string
dateanswer = date_from_string(answer)
min_date = date_from_string(min_value)
max_date = date_from_string(max_value)
if min_date and max_date and not (min_date <= dateanswer <=
max_date):
# If Minimum and Maximum Date are entered
errors.update({answer_tag: self.validation_error_msg})
elif min_date and not min_date <= dateanswer:
# If only Minimum Date is entered and not Define Maximum Date
errors.update({answer_tag: self.validation_error_msg})
elif max_date and not dateanswer <= max_date:
# If only Maximum Date is entered and not Define Minimum Date
errors.update({answer_tag: self.validation_error_msg})
except ValueError: # check that it is a date has been done hereunder
pass
return errors
def validate_date(self, post, answer_tag):
return self.date_validation('date', post, answer_tag,
self.validation_min_date,
self.validation_max_date)
def validate_datetime(self, post, answer_tag):
return self.date_validation('datetime', post, answer_tag,
self.validation_min_datetime,
self.validation_max_datetime)
def validate_simple_choice(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.comments_allowed:
comment_tag = "%s_%s" % (answer_tag, 'comment')
# Empty answer to mandatory self
if self.constr_mandatory and answer_tag not in post:
errors.update({answer_tag: self.constr_error_msg})
if self.constr_mandatory and answer_tag in post and not post[
answer_tag].strip():
errors.update({answer_tag: self.constr_error_msg})
# Answer is a comment and is empty
if self.constr_mandatory and answer_tag in post and post[
answer_tag] == "-1" and self.comment_count_as_answer and comment_tag in post and not post[
comment_tag].strip():
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_multiple_choice(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.constr_mandatory:
answer_candidates = dict_keys_startswith(post, answer_tag)
comment_flag = answer_candidates.pop(("%s_%s" % (answer_tag, -1)),
None)
if self.comments_allowed:
comment_answer = answer_candidates.pop(
("%s_%s" % (answer_tag, 'comment')), '').strip()
# Preventing answers with blank value
if all(not answer.strip() for answer in
answer_candidates.values()) and answer_candidates:
errors.update({answer_tag: self.constr_error_msg})
# There is no answer neither comments (if comments count as answer)
if not answer_candidates and self.comment_count_as_answer and (
not comment_flag or not comment_answer):
errors.update({answer_tag: self.constr_error_msg})
# There is no answer at all
if not answer_candidates and not self.comment_count_as_answer:
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_matrix(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.constr_mandatory:
lines_number = len(self.labels_ids_2)
answer_candidates = dict_keys_startswith(post, answer_tag)
answer_candidates.pop(("%s_%s" % (answer_tag, 'comment')),
'').strip()
# Number of lines that have been answered
if self.matrix_subtype == 'simple':
answer_number = len(answer_candidates)
elif self.matrix_subtype == 'multiple':
answer_number = len(
{sk.rsplit('_', 1)[0]
for sk in answer_candidates})
else:
raise RuntimeError("Invalid matrix subtype")
# Validate that each line has been answered
if answer_number != lines_number:
errors.update({answer_tag: self.constr_error_msg})
return errors
@api.depends('survey_id.question_and_page_ids.is_page',
'survey_id.question_and_page_ids.sequence')
def _compute_question_ids(self):
"""Will take all questions of the survey for which the index is higher than the index of this page
and lower than the index of the next page."""
for question in self:
if question.is_page:
next_page_index = False
for page in question.survey_id.page_ids:
if page._index() > question._index():
next_page_index = page._index()
break
question.question_ids = question.survey_id.question_ids.filtered(
lambda q: q._index() > question._index() and
(not next_page_index or q._index() < next_page_index))
else:
question.question_ids = self.env['survey.question']
@api.depends('survey_id.question_and_page_ids.is_page',
'survey_id.question_and_page_ids.sequence')
def _compute_page_id(self):
"""Will find the page to which this question belongs to by looking inside the corresponding survey"""
for question in self:
if question.is_page:
question.page_id = None
else:
page = None
for q in question.survey_id.question_and_page_ids.sorted():
if q == question:
break
if q.is_page:
page = q
question.page_id = page
def _index(self):
"""We would normally just use the 'sequence' field of questions BUT, if the pages and questions are
created without ever moving records around, the sequence field can be set to 0 for all the questions.
However, the order of the recordset is always correct so we can rely on the index method."""
self.ensure_one()
return list(self.survey_id.question_and_page_ids).index(self)
def get_correct_answer_ids(self):
self.ensure_one()
return self.labels_ids.filtered(lambda label: label.is_correct)
class SurveyUserInputLine(models.Model):
_name = 'survey.user_input_line'
_description = 'Survey User Input Line'
_rec_name = 'user_input_id'
_order = 'question_sequence,id'
# survey data
user_input_id = fields.Many2one('survey.user_input',
string='User Input',
ondelete='cascade',
required=True)
survey_id = fields.Many2one(related='user_input_id.survey_id',
string='Survey',
store=True,
readonly=False)
question_id = fields.Many2one('survey.question',
string='Question',
ondelete='cascade',
required=True)
page_id = fields.Many2one(related='question_id.page_id',
string="Section",
readonly=False)
question_sequence = fields.Integer('Sequence',
related='question_id.sequence',
store=True)
# answer
skipped = fields.Boolean('Skipped')
answer_type = fields.Selection([('text', 'Text'), ('number', 'Number'),
('date', 'Date'), ('datetime', 'Datetime'),
('free_text', 'Free Text'),
('suggestion', 'Suggestion')],
string='Answer Type')
value_text = fields.Char('Text answer')
value_number = fields.Float('Numerical answer')
value_date = fields.Date('Date answer')
value_datetime = fields.Datetime('Datetime answer')
value_free_text = fields.Text('Free Text answer')
value_suggested = fields.Many2one('survey.label',
string="Suggested answer")
value_suggested_row = fields.Many2one('survey.label', string="Row answer")
answer_score = fields.Float('Score')
answer_is_correct = fields.Boolean('Correct',
compute='_compute_answer_is_correct')
@api.depends('value_suggested', 'question_id')
def _compute_answer_is_correct(self):
for answer in self:
if answer.value_suggested and answer.question_id.question_type in [
'simple_choice', 'multiple_choice'
]:
answer.answer_is_correct = answer.value_suggested.is_correct
else:
answer.answer_is_correct = False
@api.constrains('skipped', 'answer_type')
def _answered_or_skipped(self):
for uil in self:
if not uil.skipped != bool(uil.answer_type):
raise ValidationError(
_('This question cannot be unanswered or skipped.'))
@api.constrains('answer_type')
def _check_answer_type(self):
for uil in self:
fields_type = {
'text': bool(uil.value_text),
'number': (bool(uil.value_number) or uil.value_number == 0),
'date': bool(uil.value_date),
'free_text': bool(uil.value_free_text),
'suggestion': bool(uil.value_suggested)
}
if not fields_type.get(uil.answer_type, True):
raise ValidationError(
_('The answer must be in the right type'))
@api.model_create_multi
def create(self, vals_list):
for vals in vals_list:
value_suggested = vals.get('value_suggested')
if value_suggested:
vals.update({
'answer_score':
self.env['survey.label'].browse(
int(value_suggested)).answer_score
})
return super(SurveyUserInputLine, self).create(vals_list)
def write(self, vals):
value_suggested = vals.get('value_suggested')
if value_suggested:
vals.update({
'answer_score':
self.env['survey.label'].browse(
int(value_suggested)).answer_score
})
return super(SurveyUserInputLine, self).write(vals)
@api.model
def save_lines(self, user_input_id, question, post, answer_tag):
""" Save answers to questions, depending on question type
If an answer already exists for question and user_input_id, it will be
overwritten (in order to maintain data consistency).
"""
try:
saver = getattr(self, 'save_line_' + question.question_type)
except AttributeError:
_logger.error(question.question_type +
": This type of question has no saving function")
return False
else:
saver(user_input_id, question, post, answer_tag)
@api.model
def save_line_free_text(self, user_input_id, question, post, answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False,
}
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'free_text',
'value_free_text': post[answer_tag]
})
else:
vals.update({'answer_type': None, 'skipped': True})
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
if old_uil:
old_uil.write(vals)
else:
old_uil.create(vals)
return True
@api.model
def save_line_textbox(self, user_input_id, question, post, answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'text',
'value_text': post[answer_tag]
})
else:
vals.update({'answer_type': None, 'skipped': True})
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
if old_uil:
old_uil.write(vals)
else:
old_uil.create(vals)
return True
@api.model
def save_line_numerical_box(self, user_input_id, question, post,
answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'number',
'value_number': float(post[answer_tag])
})
else:
vals.update({'answer_type': None, 'skipped': True})
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
if old_uil:
old_uil.write(vals)
else:
old_uil.create(vals)
return True
@api.model
def save_line_date(self, user_input_id, question, post, answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'date',
'value_date': post[answer_tag]
})
else:
vals.update({'answer_type': None, 'skipped': True})
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
if old_uil:
old_uil.write(vals)
else:
old_uil.create(vals)
return True
@api.model
def save_line_datetime(self, user_input_id, question, post, answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'datetime',
'value_datetime': post[answer_tag]
})
else:
vals.update({'answer_type': None, 'skipped': True})
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
if old_uil:
old_uil.write(vals)
else:
old_uil.create(vals)
return True
@api.model
def save_line_simple_choice(self, user_input_id, question, post,
answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
old_uil.sudo().unlink()
if answer_tag in post and post[answer_tag].strip():
vals.update({
'answer_type': 'suggestion',
'value_suggested': int(post[answer_tag])
})
else:
vals.update({'answer_type': None, 'skipped': True})
# '-1' indicates 'comment count as an answer' so do not need to record it
if post.get(answer_tag) and post.get(answer_tag) != '-1':
self.create(vals)
comment_answer = post.pop(("%s_%s" % (answer_tag, 'comment')),
'').strip()
if comment_answer:
vals.update({
'answer_type': 'text',
'value_text': comment_answer,
'skipped': False,
'value_suggested': False
})
self.create(vals)
return True
@api.model
def save_line_multiple_choice(self, user_input_id, question, post,
answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
old_uil.sudo().unlink()
ca_dict = dict_keys_startswith(post, answer_tag + '_')
comment_answer = ca_dict.pop(("%s_%s" % (answer_tag, 'comment')),
'').strip()
if len(ca_dict) > 0:
for key in ca_dict:
# '-1' indicates 'comment count as an answer' so do not need to record it
if key != ('%s_%s' % (answer_tag, '-1')):
val = ca_dict[key]
vals.update({
'answer_type': 'suggestion',
'value_suggested': bool(val) and int(val)
})
self.create(vals)
if comment_answer:
vals.update({
'answer_type': 'text',
'value_text': comment_answer,
'value_suggested': False
})
self.create(vals)
if not ca_dict and not comment_answer:
vals.update({'answer_type': None, 'skipped': True})
self.create(vals)
return True
@api.model
def save_line_matrix(self, user_input_id, question, post, answer_tag):
vals = {
'user_input_id': user_input_id,
'question_id': question.id,
'survey_id': question.survey_id.id,
'skipped': False
}
old_uil = self.search([('user_input_id', '=', user_input_id),
('survey_id', '=', question.survey_id.id),
('question_id', '=', question.id)])
old_uil.sudo().unlink()
no_answers = True
ca_dict = dict_keys_startswith(post, answer_tag + '_')
comment_answer = ca_dict.pop(("%s_%s" % (answer_tag, 'comment')),
'').strip()
if comment_answer:
vals.update({'answer_type': 'text', 'value_text': comment_answer})
self.create(vals)
no_answers = False
if question.matrix_subtype == 'simple':
for row in question.labels_ids_2:
a_tag = "%s_%s" % (answer_tag, row.id)
if a_tag in ca_dict:
no_answers = False
vals.update({
'answer_type': 'suggestion',
'value_suggested': ca_dict[a_tag],
'value_suggested_row': row.id
})
self.create(vals)
elif question.matrix_subtype == 'multiple':
for col in question.labels_ids:
for row in question.labels_ids_2:
a_tag = "%s_%s_%s" % (answer_tag, row.id, col.id)
if a_tag in ca_dict:
no_answers = False
vals.update({
'answer_type': 'suggestion',
'value_suggested': col.id,
'value_suggested_row': row.id
})
self.create(vals)
if no_answers:
vals.update({'answer_type': None, 'skipped': True})
self.create(vals)
return True
class MaintenanceEquipment(models.Model):
_name = 'maintenance.equipment'
_inherit = ['mail.thread', 'mail.activity.mixin']
_description = 'Maintenance Equipment'
_check_company_auto = True
def _track_subtype(self, init_values):
self.ensure_one()
if 'owner_user_id' in init_values and self.owner_user_id:
return self.env.ref('maintenance.mt_mat_assign')
return super(MaintenanceEquipment, self)._track_subtype(init_values)
def name_get(self):
result = []
for record in self:
if record.name and record.serial_no:
result.append(
(record.id, record.name + '/' + record.serial_no))
if record.name and not record.serial_no:
result.append((record.id, record.name))
return result
@api.model
def _name_search(self,
name,
args=None,
operator='ilike',
limit=100,
name_get_uid=None):
args = args or []
equipment_ids = []
if name:
equipment_ids = self._search([('name', '=', name)] + args,
limit=limit,
access_rights_uid=name_get_uid)
if not equipment_ids:
equipment_ids = self._search([('name', operator, name)] + args,
limit=limit,
access_rights_uid=name_get_uid)
return models.lazy_name_get(
self.browse(equipment_ids).with_user(name_get_uid))
name = fields.Char('Equipment Name', required=True, translate=True)
company_id = fields.Many2one('res.company',
string='Company',
default=lambda self: self.env.company)
active = fields.Boolean(default=True)
technician_user_id = fields.Many2one('res.users',
string='Technician',
tracking=True)
owner_user_id = fields.Many2one('res.users', string='Owner', tracking=True)
category_id = fields.Many2one('maintenance.equipment.category',
string='Equipment Category',
tracking=True,
group_expand='_read_group_category_ids')
partner_id = fields.Many2one('res.partner',
string='Vendor',
check_company=True)
partner_ref = fields.Char('Vendor Reference')
location = fields.Char('Location')
model = fields.Char('Model')
serial_no = fields.Char('Serial Number', copy=False)
assign_date = fields.Date('Assigned Date', tracking=True)
effective_date = fields.Date(
'Effective Date',
default=fields.Date.context_today,
required=True,
help=
"Date at which the equipment became effective. This date will be used to compute the Mean Time Between Failure."
)
cost = fields.Float('Cost')
note = fields.Text('Note')
warranty_date = fields.Date('Warranty Expiration Date')
color = fields.Integer('Color Index')
scrap_date = fields.Date('Scrap Date')
maintenance_ids = fields.One2many('maintenance.request', 'equipment_id')
maintenance_count = fields.Integer(compute='_compute_maintenance_count',
string="Maintenance Count",
store=True)
maintenance_open_count = fields.Integer(
compute='_compute_maintenance_count',
string="Current Maintenance",
store=True)
period = fields.Integer('Days between each preventive maintenance')
next_action_date = fields.Date(
compute='_compute_next_maintenance',
string='Date of the next preventive maintenance',
store=True)
maintenance_team_id = fields.Many2one('maintenance.team',
string='Maintenance Team',
check_company=True)
maintenance_duration = fields.Float(help="Maintenance Duration in hours.")
@api.depends('effective_date', 'period', 'maintenance_ids.request_date',
'maintenance_ids.close_date')
def _compute_next_maintenance(self):
date_now = fields.Date.context_today(self)
equipments = self.filtered(lambda x: x.period > 0)
for equipment in equipments:
next_maintenance_todo = self.env['maintenance.request'].search(
[('equipment_id', '=', equipment.id),
('maintenance_type', '=', 'preventive'),
('stage_id.done', '!=', True), ('close_date', '=', False)],
order="request_date asc",
limit=1)
last_maintenance_done = self.env['maintenance.request'].search(
[('equipment_id', '=', equipment.id),
('maintenance_type', '=', 'preventive'),
('stage_id.done', '=', True), ('close_date', '!=', False)],
order="close_date desc",
limit=1)
if next_maintenance_todo and last_maintenance_done:
next_date = next_maintenance_todo.request_date
date_gap = next_maintenance_todo.request_date - last_maintenance_done.close_date
# If the gap between the last_maintenance_done and the next_maintenance_todo one is bigger than 2 times the period and next request is in the future
# We use 2 times the period to avoid creation too closed request from a manually one created
if date_gap > timedelta(0) and date_gap > timedelta(
days=equipment.period
) * 2 and next_maintenance_todo.request_date > date_now:
# If the new date still in the past, we set it for today
if last_maintenance_done.close_date + timedelta(
days=equipment.period) < date_now:
next_date = date_now
else:
next_date = last_maintenance_done.close_date + timedelta(
days=equipment.period)
elif next_maintenance_todo:
next_date = next_maintenance_todo.request_date
date_gap = next_maintenance_todo.request_date - date_now
# If next maintenance to do is in the future, and in more than 2 times the period, we insert an new request
# We use 2 times the period to avoid creation too closed request from a manually one created
if date_gap > timedelta(0) and date_gap > timedelta(
days=equipment.period) * 2:
next_date = date_now + timedelta(days=equipment.period)
elif last_maintenance_done:
next_date = last_maintenance_done.close_date + timedelta(
days=equipment.period)
# If when we add the period to the last maintenance done and we still in past, we plan it for today
if next_date < date_now:
next_date = date_now
else:
next_date = equipment.effective_date + timedelta(
days=equipment.period)
equipment.next_action_date = next_date
(self - equipments).next_action_date = False
@api.depends('maintenance_ids.stage_id.done')
def _compute_maintenance_count(self):
for equipment in self:
equipment.maintenance_count = len(equipment.maintenance_ids)
equipment.maintenance_open_count = len(
equipment.maintenance_ids.filtered(
lambda x: not x.stage_id.done))
@api.onchange('company_id')
def _onchange_company_id(self):
if self.company_id and self.maintenance_team_id:
if self.maintenance_team_id.company_id and not self.maintenance_team_id.company_id.id == self.company_id.id:
self.maintenance_team_id = False
@api.onchange('category_id')
def _onchange_category_id(self):
self.technician_user_id = self.category_id.technician_user_id
_sql_constraints = [
('serial_no', 'unique(serial_no)',
"Another asset already exists with this serial number!"),
]
@api.model
def create(self, vals):
equipment = super(MaintenanceEquipment, self).create(vals)
if equipment.owner_user_id:
equipment.message_subscribe(
partner_ids=[equipment.owner_user_id.partner_id.id])
return equipment
def write(self, vals):
if vals.get('owner_user_id'):
self.message_subscribe(partner_ids=self.env['res.users'].browse(
vals['owner_user_id']).partner_id.ids)
return super(MaintenanceEquipment, self).write(vals)
@api.model
def _read_group_category_ids(self, categories, domain, order):
""" Read group customization in order to display all the categories in
the kanban view, even if they are empty.
"""
category_ids = categories._search([],
order=order,
access_rights_uid=SUPERUSER_ID)
return categories.browse(category_ids)
def _create_new_request(self, date):
self.ensure_one()
self.env['maintenance.request'].create({
'name':
_('Preventive Maintenance - %s') % self.name,
'request_date':
date,
'schedule_date':
date,
'category_id':
self.category_id.id,
'equipment_id':
self.id,
'maintenance_type':
'preventive',
'owner_user_id':
self.owner_user_id.id,
'user_id':
self.technician_user_id.id,
'maintenance_team_id':
self.maintenance_team_id.id,
'duration':
self.maintenance_duration,
'company_id':
self.company_id.id or self.env.company.id
})
@api.model
def _cron_generate_requests(self):
"""
Generates maintenance request on the next_action_date or today if none exists
"""
for equipment in self.search([('period', '>', 0)]):
next_requests = self.env['maintenance.request'].search([
('stage_id.done', '=', False),
('equipment_id', '=', equipment.id),
('maintenance_type', '=', 'preventive'),
('request_date', '=', equipment.next_action_date)
])
if not next_requests:
equipment._create_new_request(equipment.next_action_date)
class AccountAnalyticDefault(models.Model):
_name = "account.analytic.default"
_description = "Analytic Distribution"
_rec_name = "analytic_id"
_order = "sequence"
sequence = fields.Integer(
string='Sequence',
help=
"Gives the sequence order when displaying a list of analytic distribution"
)
analytic_id = fields.Many2one('account.analytic.account',
string='Analytic Account')
analytic_tag_ids = fields.Many2many('account.analytic.tag',
string='Analytic Tags')
product_id = fields.Many2one(
'product.product',
string='Product',
ondelete='cascade',
help=
"Select a product which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this product, it will automatically take this as an analytic account)"
)
partner_id = fields.Many2one(
'res.partner',
string='Partner',
ondelete='cascade',
help=
"Select a partner which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this partner, it will automatically take this as an analytic account)"
)
account_id = fields.Many2one(
'account.account',
string='Account',
ondelete='cascade',
help=
"Select an accounting account which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this account, it will automatically take this as an analytic account)"
)
user_id = fields.Many2one(
'res.users',
string='User',
ondelete='cascade',
help=
"Select a user which will use analytic account specified in analytic default."
)
company_id = fields.Many2one(
'res.company',
string='Company',
ondelete='cascade',
help=
"Select a company which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this company, it will automatically take this as an analytic account)"
)
date_start = fields.Date(
string='Start Date',
help="Default start date for this Analytic Account.")
date_stop = fields.Date(string='End Date',
help="Default end date for this Analytic Account.")
@api.constrains('analytic_id', 'analytic_tag_ids')
def _check_account_or_tags(self):
if any(not default.analytic_id and not default.analytic_tag_ids
for default in self):
raise ValidationError(
_('An analytic default requires at least an analytic account or an analytic tag.'
))
@api.model
def account_get(self,
product_id=None,
partner_id=None,
account_id=None,
user_id=None,
date=None,
company_id=None):
domain = []
if product_id:
domain += ['|', ('product_id', '=', product_id)]
domain += [('product_id', '=', False)]
if partner_id:
domain += ['|', ('partner_id', '=', partner_id)]
domain += [('partner_id', '=', False)]
if account_id:
domain += ['|', ('account_id', '=', account_id)]
domain += [('account_id', '=', False)]
if company_id:
domain += ['|', ('company_id', '=', company_id)]
domain += [('company_id', '=', False)]
if user_id:
domain += ['|', ('user_id', '=', user_id)]
domain += [('user_id', '=', False)]
if date:
domain += [
'|', ('date_start', '<=', date), ('date_start', '=', False)
]
domain += [
'|', ('date_stop', '>=', date), ('date_stop', '=', False)
]
best_index = -1
res = self.env['account.analytic.default']
for rec in self.search(domain):
index = 0
if rec.product_id: index += 1
if rec.partner_id: index += 1
if rec.account_id: index += 1
if rec.company_id: index += 1
if rec.user_id: index += 1
if rec.date_start: index += 1
if rec.date_stop: index += 1
if index > best_index:
res = rec
best_index = index
return res
class SupplierInfo(models.Model):
_name = "product.supplierinfo"
_description = "Supplier Pricelist"
_order = 'sequence, min_qty desc, price'
name = fields.Many2one('res.partner',
'Vendor',
ondelete='cascade',
required=True,
help="Vendor of this product",
check_company=True)
product_name = fields.Char(
'Vendor Product Name',
help=
"This vendor's product name will be used when printing a request for quotation. Keep empty to use the internal one."
)
product_code = fields.Char(
'Vendor Product Code',
help=
"This vendor's product code will be used when printing a request for quotation. Keep empty to use the internal one."
)
sequence = fields.Integer(
'Sequence',
default=1,
help="Assigns the priority to the list of product vendor.")
product_uom = fields.Many2one('uom.uom',
'Unit of Measure',
related='product_tmpl_id.uom_po_id',
help="This comes from the product form.")
min_qty = fields.Float(
'Quantity',
default=0.0,
required=True,
help=
"The quantity to purchase from this vendor to benefit from the price, expressed in the vendor Product Unit of Measure if not any, in the default unit of measure of the product otherwise."
)
price = fields.Float('Price',
default=0.0,
digits='Product Price',
required=True,
help="The price to purchase a product")
company_id = fields.Many2one('res.company',
'Company',
default=lambda self: self.env.company.id,
index=1)
currency_id = fields.Many2one(
'res.currency',
'Currency',
default=lambda self: self.env.company.currency_id.id,
required=True)
date_start = fields.Date('Start Date',
help="Start date for this vendor price")
date_end = fields.Date('End Date', help="End date for this vendor price")
product_id = fields.Many2one(
'product.product',
'Product Variant',
check_company=True,
help=
"If not set, the vendor price will apply to all variants of this product."
)
product_tmpl_id = fields.Many2one('product.template',
'Product Template',
check_company=True,
index=True,
ondelete='cascade')
product_variant_count = fields.Integer(
'Variant Count',
related='product_tmpl_id.product_variant_count',
readonly=False)
delay = fields.Integer(
'Delivery Lead Time',
default=1,
required=True,
help=
"Lead time in days between the confirmation of the purchase order and the receipt of the products in your warehouse. Used by the scheduler for automatic computation of the purchase order planning."
)
@api.model
def get_import_templates(self):
return [{
'label': _('Import Template for Vendor Pricelists'),
'template': '/product/static/xls/product_supplierinfo.xls'
}]
class MaintenanceRequest(models.Model):
_name = 'maintenance.request'
_inherit = ['mail.thread.cc', 'mail.activity.mixin']
_description = 'Maintenance Request'
_order = "id desc"
_check_company_auto = True
@api.returns('self')
def _default_stage(self):
return self.env['maintenance.stage'].search([], limit=1)
def _creation_subtype(self):
return self.env.ref('maintenance.mt_req_created')
def _track_subtype(self, init_values):
self.ensure_one()
if 'stage_id' in init_values:
return self.env.ref('maintenance.mt_req_status')
return super(MaintenanceRequest, self)._track_subtype(init_values)
def _get_default_team_id(self):
MT = self.env['maintenance.team']
team = MT.search([('company_id', '=', self.env.company.id)], limit=1)
if not team:
team = MT.search([], limit=1)
return team.id
name = fields.Char('Subjects', required=True)
company_id = fields.Many2one('res.company',
string='Company',
default=lambda self: self.env.company)
description = fields.Text('Description')
request_date = fields.Date(
'Request Date',
tracking=True,
default=fields.Date.context_today,
help="Date requested for the maintenance to happen")
owner_user_id = fields.Many2one('res.users',
string='Created by User',
default=lambda s: s.env.uid)
category_id = fields.Many2one('maintenance.equipment.category',
related='equipment_id.category_id',
string='Category',
store=True,
readonly=True)
equipment_id = fields.Many2one('maintenance.equipment',
string='Equipment',
ondelete='restrict',
index=True,
check_company=True)
user_id = fields.Many2one('res.users', string='Technician', tracking=True)
stage_id = fields.Many2one('maintenance.stage',
string='Stage',
ondelete='restrict',
tracking=True,
group_expand='_read_group_stage_ids',
default=_default_stage,
copy=False)
priority = fields.Selection([('0', 'Very Low'), ('1', 'Low'),
('2', 'Normal'), ('3', 'High')],
string='Priority')
color = fields.Integer('Color Index')
close_date = fields.Date('Close Date',
help="Date the maintenance was finished. ")
kanban_state = fields.Selection([('normal', 'In Progress'),
('blocked', 'Blocked'),
('done', 'Ready for next stage')],
string='Kanban State',
required=True,
default='normal',
tracking=True)
# active = fields.Boolean(default=True, help="Set active to false to hide the maintenance request without deleting it.")
archive = fields.Boolean(
default=False,
help=
"Set archive to true to hide the maintenance request without deleting it."
)
maintenance_type = fields.Selection([('corrective', 'Corrective'),
('preventive', 'Preventive')],
string='Maintenance Type',
default="corrective")
schedule_date = fields.Datetime(
'Scheduled Date',
help=
"Date the maintenance team plans the maintenance. It should not differ much from the Request Date. "
)
maintenance_team_id = fields.Many2one('maintenance.team',
string='Team',
required=True,
default=_get_default_team_id,
check_company=True)
duration = fields.Float(help="Duration in hours.")
done = fields.Boolean(related='stage_id.done')
def archive_equipment_request(self):
self.write({'archive': True})
def reset_equipment_request(self):
""" Reinsert the maintenance request into the maintenance pipe in the first stage"""
first_stage_obj = self.env['maintenance.stage'].search(
[], order="sequence asc", limit=1)
# self.write({'active': True, 'stage_id': first_stage_obj.id})
self.write({'archive': False, 'stage_id': first_stage_obj.id})
@api.onchange('company_id')
def _onchange_company_id(self):
if self.company_id and self.maintenance_team_id:
if self.maintenance_team_id.company_id and not self.maintenance_team_id.company_id.id == self.company_id.id:
self.maintenance_team_id = False
@api.onchange('equipment_id')
def onchange_equipment_id(self):
if self.equipment_id:
self.user_id = self.equipment_id.technician_user_id if self.equipment_id.technician_user_id else self.equipment_id.category_id.technician_user_id
self.category_id = self.equipment_id.category_id
if self.equipment_id.maintenance_team_id:
self.maintenance_team_id = self.equipment_id.maintenance_team_id.id
@api.onchange('category_id')
def onchange_category_id(self):
if not self.user_id or not self.equipment_id or (
self.user_id and not self.equipment_id.technician_user_id):
self.user_id = self.category_id.technician_user_id
@api.model
def create(self, vals):
# context: no_log, because subtype already handle this
request = super(MaintenanceRequest, self).create(vals)
if request.owner_user_id or request.user_id:
request._add_followers()
if request.equipment_id and not request.maintenance_team_id:
request.maintenance_team_id = request.equipment_id.maintenance_team_id
request.activity_update()
return request
def write(self, vals):
# Overridden to reset the kanban_state to normal whenever
# the stage (stage_id) of the Maintenance Request changes.
if vals and 'kanban_state' not in vals and 'stage_id' in vals:
vals['kanban_state'] = 'normal'
res = super(MaintenanceRequest, self).write(vals)
if vals.get('owner_user_id') or vals.get('user_id'):
self._add_followers()
if 'stage_id' in vals:
self.filtered(lambda m: m.stage_id.done).write(
{'close_date': fields.Date.today()})
self.activity_feedback(
['maintenance.mail_act_maintenance_request'])
if vals.get('user_id') or vals.get('schedule_date'):
self.activity_update()
if vals.get('equipment_id'):
# need to change description of activity also so unlink old and create new activity
self.activity_unlink(['maintenance.mail_act_maintenance_request'])
self.activity_update()
return res
def activity_update(self):
""" Update maintenance activities based on current record set state.
It reschedule, unlink or create maintenance request activities. """
self.filtered(
lambda request: not request.schedule_date).activity_unlink(
['maintenance.mail_act_maintenance_request'])
for request in self.filtered(lambda request: request.schedule_date):
date_dl = fields.Datetime.from_string(request.schedule_date).date()
updated = request.activity_reschedule(
['maintenance.mail_act_maintenance_request'],
date_deadline=date_dl,
new_user_id=request.user_id.id or request.owner_user_id.id
or self.env.uid)
if not updated:
if request.equipment_id:
note = _(
'Request planned for <a href="#" data-oe-model="%s" data-oe-id="%s">%s</a>'
) % (request.equipment_id._name, request.equipment_id.id,
request.equipment_id.display_name)
else:
note = False
request.activity_schedule(
'maintenance.mail_act_maintenance_request',
fields.Datetime.from_string(request.schedule_date).date(),
note=note,
user_id=request.user_id.id or request.owner_user_id.id
or self.env.uid)
def _add_followers(self):
for request in self:
partner_ids = (request.owner_user_id.partner_id +
request.user_id.partner_id).ids
request.message_subscribe(partner_ids=partner_ids)
@api.model
def _read_group_stage_ids(self, stages, domain, order):
""" Read group customization in order to display all the stages in the
kanban view, even if they are empty
"""
stage_ids = stages._search([],
order=order,
access_rights_uid=SUPERUSER_ID)
return stages.browse(stage_ids)
class Digest(models.Model):
_name = 'digest.digest'
_description = 'Digest'
# Digest description
name = fields.Char(string='Name', required=True, translate=True)
user_ids = fields.Many2many('res.users', string='Recipients', domain="[('share', '=', False)]")
periodicity = fields.Selection([('weekly', 'Weekly'),
('monthly', 'Monthly'),
('quarterly', 'Quarterly')],
string='Periodicity', default='weekly', required=True)
next_run_date = fields.Date(string='Next Send Date')
template_id = fields.Many2one('mail.template', string='Email Template',
domain="[('model','=','digest.digest')]",
default=lambda self: self.env.ref('digest.digest_mail_template'),
required=True)
currency_id = fields.Many2one(related="company_id.currency_id", string='Currency', readonly=False)
company_id = fields.Many2one('res.company', string='Company', default=lambda self: self.env.company.id)
available_fields = fields.Char(compute='_compute_available_fields')
is_subscribed = fields.Boolean('Is user subscribed', compute='_compute_is_subscribed')
state = fields.Selection([('activated', 'Activated'), ('deactivated', 'Deactivated')], string='Status', readonly=True, default='activated')
# First base-related KPIs
kpi_res_users_connected = fields.Boolean('Connected Users')
kpi_res_users_connected_value = fields.Integer(compute='_compute_kpi_res_users_connected_value')
kpi_mail_message_total = fields.Boolean('Messages')
kpi_mail_message_total_value = fields.Integer(compute='_compute_kpi_mail_message_total_value')
def _compute_is_subscribed(self):
for digest in self:
digest.is_subscribed = self.env.user in digest.user_ids
def _compute_available_fields(self):
for digest in self:
kpis_values_fields = []
for field_name, field in digest._fields.items():
if field.type == 'boolean' and field_name.startswith(('kpi_', 'x_kpi_', 'x_studio_kpi_')) and digest[field_name]:
kpis_values_fields += [field_name + '_value']
digest.available_fields = ', '.join(kpis_values_fields)
def _get_kpi_compute_parameters(self):
return fields.Date.to_string(self._context.get('start_date')), fields.Date.to_string(self._context.get('end_date')), self._context.get('company')
def _compute_kpi_res_users_connected_value(self):
for record in self:
start, end, company = record._get_kpi_compute_parameters()
user_connected = self.env['res.users'].search_count([('company_id', '=', company.id), ('login_date', '>=', start), ('login_date', '<', end)])
record.kpi_res_users_connected_value = user_connected
def _compute_kpi_mail_message_total_value(self):
discussion_subtype_id = self.env.ref('mail.mt_comment').id
for record in self:
start, end, company = record._get_kpi_compute_parameters()
total_messages = self.env['mail.message'].search_count([('create_date', '>=', start), ('create_date', '<', end), ('subtype_id', '=', discussion_subtype_id), ('message_type', 'in', ['comment', 'email'])])
record.kpi_mail_message_total_value = total_messages
@api.onchange('periodicity')
def _onchange_periodicity(self):
self.next_run_date = self._get_next_run_date()
@api.model
def create(self, vals):
vals['next_run_date'] = date.today() + relativedelta(days=3)
return super(Digest, self).create(vals)
def action_subscribe(self):
if self.env.user not in self.user_ids:
self.sudo().user_ids |= self.env.user
def action_unsubcribe(self):
if self.env.user in self.user_ids:
self.sudo().user_ids -= self.env.user
def action_activate(self):
self.state = 'activated'
def action_deactivate(self):
self.state = 'deactivated'
def action_send(self):
for digest in self:
for user in digest.user_ids:
subject = '%s: %s' % (user.company_id.name, digest.name)
digest.template_id.with_context(user=user).send_mail(digest.id, force_send=True, raise_exception=True, email_values={'email_to': user.email, 'subject': subject})
digest.next_run_date = digest._get_next_run_date()
def compute_kpis(self, company, user):
self.ensure_one()
res = {}
for tf_name, tf in self._compute_timeframes(company).items():
digest = self.with_context(start_date=tf[0][0], end_date=tf[0][1], company=company).with_user(user)
previous_digest = self.with_context(start_date=tf[1][0], end_date=tf[1][1], company=company).with_user(user)
kpis = {}
for field_name, field in self._fields.items():
if field.type == 'boolean' and field_name.startswith(('kpi_', 'x_kpi_', 'x_studio_kpi_')) and self[field_name]:
try:
compute_value = digest[field_name + '_value']
# Context start and end date is different each time so invalidate to recompute.
digest.invalidate_cache([field_name + '_value'])
previous_value = previous_digest[field_name + '_value']
# Context start and end date is different each time so invalidate to recompute.
previous_digest.invalidate_cache([field_name + '_value'])
except AccessError: # no access rights -> just skip that digest details from that user's digest email
continue
margin = self._get_margin_value(compute_value, previous_value)
if self._fields[field_name+'_value'].type == 'monetary':
converted_amount = self._format_human_readable_amount(compute_value)
kpis.update({field_name: {field_name: self._format_currency_amount(converted_amount, company.currency_id), 'margin': margin}})
else:
kpis.update({field_name: {field_name: compute_value, 'margin': margin}})
res.update({tf_name: kpis})
return res
def compute_tips(self, company, user):
tip = self.env['digest.tip'].search([('user_ids', '!=', user.id), '|', ('group_id', 'in', user.groups_id.ids), ('group_id', '=', False)], limit=1)
if not tip:
return False
tip.user_ids += user
body = tools.html_sanitize(tip.tip_description)
tip_description = self.env['mail.template']._render_template(body, 'digest.tip', self.id)
return tip_description
def compute_kpis_actions(self, company, user):
""" Give an optional action to display in digest email linked to some KPIs.
:return dict: key: kpi name (field name), value: an action that will be
concatenated with /web#action={action}
"""
return {}
def _get_next_run_date(self):
self.ensure_one()
if self.periodicity == 'weekly':
delta = relativedelta(weeks=1)
elif self.periodicity == 'monthly':
delta = relativedelta(months=1)
elif self.periodicity == 'quarterly':
delta = relativedelta(months=3)
return date.today() + delta
def _compute_timeframes(self, company):
now = datetime.utcnow()
tz_name = company.resource_calendar_id.tz
if tz_name:
now = pytz.timezone(tz_name).localize(now)
start_date = now.date()
return {
'yesterday': (
(start_date + relativedelta(days=-1), start_date),
(start_date + relativedelta(days=-2), start_date + relativedelta(days=-1))),
'lastweek': (
(start_date + relativedelta(weeks=-1), start_date),
(start_date + relativedelta(weeks=-2), start_date + relativedelta(weeks=-1))),
'lastmonth': (
(start_date + relativedelta(months=-1), start_date),
(start_date + relativedelta(months=-2), start_date + relativedelta(months=-1))),
}
def _get_margin_value(self, value, previous_value=0.0):
margin = 0.0
if (value != previous_value) and (value != 0.0 and previous_value != 0.0):
margin = float_round((float(value-previous_value) / previous_value or 1) * 100, precision_digits=2)
return margin
def _format_currency_amount(self, amount, currency_id):
pre = currency_id.position == 'before'
symbol = u'{symbol}'.format(symbol=currency_id.symbol or '')
return u'{pre}{0}{post}'.format(amount, pre=symbol if pre else '', post=symbol if not pre else '')
def _format_human_readable_amount(self, amount, suffix=''):
for unit in ['', 'K', 'M', 'G']:
if abs(amount) < 1000.0:
return "%3.2f%s%s" % (amount, unit, suffix)
amount /= 1000.0
return "%.2f%s%s" % (amount, 'T', suffix)
@api.model
def _cron_send_digest_email(self):
digests = self.search([('next_run_date', '=', fields.Date.today()), ('state', '=', 'activated')])
for digest in digests:
try:
digest.action_send()
except MailDeliveryException as e:
_logger.warning('MailDeliveryException while sending digest %d. Digest is now scheduled for next cron update.')
class AccrualAccountingWizard(models.TransientModel):
_name = 'account.accrual.accounting.wizard'
_description = 'Create accrual entry.'
date = fields.Date(required=True)
company_id = fields.Many2one('res.company', required=True)
account_type = fields.Selection([('income', 'Revenue'),
('expense', 'Expense')])
active_move_line_ids = fields.Many2many('account.move.line')
journal_id = fields.Many2one(
'account.journal',
required=True,
readonly=False,
domain="[('company_id', '=', company_id), ('type', '=', 'general')]",
related="company_id.accrual_default_journal_id")
expense_accrual_account = fields.Many2one(
'account.account',
readonly=False,
domain=
"[('company_id', '=', company_id), ('internal_type', 'not in', ('receivable', 'payable')), ('internal_group', '=', 'liability'), ('reconcile', '=', True)]",
related="company_id.expense_accrual_account_id")
revenue_accrual_account = fields.Many2one(
'account.account',
readonly=False,
domain=
"[('company_id', '=', company_id), ('internal_type', 'not in', ('receivable', 'payable')), ('internal_group', '=', 'asset'), ('reconcile', '=', True)]",
related="company_id.revenue_accrual_account_id")
percentage = fields.Float("Percentage", default=100.0)
total_amount = fields.Monetary(compute="_compute_total_amount",
currency_field='company_currency_id')
company_currency_id = fields.Many2one('res.currency',
related='company_id.currency_id')
@api.constrains('percentage')
def _constraint_percentage(self):
for record in self:
if not (0.0 < record.percentage <= 100.0):
raise UserError(_("Percentage must be between 0 and 100"))
@api.depends('percentage', 'active_move_line_ids')
def _compute_total_amount(self):
for record in self:
record.total_amount = sum(
record.active_move_line_ids.mapped(
lambda l: record.percentage * (l.debit + l.credit) / 100))
@api.model
def default_get(self, fields):
if self.env.context.get(
'active_model'
) != 'account.move.line' or not self.env.context.get('active_ids'):
raise UserError(_('This can only be used on journal items'))
rec = super(AccrualAccountingWizard, self).default_get(fields)
active_move_line_ids = self.env['account.move.line'].browse(
self.env.context['active_ids'])
rec['active_move_line_ids'] = active_move_line_ids.ids
if any(move.state != 'posted'
for move in active_move_line_ids.mapped('move_id')):
raise UserError(
_('You can only change the period for posted journal items.'))
if any(move_line.reconciled for move_line in active_move_line_ids):
raise UserError(
_('You can only change the period for items that are not yet reconciled.'
))
if any(line.account_id.user_type_id !=
active_move_line_ids[0].account_id.user_type_id
for line in active_move_line_ids):
raise UserError(
_('All accounts on the lines must be from the same type.'))
if any(line.company_id != active_move_line_ids[0].company_id
for line in active_move_line_ids):
raise UserError(_('All lines must be from the same company.'))
rec['company_id'] = active_move_line_ids[0].company_id.id
account_types_allowed = self.env.ref(
'account.data_account_type_expenses') + self.env.ref(
'account.data_account_type_revenue') + self.env.ref(
'account.data_account_type_other_income')
if active_move_line_ids[
0].account_id.user_type_id not in account_types_allowed:
raise UserError(
_('You can only change the period for items in these types of accounts: '
) + ", ".join(account_types_allowed.mapped('name')))
rec['account_type'] = active_move_line_ids[
0].account_id.user_type_id.internal_group
return rec
def amend_entries(self):
# set the accrual account on the selected journal items
accrual_account = self.revenue_accrual_account if self.account_type == 'income' else self.expense_accrual_account
# Generate journal entries.
move_data = {}
for aml in self.active_move_line_ids:
ref1 = _(
'Accrual Adjusting Entry (%s%% recognized) for invoice: %s'
) % (self.percentage, aml.move_id.name)
ref2 = _(
'Accrual Adjusting Entry (%s%% recognized) for invoice: %s'
) % (100 - self.percentage, aml.move_id.name)
move_data.setdefault(
aml.move_id,
(
[
# Values to create moves.
{
'date': self.date,
'ref': ref1,
'journal_id': self.journal_id.id,
'line_ids': [],
},
{
'date': aml.move_id.date,
'ref': ref2,
'journal_id': self.journal_id.id,
'line_ids': [],
},
],
[
# Messages to log on the chatter.
(_('Accrual Adjusting Entry ({percent}% recognized) for invoice:'
) +
' <a href=# data-oe-model=account.move data-oe-id={id}>{name}</a>'
).format(
percent=self.percentage,
id=aml.move_id.id,
name=aml.move_id.name,
),
(_('Accrual Adjusting Entry ({percent}% recognized) for invoice:'
) +
' <a href=# data-oe-model=account.move data-oe-id={id}>{name}</a>'
).format(
percent=100 - self.percentage,
id=aml.move_id.id,
name=aml.move_id.name,
),
(_('Accrual Adjusting Entries ({percent}%% recognized) have been created for this invoice on {date}'
) +
' <a href=# data-oe-model=account.move data-oe-id=%(first_id)d>%(first_name)s</a> and <a href=# data-oe-model=account.move data-oe-id=%(second_id)d>%(second_name)s</a>'
).format(
percent=self.percentage,
date=format_date(self.env, self.date),
),
]))
reported_debit = aml.company_id.currency_id.round(
(self.percentage / 100) * aml.debit)
reported_credit = aml.company_id.currency_id.round(
(self.percentage / 100) * aml.credit)
if aml.currency_id:
reported_amount_currency = aml.currency_id.round(
(self.percentage / 100) * aml.amount_currency)
else:
reported_amount_currency = 0.0
move_data[aml.move_id][0][0]['line_ids'] += [
(0, 0, {
'name': aml.name,
'debit': reported_debit,
'credit': reported_credit,
'amount_currency': reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': aml.account_id.id,
'partner_id': aml.partner_id.id,
}),
(0, 0, {
'name': ref1,
'debit': reported_credit,
'credit': reported_debit,
'amount_currency': -reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': accrual_account.id,
'partner_id': aml.partner_id.id,
}),
]
move_data[aml.move_id][0][1]['line_ids'] += [
(0, 0, {
'name': aml.name,
'debit': reported_credit,
'credit': reported_debit,
'amount_currency': -reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': aml.account_id.id,
'partner_id': aml.partner_id.id,
}),
(0, 0, {
'name': ref2,
'debit': reported_debit,
'credit': reported_credit,
'amount_currency': reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': accrual_account.id,
'partner_id': aml.partner_id.id,
}),
]
move_vals = []
log_messages = []
for v in move_data.values():
move_vals += v[0]
log_messages += v[1]
created_moves = self.env['account.move'].create(move_vals)
created_moves.post()
# Reconcile.
index = 0
for move in self.active_move_line_ids.mapped('move_id'):
accrual_moves = created_moves[index:index + 2]
to_reconcile = accrual_moves.mapped('line_ids').filtered(
lambda line: line.account_id == accrual_account)
to_reconcile.reconcile()
move.message_post(
body=log_messages[index // 2 + 2] % {
'first_id': accrual_moves[0].id,
'first_name': accrual_moves[0].name,
'second_id': accrual_moves[1].id,
'second_name': accrual_moves[1].name,
})
accrual_moves[0].message_post(body=log_messages[index // 2 + 0])
accrual_moves[1].message_post(body=log_messages[index // 2 + 1])
index += 2
# open the generated entries
action = {
'name':
_('Generated Entries'),
'domain': [('id', 'in', created_moves.ids)],
'res_model':
'account.move',
'view_mode':
'tree,form',
'type':
'ir.actions.act_window',
'views': [(self.env.ref('account.view_move_tree').id, 'tree'),
(False, 'form')],
}
if len(created_moves) == 1:
action.update({'view_mode': 'form', 'res_id': created_moves.id})
return action
class FleetVehicle(models.Model):
_inherit = ['mail.thread', 'mail.activity.mixin']
_name = 'fleet.vehicle'
_description = 'Vehicle'
_order = 'license_plate asc, acquisition_date asc'
def _get_default_state(self):
state = self.env.ref('fleet.fleet_vehicle_state_registered', raise_if_not_found=False)
return state if state and state.id else False
name = fields.Char(compute="_compute_vehicle_name", store=True)
active = fields.Boolean('Active', default=True, tracking=True)
company_id = fields.Many2one('res.company', 'Company', default=lambda self: self.env.company)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
license_plate = fields.Char(tracking=True,
help='License plate number of the vehicle (i = plate number for a car)')
vin_sn = fields.Char('Chassis Number', help='Unique number written on the vehicle motor (VIN/SN number)', copy=False)
driver_id = fields.Many2one('res.partner', 'Driver', tracking=True, help='Driver of the vehicle', copy=False)
future_driver_id = fields.Many2one('res.partner', 'Future Driver', tracking=True, help='Next Driver of the vehicle', copy=False, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
model_id = fields.Many2one('fleet.vehicle.model', 'Model',
tracking=True, required=True, help='Model of the vehicle')
manager_id = fields.Many2one('res.users', related='model_id.manager_id')
brand_id = fields.Many2one('fleet.vehicle.model.brand', 'Brand', related="model_id.brand_id", store=True, readonly=False)
log_drivers = fields.One2many('fleet.vehicle.assignation.log', 'vehicle_id', string='Assignation Logs')
log_fuel = fields.One2many('fleet.vehicle.log.fuel', 'vehicle_id', 'Fuel Logs')
log_services = fields.One2many('fleet.vehicle.log.services', 'vehicle_id', 'Services Logs')
log_contracts = fields.One2many('fleet.vehicle.log.contract', 'vehicle_id', 'Contracts')
cost_count = fields.Integer(compute="_compute_count_all", string="Costs")
contract_count = fields.Integer(compute="_compute_count_all", string='Contract Count')
service_count = fields.Integer(compute="_compute_count_all", string='Services')
fuel_logs_count = fields.Integer(compute="_compute_count_all", string='Fuel Log Count')
odometer_count = fields.Integer(compute="_compute_count_all", string='Odometer')
history_count = fields.Integer(compute="_compute_count_all", string="Drivers History Count")
next_assignation_date = fields.Date('Assignation Date', help='This is the date at which the car will be available, if not set it means available instantly')
acquisition_date = fields.Date('Immatriculation Date', required=False,
default=fields.Date.today, help='Date when the vehicle has been immatriculated')
first_contract_date = fields.Date(string="First Contract Date", default=fields.Date.today)
color = fields.Char(help='Color of the vehicle')
state_id = fields.Many2one('fleet.vehicle.state', 'State',
default=_get_default_state, group_expand='_read_group_stage_ids',
tracking=True,
help='Current state of the vehicle', ondelete="set null")
location = fields.Char(help='Location of the vehicle (garage, ...)')
seats = fields.Integer('Seats Number', help='Number of seats of the vehicle')
model_year = fields.Char('Model Year', help='Year of the model')
doors = fields.Integer('Doors Number', help='Number of doors of the vehicle', default=5)
tag_ids = fields.Many2many('fleet.vehicle.tag', 'fleet_vehicle_vehicle_tag_rel', 'vehicle_tag_id', 'tag_id', 'Tags', copy=False)
odometer = fields.Float(compute='_get_odometer', inverse='_set_odometer', string='Last Odometer',
help='Odometer measure of the vehicle at the moment of this log')
odometer_unit = fields.Selection([
('kilometers', 'Kilometers'),
('miles', 'Miles')
], 'Odometer Unit', default='kilometers', help='Unit of the odometer ', required=True)
transmission = fields.Selection([('manual', 'Manual'), ('automatic', 'Automatic')], 'Transmission', help='Transmission Used by the vehicle')
fuel_type = fields.Selection([
('gasoline', 'Gasoline'),
('diesel', 'Diesel'),
('lpg', 'LPG'),
('electric', 'Electric'),
('hybrid', 'Hybrid')
], 'Fuel Type', help='Fuel Used by the vehicle')
horsepower = fields.Integer()
horsepower_tax = fields.Float('Horsepower Taxation')
power = fields.Integer('Power', help='Power in kW of the vehicle')
co2 = fields.Float('CO2 Emissions', help='CO2 emissions of the vehicle')
image_128 = fields.Image(related='model_id.image_128', readonly=False)
contract_renewal_due_soon = fields.Boolean(compute='_compute_contract_reminder', search='_search_contract_renewal_due_soon',
string='Has Contracts to renew', multi='contract_info')
contract_renewal_overdue = fields.Boolean(compute='_compute_contract_reminder', search='_search_get_overdue_contract_reminder',
string='Has Contracts Overdue', multi='contract_info')
contract_renewal_name = fields.Text(compute='_compute_contract_reminder', string='Name of contract to renew soon', multi='contract_info')
contract_renewal_total = fields.Text(compute='_compute_contract_reminder', string='Total of contracts due or overdue minus one',
multi='contract_info')
car_value = fields.Float(string="Catalog Value (VAT Incl.)", help='Value of the bought vehicle')
net_car_value = fields.Float(string="Purchase Value", help="Purchase Value of the car")
residual_value = fields.Float()
plan_to_change_car = fields.Boolean(related='driver_id.plan_to_change_car', store=True, readonly=False)
@api.depends('model_id.brand_id.name', 'model_id.name', 'license_plate')
def _compute_vehicle_name(self):
for record in self:
record.name = (record.model_id.brand_id.name or '') + '/' + (record.model_id.name or '') + '/' + (record.license_plate or _('No Plate'))
def _get_odometer(self):
FleetVehicalOdometer = self.env['fleet.vehicle.odometer']
for record in self:
vehicle_odometer = FleetVehicalOdometer.search([('vehicle_id', '=', record.id)], limit=1, order='value desc')
if vehicle_odometer:
record.odometer = vehicle_odometer.value
else:
record.odometer = 0
def _set_odometer(self):
for record in self:
if record.odometer:
date = fields.Date.context_today(record)
data = {'value': record.odometer, 'date': date, 'vehicle_id': record.id}
self.env['fleet.vehicle.odometer'].create(data)
def _compute_count_all(self):
Odometer = self.env['fleet.vehicle.odometer']
LogFuel = self.env['fleet.vehicle.log.fuel']
LogService = self.env['fleet.vehicle.log.services']
LogContract = self.env['fleet.vehicle.log.contract']
Cost = self.env['fleet.vehicle.cost']
for record in self:
record.odometer_count = Odometer.search_count([('vehicle_id', '=', record.id)])
record.fuel_logs_count = LogFuel.search_count([('vehicle_id', '=', record.id)])
record.service_count = LogService.search_count([('vehicle_id', '=', record.id)])
record.contract_count = LogContract.search_count([('vehicle_id', '=', record.id), ('state', '!=', 'closed')])
record.cost_count = Cost.search_count([('vehicle_id', '=', record.id), ('parent_id', '=', False)])
record.history_count = self.env['fleet.vehicle.assignation.log'].search_count([('vehicle_id', '=', record.id)])
@api.depends('log_contracts')
def _compute_contract_reminder(self):
params = self.env['ir.config_parameter'].sudo()
delay_alert_contract = int(params.get_param('hr_fleet.delay_alert_contract', default=30))
for record in self:
overdue = False
due_soon = False
total = 0
name = ''
for element in record.log_contracts:
if element.state in ('open', 'diesoon', 'expired') and element.expiration_date:
current_date_str = fields.Date.context_today(record)
due_time_str = element.expiration_date
current_date = fields.Date.from_string(current_date_str)
due_time = fields.Date.from_string(due_time_str)
diff_time = (due_time - current_date).days
if diff_time < 0:
overdue = True
total += 1
if diff_time < delay_alert_contract:
due_soon = True
total += 1
if overdue or due_soon:
log_contract = self.env['fleet.vehicle.log.contract'].search([
('vehicle_id', '=', record.id),
('state', 'in', ('open', 'diesoon', 'expired'))
], limit=1, order='expiration_date asc')
if log_contract:
# we display only the name of the oldest overdue/due soon contract
name = log_contract.cost_subtype_id.name
record.contract_renewal_overdue = overdue
record.contract_renewal_due_soon = due_soon
record.contract_renewal_total = total - 1 # we remove 1 from the real total for display purposes
record.contract_renewal_name = name
def _search_contract_renewal_due_soon(self, operator, value):
params = self.env['ir.config_parameter'].sudo()
delay_alert_contract = int(params.get_param('hr_fleet.delay_alert_contract', default=30))
res = []
assert operator in ('=', '!=', '<>') and value in (True, False), 'Operation not supported'
if (operator == '=' and value is True) or (operator in ('<>', '!=') and value is False):
search_operator = 'in'
else:
search_operator = 'not in'
today = fields.Date.context_today(self)
datetime_today = fields.Datetime.from_string(today)
limit_date = fields.Datetime.to_string(datetime_today + relativedelta(days=+delay_alert_contract))
self.env.cr.execute("""SELECT cost.vehicle_id,
count(contract.id) AS contract_number
FROM fleet_vehicle_cost cost
LEFT JOIN fleet_vehicle_log_contract contract ON contract.cost_id = cost.id
WHERE contract.expiration_date IS NOT NULL
AND contract.expiration_date > %s
AND contract.expiration_date < %s
AND contract.state IN ('open', 'diesoon', 'expired')
GROUP BY cost.vehicle_id""", (today, limit_date))
res_ids = [x[0] for x in self.env.cr.fetchall()]
res.append(('id', search_operator, res_ids))
return res
def _search_get_overdue_contract_reminder(self, operator, value):
res = []
assert operator in ('=', '!=', '<>') and value in (True, False), 'Operation not supported'
if (operator == '=' and value is True) or (operator in ('<>', '!=') and value is False):
search_operator = 'in'
else:
search_operator = 'not in'
today = fields.Date.context_today(self)
self.env.cr.execute('''SELECT cost.vehicle_id,
count(contract.id) AS contract_number
FROM fleet_vehicle_cost cost
LEFT JOIN fleet_vehicle_log_contract contract ON contract.cost_id = cost.id
WHERE contract.expiration_date IS NOT NULL
AND contract.expiration_date < %s
AND contract.state IN ('open', 'diesoon', 'expired')
GROUP BY cost.vehicle_id ''', (today,))
res_ids = [x[0] for x in self.env.cr.fetchall()]
res.append(('id', search_operator, res_ids))
return res
@api.model
def create(self, vals):
res = super(FleetVehicle, self).create(vals)
if 'driver_id' in vals and vals['driver_id']:
res.create_driver_history(vals['driver_id'])
if 'future_driver_id' in vals and vals['future_driver_id']:
state_waiting_list = self.env.ref('fleet.fleet_vehicle_state_waiting_list', raise_if_not_found=False)
states = res.mapped('state_id').ids
if not state_waiting_list or state_waiting_list.id not in states:
future_driver = self.env['res.partner'].browse(vals['future_driver_id'])
future_driver.sudo().write({'plan_to_change_car': True})
return res
def write(self, vals):
if 'driver_id' in vals and vals['driver_id']:
driver_id = vals['driver_id']
self.filtered(lambda v: v.driver_id.id != driver_id).create_driver_history(driver_id)
if 'future_driver_id' in vals and vals['future_driver_id']:
state_waiting_list = self.env.ref('fleet.fleet_vehicle_state_waiting_list', raise_if_not_found=False)
states = self.mapped('state_id').ids if 'state_id' not in vals else [vals['state_id']]
if not state_waiting_list or state_waiting_list.id not in states:
future_driver = self.env['res.partner'].browse(vals['future_driver_id'])
future_driver.sudo().write({'plan_to_change_car': True})
res = super(FleetVehicle, self).write(vals)
if 'active' in vals and not vals['active']:
self.mapped('log_contracts').write({'active': False})
return res
def _close_driver_history(self):
self.env['fleet.vehicle.assignation.log'].search([
('vehicle_id', 'in', self.ids),
('driver_id', 'in', self.mapped('driver_id').ids),
('date_end', '=', False)
]).write({'date_end': fields.Date.today()})
def create_driver_history(self, driver_id):
for vehicle in self:
self.env['fleet.vehicle.assignation.log'].create({
'vehicle_id': vehicle.id,
'driver_id': driver_id,
'date_start': fields.Date.today(),
})
def action_accept_driver_change(self):
# Find all the vehicles for which the driver is the future_driver_id
# remove their driver_id and close their history using current date
vehicles = self.search([('driver_id', 'in', self.mapped('future_driver_id').ids)])
vehicles.write({'driver_id': False})
vehicles._close_driver_history()
for vehicle in self:
vehicle.future_driver_id.sudo().write({'plan_to_change_car': False})
vehicle.driver_id = vehicle.future_driver_id
vehicle.future_driver_id = False
@api.model
def _read_group_stage_ids(self, stages, domain, order):
return self.env['fleet.vehicle.state'].search([], order=order)
@api.model
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
args = args or []
if operator == 'ilike' and not (name or '').strip():
domain = []
else:
domain = ['|', ('name', operator, name), ('driver_id.name', operator, name)]
rec = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid)
return models.lazy_name_get(self.browse(rec).with_user(name_get_uid))
def return_action_to_open(self):
""" This opens the xml view specified in xml_id for the current vehicle """
self.ensure_one()
xml_id = self.env.context.get('xml_id')
if xml_id:
res = self.env['ir.actions.act_window'].for_xml_id('fleet', xml_id)
res.update(
context=dict(self.env.context, default_vehicle_id=self.id, group_by=False),
domain=[('vehicle_id', '=', self.id)]
)
return res
return False
def act_show_log_cost(self):
""" This opens log view to view and add new log for this vehicle, groupby default to only show effective costs
@return: the costs log view
"""
self.ensure_one()
copy_context = dict(self.env.context)
copy_context.pop('group_by', None)
res = self.env['ir.actions.act_window'].for_xml_id('fleet', 'fleet_vehicle_costs_action')
res.update(
context=dict(copy_context, default_vehicle_id=self.id, search_default_parent_false=True),
domain=[('vehicle_id', '=', self.id)]
)
return res
def _track_subtype(self, init_values):
self.ensure_one()
if 'driver_id' in init_values or 'future_driver_id' in init_values:
return self.env.ref('fleet.mt_fleet_driver_updated')
return super(FleetVehicle, self)._track_subtype(init_values)
def open_assignation_logs(self):
self.ensure_one()
return {
'type': 'ir.actions.act_window',
'name': 'Assignation Logs',
'view_mode': 'tree',
'res_model': 'fleet.vehicle.assignation.log',
'domain': [('vehicle_id', '=', self.id)],
'context': {'default_driver_id': self.driver_id.id, 'default_vehicle_id': self.id}
}
class Goal(models.Model):
"""Goal instance for a user
An individual goal for a user on a specified time period"""
_name = 'gamification.goal'
_description = 'Gamification Goal'
_rec_name = 'definition_id'
_order = 'start_date desc, end_date desc, definition_id, id'
definition_id = fields.Many2one('gamification.goal.definition',
string="Goal Definition",
required=True,
ondelete="cascade")
user_id = fields.Many2one('res.users',
string="User",
required=True,
auto_join=True,
ondelete="cascade")
line_id = fields.Many2one('gamification.challenge.line',
string="Challenge Line",
ondelete="cascade")
challenge_id = fields.Many2one(
related='line_id.challenge_id',
store=True,
readonly=True,
help="Challenge that generated the goal, assign challenge to users "
"to generate goals with a value in this field.")
start_date = fields.Date("Start Date", default=fields.Date.today)
end_date = fields.Date("End Date") # no start and end = always active
target_goal = fields.Float('To Reach', required=True, tracking=True)
# no goal = global index
current = fields.Float("Current Value",
required=True,
default=0,
tracking=True)
completeness = fields.Float("Completeness", compute='_get_completion')
state = fields.Selection([
('draft', "Draft"),
('inprogress', "In progress"),
('reached', "Reached"),
('failed', "Failed"),
('canceled', "Canceled"),
],
default='draft',
string='State',
required=True,
tracking=True)
to_update = fields.Boolean('To update')
closed = fields.Boolean('Closed goal',
help="These goals will not be recomputed.")
computation_mode = fields.Selection(
related='definition_id.computation_mode', readonly=False)
remind_update_delay = fields.Integer(
"Remind delay",
help="The number of days after which the user "
"assigned to a manual goal will be reminded. "
"Never reminded if no value is specified.")
last_update = fields.Date(
"Last Update",
help="In case of manual goal, reminders are sent if the goal as not "
"been updated for a while (defined in challenge). Ignored in "
"case of non-manual goal or goal not linked to a challenge.")
definition_description = fields.Text("Definition Description",
related='definition_id.description',
readonly=True)
definition_condition = fields.Selection("Definition Condition",
related='definition_id.condition',
readonly=True)
definition_suffix = fields.Char("Suffix",
related='definition_id.full_suffix',
readonly=True)
definition_display = fields.Selection("Display Mode",
related='definition_id.display_mode',
readonly=True)
@api.depends('current', 'target_goal', 'definition_id.condition')
def _get_completion(self):
"""Return the percentage of completeness of the goal, between 0 and 100"""
for goal in self:
if goal.definition_condition == 'higher':
if goal.current >= goal.target_goal:
goal.completeness = 100.0
else:
goal.completeness = round(
100.0 * goal.current /
goal.target_goal, 2) if goal.target_goal else 0
elif goal.current < goal.target_goal:
# a goal 'lower than' has only two values possible: 0 or 100%
goal.completeness = 100.0
else:
goal.completeness = 0.0
def _check_remind_delay(self):
"""Verify if a goal has not been updated for some time and send a
reminder message of needed.
:return: data to write on the goal object
"""
if not (self.remind_update_delay and self.last_update):
return {}
delta_max = timedelta(days=self.remind_update_delay)
last_update = fields.Date.from_string(self.last_update)
if date.today() - last_update < delta_max:
return {}
# generate a reminder report
template = self.env.ref('gamification.email_template_goal_reminder')\
.get_email_template(self.id)
body_html = self.env['mail.template'].with_context(template._context)\
._render_template(template.body_html, 'gamification.goal', self.id)
self.message_notify(
body=body_html,
partner_ids=[self.user_id.partner_id.id],
subtype='mail.mt_comment',
email_layout_xmlid='mail.mail_notification_light',
)
return {'to_update': True}
def _get_write_values(self, new_value):
"""Generate values to write after recomputation of a goal score"""
if new_value == self.current:
# avoid useless write if the new value is the same as the old one
return {}
result = {'current': new_value}
if (self.definition_id.condition == 'higher' and new_value >= self.target_goal) \
or (self.definition_id.condition == 'lower' and new_value <= self.target_goal):
# success, do no set closed as can still change
result['state'] = 'reached'
elif self.end_date and fields.Date.today() > self.end_date:
# check goal failure
result['state'] = 'failed'
result['closed'] = True
return {self: result}
def update_goal(self):
"""Update the goals to recomputes values and change of states
If a manual goal is not updated for enough time, the user will be
reminded to do so (done only once, in 'inprogress' state).
If a goal reaches the target value, the status is set to reached
If the end date is passed (at least +1 day, time not considered) without
the target value being reached, the goal is set as failed."""
goals_by_definition = {}
for goal in self.with_context(prefetch_fields=False):
goals_by_definition.setdefault(goal.definition_id, []).append(goal)
for definition, goals in goals_by_definition.items():
goals_to_write = {}
if definition.computation_mode == 'manually':
for goal in goals:
goals_to_write[goal] = goal._check_remind_delay()
elif definition.computation_mode == 'python':
# TODO batch execution
for goal in goals:
# execute the chosen method
cxt = {
'object': goal,
'env': self.env,
'date': date,
'datetime': datetime,
'timedelta': timedelta,
'time': time,
}
code = definition.compute_code.strip()
safe_eval(code, cxt, mode="exec", nocopy=True)
# the result of the evaluated codeis put in the 'result' local variable, propagated to the context
result = cxt.get('result')
if isinstance(result, (float, int)):
goals_to_write.update(goal._get_write_values(result))
else:
_logger.error(
"Invalid return content '%r' from the evaluation "
"of code for definition %s, expected a number",
result, definition.name)
else: # count or sum
Obj = self.env[definition.model_id.model]
field_date_name = definition.field_date_id.name
if definition.computation_mode == 'count' and definition.batch_mode:
# batch mode, trying to do as much as possible in one request
general_domain = safe_eval(definition.domain)
field_name = definition.batch_distinctive_field.name
subqueries = {}
for goal in goals:
start_date = field_date_name and goal.start_date or False
end_date = field_date_name and goal.end_date or False
subqueries.setdefault(
(start_date, end_date), {}).update({
goal.id:
safe_eval(definition.batch_user_expression,
{'user': goal.user_id})
})
# the global query should be split by time periods (especially for recurrent goals)
for (start_date,
end_date), query_goals in subqueries.items():
subquery_domain = list(general_domain)
subquery_domain.append(
(field_name, 'in',
list(set(query_goals.values()))))
if start_date:
subquery_domain.append(
(field_date_name, '>=', start_date))
if end_date:
subquery_domain.append(
(field_date_name, '<=', end_date))
if field_name == 'id':
# grouping on id does not work and is similar to search anyway
users = Obj.search(subquery_domain)
user_values = [{
'id': user.id,
'id_count': 1
} for user in users]
else:
user_values = Obj.read_group(subquery_domain,
fields=[field_name],
groupby=[field_name])
# user_values has format of read_group: [{'partner_id': 42, 'partner_id_count': 3},...]
for goal in [g for g in goals if g.id in query_goals]:
for user_value in user_values:
queried_value = field_name in user_value and user_value[
field_name] or False
if isinstance(queried_value, tuple) and len(
queried_value) == 2 and isinstance(
queried_value[0], int):
queried_value = queried_value[0]
if queried_value == query_goals[goal.id]:
new_value = user_value.get(
field_name + '_count', goal.current)
goals_to_write.update(
goal._get_write_values(new_value))
else:
for goal in goals:
# eval the domain with user replaced by goal user object
domain = safe_eval(definition.domain,
{'user': goal.user_id})
# add temporal clause(s) to the domain if fields are filled on the goal
if goal.start_date and field_date_name:
domain.append(
(field_date_name, '>=', goal.start_date))
if goal.end_date and field_date_name:
domain.append(
(field_date_name, '<=', goal.end_date))
if definition.computation_mode == 'sum':
field_name = definition.field_id.name
# TODO for master: group on user field in batch mode
res = Obj.read_group(domain, [field_name], [])
new_value = res and res[0][field_name] or 0.0
else: # computation mode = count
new_value = Obj.search_count(domain)
goals_to_write.update(
goal._get_write_values(new_value))
for goal, values in goals_to_write.items():
if not values:
continue
goal.write(values)
if self.env.context.get('commit_gamification'):
self.env.cr.commit()
return True
def action_start(self):
"""Mark a goal as started.
This should only be used when creating goals manually (in draft state)"""
self.write({'state': 'inprogress'})
return self.update_goal()
def action_reach(self):
"""Mark a goal as reached.
If the target goal condition is not met, the state will be reset to In
Progress at the next goal update until the end date."""
return self.write({'state': 'reached'})
def action_fail(self):
"""Set the state of the goal to failed.
A failed goal will be ignored in future checks."""
return self.write({'state': 'failed'})
def action_cancel(self):
"""Reset the completion after setting a goal as reached or failed.
This is only the current state, if the date and/or target criteria
match the conditions for a change of state, this will be applied at the
next goal update."""
return self.write({'state': 'inprogress'})
@api.model
def create(self, vals):
return super(Goal, self.with_context(no_remind_goal=True)).create(vals)
def write(self, vals):
"""Overwrite the write method to update the last_update field to today
If the current value is changed and the report frequency is set to On
change, a report is generated
"""
vals['last_update'] = fields.Date.today()
result = super(Goal, self).write(vals)
for goal in self:
if goal.state != "draft" and ('definition_id' in vals
or 'user_id' in vals):
# avoid drag&drop in kanban view
raise exceptions.UserError(
_('Can not modify the configuration of a started goal'))
if vals.get(
'current') and 'no_remind_goal' not in self.env.context:
if goal.challenge_id.report_message_frequency == 'onchange':
goal.challenge_id.sudo().report_progress(
users=goal.user_id)
return result
def get_action(self):
"""Get the ir.action related to update the goal
In case of a manual goal, should return a wizard to update the value
:return: action description in a dictionary
"""
if self.definition_id.action_id:
# open a the action linked to the goal
action = self.definition_id.action_id.read()[0]
if self.definition_id.res_id_field:
current_user = self.env.user.with_user(self.env.user)
action['res_id'] = safe_eval(self.definition_id.res_id_field,
{'user': current_user})
# if one element to display, should see it in form mode if possible
action['views'] = [(view_id, mode)
for (view_id, mode) in action['views']
if mode == 'form'] or action['views']
return action
if self.computation_mode == 'manually':
# open a wizard window to update the value manually
action = {
'name': _("Update %s") % self.definition_id.name,
'id': self.id,
'type': 'ir.actions.act_window',
'views': [[False, 'form']],
'target': 'new',
'context': {
'default_goal_id': self.id,
'default_current': self.current
},
'res_model': 'gamification.goal.wizard'
}
return action
return False
class SaleCoupon(models.Model):
_name = 'sale.coupon'
_description = "Sales Coupon"
_rec_name = 'code'
@api.model
def _generate_code(self):
"""Generate a 20 char long pseudo-random string of digits for barcode
generation.
A decimal serialisation is longer than a hexadecimal one *but* it
generates a more compact barcode (Code128C rather than Code128A).
Generate 8 bytes (64 bits) barcodes as 16 bytes barcodes are not
compatible with all scanners.
"""
return str(random.getrandbits(64))
code = fields.Char(default=_generate_code, required=True, readonly=True)
expiration_date = fields.Date('Expiration Date', compute='_compute_expiration_date')
state = fields.Selection([
('reserved', 'Reserved'),
('new', 'Valid'),
('used', 'Consumed'),
('expired', 'Expired')
], required=True, default='new')
partner_id = fields.Many2one('res.partner', "For Customer")
program_id = fields.Many2one('sale.coupon.program', "Program", required=True, ondelete="cascade")
order_id = fields.Many2one('sale.order', 'Order Reference', readonly=True,
help="The sales order from which coupon is generated")
sales_order_id = fields.Many2one('sale.order', 'Applied on order', readonly=True,
help="The sales order on which the coupon is applied")
discount_line_product_id = fields.Many2one('product.product', related='program_id.discount_line_product_id', readonly=False,
help='Product used in the sales order to apply the discount.')
_sql_constraints = [
('unique_coupon_code', 'unique(code)', 'The coupon code must be unique!'),
]
def _compute_expiration_date(self):
self.expiration_date = 0
for coupon in self.filtered(lambda x: x.program_id.validity_duration > 0):
coupon.expiration_date = (coupon.create_date + relativedelta(days=coupon.program_id.validity_duration)).date()
def _check_coupon_code(self, order):
message = {}
applicable_programs = order._get_applicable_programs()
if self.state in ('used', 'expired') or \
(self.expiration_date and self.expiration_date < order.date_order.date()):
message = {'error': _('This coupon %s has been used or is expired.') % (self.code)}
elif self.state == 'reserved':
message = {'error': _('This coupon %s exists but the origin sales order is not validated yet.') % (self.code)}
# Minimum requirement should not be checked if the coupon got generated by a promotion program (the requirement should have only be checked to generate the coupon)
elif self.program_id.program_type == 'coupon_program' and not self.program_id._filter_on_mimimum_amount(order):
message = {'error': _('A minimum of %s %s should be purchased to get the reward') % (self.program_id.rule_minimum_amount, self.program_id.currency_id.name)}
elif not self.program_id.active:
message = {'error': _('The coupon program for %s is in draft or closed state') % (self.code)}
elif self.partner_id and self.partner_id != order.partner_id:
message = {'error': _('Invalid partner.')}
elif self.program_id in order.applied_coupon_ids.mapped('program_id'):
message = {'error': _('A Coupon is already applied for the same reward')}
elif self.program_id._is_global_discount_program() and order._is_global_discount_already_applied():
message = {'error': _('Global discounts are not cumulable.')}
elif self.program_id.reward_type == 'product' and not order._is_reward_in_order_lines(self.program_id):
message = {'error': _('The reward products should be in the sales order lines to apply the discount.')}
elif not self.program_id._is_valid_partner(order.partner_id):
message = {'error': _("The customer doesn't have access to this reward.")}
# Product requirement should not be checked if the coupon got generated by a promotion program (the requirement should have only be checked to generate the coupon)
elif self.program_id.program_type == 'coupon_program' and not self.program_id._filter_programs_on_products(order):
message = {'error': _("You don't have the required product quantities on your sales order. All the products should be recorded on the sales order. (Example: You need to have 3 T-shirts on your sales order if the promotion is 'Buy 2, Get 1 Free').")}
else:
if self.program_id not in applicable_programs and self.program_id.promo_applicability == 'on_current_order':
message = {'error': _('At least one of the required conditions is not met to get the reward!')}
return message
def action_coupon_sent(self):
""" Open a window to compose an email, with the edi invoice template
message loaded by default
"""
self.ensure_one()
template = self.env.ref('sale_coupon.mail_template_sale_coupon', False)
compose_form = self.env.ref('mail.email_compose_message_wizard_form', False)
ctx = dict(
default_model='sale.coupon',
default_res_id=self.id,
default_use_template=bool(template),
default_template_id=template.id,
default_composition_mode='comment',
custom_layout='mail.mail_notification_light',
)
return {
'name': _('Compose Email'),
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'mail.compose.message',
'views': [(compose_form.id, 'form')],
'view_id': compose_form.id,
'target': 'new',
'context': ctx,
}
class FinancialYearOpeningWizard(models.TransientModel):
_name = 'account.financial.year.op'
_description = 'Opening Balance of Financial Year'
company_id = fields.Many2one(comodel_name='res.company', required=True)
opening_move_posted = fields.Boolean(
string='Opening Move Posted', compute='_compute_opening_move_posted')
opening_date = fields.Date(
string='Opening Date',
required=True,
related='company_id.account_opening_date',
help=
"Date from which the accounting is managed in Harpiya. It is the date of the opening entry.",
readonly=False)
fiscalyear_last_day = fields.Integer(
related="company_id.fiscalyear_last_day",
required=True,
readonly=False,
help=
"The last day of the month will be used if the chosen day doesn't exist."
)
fiscalyear_last_month = fields.Selection(
selection=[(1, 'January'), (2, 'February'), (3, 'March'), (4, 'April'),
(5, 'May'), (6, 'June'), (7, 'July'), (8, 'August'),
(9, 'September'), (10, 'October'), (11, 'November'),
(12, 'December')],
related="company_id.fiscalyear_last_month",
readonly=False,
required=True,
help=
"The last day of the month will be used if the chosen day doesn't exist."
)
@api.depends('company_id.account_opening_move_id')
def _compute_opening_move_posted(self):
for record in self:
record.opening_move_posted = record.company_id.opening_move_posted(
)
@api.constrains('fiscalyear_last_day', 'fiscalyear_last_month')
def _check_fiscalyear(self):
# We try if the date exists in 2020, which is a leap year.
# We do not define the constrain on res.company, since the recomputation of the related
# fields is done one field at a time.
for wiz in self:
try:
date(2020, int(wiz.fiscalyear_last_month),
wiz.fiscalyear_last_day)
except ValueError:
raise ValidationError(
_('Incorrect fiscal year date: day is out of range for month. Month: %s; Day: %s'
) % (wiz.fiscalyear_last_month, wiz.fiscalyear_last_day))
def write(self, vals):
# Amazing workaround: non-stored related fields on company are a BAD idea since the 3 fields
# must follow the constraint '_check_fiscalyear_last_day'. The thing is, in case of related
# fields, the inverse write is done one value at a time, and thus the constraint is verified
# one value at a time... so it is likely to fail.
for wiz in self:
wiz.company_id.write({
'account_opening_date':
vals.get('opening_date')
or wiz.company_id.account_opening_date,
'fiscalyear_last_day':
vals.get('fiscalyear_last_day')
or wiz.company_id.fiscalyear_last_day,
'fiscalyear_last_month':
vals.get('fiscalyear_last_month')
or wiz.company_id.fiscalyear_last_month,
})
vals.pop('opening_date', None)
vals.pop('fiscalyear_last_day', None)
vals.pop('fiscalyear_last_month', None)
return super().write(vals)
def action_save_onboarding_fiscal_year(self):
self.env.company.sudo().set_onboarding_step_done(
'account_setup_fy_data_state')
class User(models.Model):
_inherit = "res.users"
leave_manager_id = fields.Many2one(related='employee_id.leave_manager_id')
show_leaves = fields.Boolean(related='employee_id.show_leaves')
allocation_used_count = fields.Float(related='employee_id.allocation_used_count')
allocation_count = fields.Float(related='employee_id.allocation_count')
leave_date_to = fields.Date(related='employee_id.leave_date_to')
is_absent = fields.Boolean(related='employee_id.is_absent')
allocation_used_display = fields.Char(related='employee_id.allocation_used_display')
allocation_display = fields.Char(related='employee_id.allocation_display')
def __init__(self, pool, cr):
""" Override of __init__ to add access rights.
Access rights are disabled by default, but allowed
on some specific fields defined in self.SELF_{READ/WRITE}ABLE_FIELDS.
"""
readable_fields = [
'leave_manager_id',
'show_leaves',
'allocation_used_count',
'allocation_count',
'leave_date_to',
'is_absent',
'allocation_used_display',
'allocation_display',
]
init_res = super(User, self).__init__(pool, cr)
# duplicate list to avoid modifying the original reference
type(self).SELF_READABLE_FIELDS = type(self).SELF_READABLE_FIELDS + readable_fields
return init_res
def _compute_im_status(self):
super(User, self)._compute_im_status()
on_leave_user_ids = self._get_on_leave_ids()
for user in self:
if user.id in on_leave_user_ids:
if user.im_status == 'online':
user.im_status = 'leave_online'
else:
user.im_status = 'leave_offline'
@api.model
def _get_on_leave_ids(self, partner=False):
now = fields.Datetime.now()
field = 'partner_id' if partner else 'id'
self.env.cr.execute('''SELECT res_users.%s FROM res_users
JOIN hr_leave ON hr_leave.user_id = res_users.id
AND state not in ('cancel', 'refuse')
AND res_users.active = 't'
AND date_from <= %%s AND date_to >= %%s''' % field, (now, now))
return [r[0] for r in self.env.cr.fetchall()]
def _clean_leave_responsible_users(self):
# self = old bunch of leave responsibles
# This method compares the current leave managers
# and remove the access rights to those who don't
# need them anymore
approver_group = self.env.ref('hr_holidays.group_hr_holidays_responsible', raise_if_not_found=False)
if not self or not approver_group:
return
res = self.env['hr.employee'].read_group(
[('leave_manager_id', 'in', self.ids)],
['leave_manager_id'],
['leave_manager_id'])
responsibles_to_remove_ids = set(self.ids) - {x['leave_manager_id'][0] for x in res}
approver_group.sudo().write({
'users': [(3, manager_id) for manager_id in responsibles_to_remove_ids]})
class Contract(models.Model):
_name = 'hr.contract'
_description = 'Contract'
_inherit = ['mail.thread', 'mail.activity.mixin']
name = fields.Char('Contract Reference', required=True)
active = fields.Boolean(default=True)
employee_id = fields.Many2one(
'hr.employee',
string='Employee',
tracking=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
department_id = fields.Many2one(
'hr.department',
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
string="Department")
job_id = fields.Many2one(
'hr.job',
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
string='Job Position')
date_start = fields.Date('Start Date',
required=True,
default=fields.Date.today,
tracking=True,
help="Start date of the contract.")
date_end = fields.Date(
'End Date',
tracking=True,
help="End date of the contract (if it's a fixed-term contract).")
trial_date_end = fields.Date(
'End of Trial Period',
help="End date of the trial period (if there is one).")
resource_calendar_id = fields.Many2one(
'resource.calendar',
'Working Schedule',
default=lambda self: self.env.company.resource_calendar_id.id,
copy=False,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
wage = fields.Monetary('Wage',
required=True,
tracking=True,
help="Employee's monthly gross wage.")
advantages = fields.Text('Advantages')
notes = fields.Text('Notes')
state = fields.Selection([('draft', 'New'), ('open', 'Running'),
('close', 'Expired'), ('cancel', 'Cancelled')],
string='Status',
group_expand='_expand_states',
copy=False,
tracking=True,
help='Status of the contract',
default='draft')
company_id = fields.Many2one('res.company',
default=lambda self: self.env.company,
required=True)
"""
kanban_state:
* draft + green = "Incoming" state (will be set as Open once the contract has started)
* open + red = "Pending" state (will be set as Closed once the contract has ended)
* red = Shows a warning on the employees kanban view
"""
kanban_state = fields.Selection([('normal', 'Grey'), ('done', 'Green'),
('blocked', 'Red')],
string='Kanban State',
default='normal',
tracking=True,
copy=False)
currency_id = fields.Many2one(string="Currency",
related='company_id.currency_id',
readonly=True)
permit_no = fields.Char('Work Permit No',
related="employee_id.permit_no",
readonly=False)
visa_no = fields.Char('Visa No',
related="employee_id.visa_no",
readonly=False)
visa_expire = fields.Date('Visa Expire Date',
related="employee_id.visa_expire",
readonly=False)
hr_responsible_id = fields.Many2one(
'res.users',
'HR Responsible',
tracking=True,
help='Person responsible for validating the employee\'s contracts.')
calendar_mismatch = fields.Boolean(compute='_compute_calendar_mismatch')
@api.depends('employee_id.resource_calendar_id', 'resource_calendar_id')
def _compute_calendar_mismatch(self):
for contract in self:
contract.calendar_mismatch = contract.resource_calendar_id != contract.employee_id.resource_calendar_id
def _expand_states(self, states, domain, order):
return [key for key, val in type(self).state.selection]
@api.onchange('employee_id')
def _onchange_employee_id(self):
if self.employee_id:
self.job_id = self.employee_id.job_id
self.department_id = self.employee_id.department_id
self.resource_calendar_id = self.employee_id.resource_calendar_id
self.company_id = self.employee_id.company_id
@api.constrains('employee_id', 'state', 'kanban_state', 'date_start',
'date_end')
def _check_current_contract(self):
""" Two contracts in state [incoming | open | close] cannot overlap """
for contract in self.filtered(lambda c: (
c.state not in ['draft', 'cancel'] or c.state == 'draft' and c.
kanban_state == 'done') and c.employee_id):
domain = [
('id', '!=', contract.id),
('employee_id', '=', contract.employee_id.id),
'|',
('state', 'in', ['open', 'close']),
'&',
('state', '=', 'draft'),
('kanban_state', '=', 'done') # replaces incoming
]
if not contract.date_end:
start_domain = []
end_domain = [
'|', ('date_end', '>=', contract.date_start),
('date_end', '=', False)
]
else:
start_domain = [('date_start', '<=', contract.date_end)]
end_domain = [
'|', ('date_end', '>', contract.date_start),
('date_end', '=', False)
]
domain = expression.AND([domain, start_domain, end_domain])
if self.search_count(domain):
raise ValidationError(
_('An employee can only have one contract at the same time. (Excluding Draft and Cancelled contracts)'
))
@api.constrains('date_start', 'date_end')
def _check_dates(self):
if self.filtered(lambda c: c.date_end and c.date_start > c.date_end):
raise ValidationError(
_('Contract start date must be earlier than contract end date.'
))
@api.model
def update_state(self):
self.search([
('state', '=', 'open'),
'|',
'&',
('date_end', '<=',
fields.Date.to_string(date.today() + relativedelta(days=7))),
('date_end', '>=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
'&',
('visa_expire', '<=',
fields.Date.to_string(date.today() + relativedelta(days=60))),
('visa_expire', '>=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
]).write({'kanban_state': 'blocked'})
self.search([
('state', '=', 'open'),
'|',
('date_end', '<=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
('visa_expire', '<=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
]).write({'state': 'close'})
self.search([
('state', '=', 'draft'),
('kanban_state', '=', 'done'),
('date_start', '<=', fields.Date.to_string(date.today())),
]).write({'state': 'open'})
contract_ids = self.search([('date_end', '=', False),
('state', '=', 'close'),
('employee_id', '!=', False)])
# Ensure all closed contract followed by a new contract have a end date.
# If closed contract has no closed date, the work entries will be generated for an unlimited period.
for contract in contract_ids:
next_contract = self.search(
[('employee_id', '=', contract.employee_id.id),
('state', 'not in', ['cancel', 'new']),
('date_start', '>', contract.date_start)],
order="date_start asc",
limit=1)
if next_contract:
contract.date_end = next_contract.date_start - relativedelta(
days=1)
continue
next_contract = self.search(
[('employee_id', '=', contract.employee_id.id),
('date_start', '>', contract.date_start)],
order="date_start asc",
limit=1)
if next_contract:
contract.date_end = next_contract.date_start - relativedelta(
days=1)
return True
def _assign_open_contract(self):
for contract in self:
contract.employee_id.sudo().write({'contract_id': contract.id})
def write(self, vals):
res = super(Contract, self).write(vals)
if vals.get('state') == 'open':
self._assign_open_contract()
if vals.get('state') == 'close':
for contract in self.filtered(lambda c: not c.date_end):
contract.date_end = max(date.today(), contract.date_start)
calendar = vals.get('resource_calendar_id')
if calendar and (self.state == 'open' or
(self.state == 'draft'
and self.kanban_state == 'done')):
self.mapped('employee_id').write(
{'resource_calendar_id': calendar})
if 'state' in vals and 'kanban_state' not in vals:
self.write({'kanban_state': 'normal'})
return res
@api.model
def create(self, vals):
contracts = super(Contract, self).create(vals)
if vals.get('state') == 'open':
contracts._assign_open_contract()
open_contracts = contracts.filtered(
lambda c: c.state == 'open' or c.state == 'draft' and c.
kanban_state == 'done')
# sync contract calendar -> calendar employee
for contract in open_contracts.filtered(
lambda c: c.employee_id and c.resource_calendar_id):
contract.employee_id.resource_calendar_id = contract.resource_calendar_id
return contracts
def _track_subtype(self, init_values):
self.ensure_one()
if 'state' in init_values and self.state == 'open' and 'kanban_state' in init_values and self.kanban_state == 'blocked':
return self.env.ref('hr_contract.mt_contract_pending')
elif 'state' in init_values and self.state == 'close':
return self.env.ref('hr_contract.mt_contract_close')
return super(Contract, self)._track_subtype(init_values)
class Channel(models.Model):
""" A channel is a container of slides. """
_name = 'slide.channel'
_description = 'Slide Channel'
_inherit = [
'mail.thread', 'rating.mixin', 'image.mixin', 'website.seo.metadata',
'website.published.multi.mixin'
]
_order = 'sequence, id'
def _default_access_token(self):
return str(uuid.uuid4())
# description
name = fields.Char('Name', translate=True, required=True)
active = fields.Boolean(default=True)
description = fields.Text('Short Description', translate=True)
description_html = fields.Html('Description',
translate=tools.html_translate,
sanitize_attributes=False)
channel_type = fields.Selection([('documentation', 'Documentation'),
('training', 'Training')],
string="Course type",
default="documentation",
required=True)
sequence = fields.Integer(default=10, help='Display order')
user_id = fields.Many2one('res.users',
string='Responsible',
default=lambda self: self.env.uid)
color = fields.Integer('Color Index',
default=0,
help='Used to decorate kanban view')
tag_ids = fields.Many2many(
'slide.channel.tag',
'slide_channel_tag_rel',
'channel_id',
'tag_id',
string='Tags',
help='Used to categorize and filter displayed channels/courses')
# slides: promote, statistics
slide_ids = fields.One2many('slide.slide',
'channel_id',
string="Slides and categories")
slide_content_ids = fields.One2many(
'slide.slide',
string='Slides',
compute="_compute_category_and_slide_ids")
slide_category_ids = fields.One2many(
'slide.slide',
string='Categories',
compute="_compute_category_and_slide_ids")
slide_last_update = fields.Date('Last Update',
compute='_compute_slide_last_update',
store=True)
slide_partner_ids = fields.One2many(
'slide.slide.partner',
'channel_id',
string="Slide User Data",
copy=False,
groups='website.group_website_publisher')
promote_strategy = fields.Selection([('latest', 'Latest Published'),
('most_voted', 'Most Voted'),
('most_viewed', 'Most Viewed')],
string="Featured Content",
default='latest',
required=True)
access_token = fields.Char("Security Token",
copy=False,
default=_default_access_token)
nbr_presentation = fields.Integer('Presentations',
compute='_compute_slides_statistics',
store=True)
nbr_document = fields.Integer('Documents',
compute='_compute_slides_statistics',
store=True)
nbr_video = fields.Integer('Videos',
compute='_compute_slides_statistics',
store=True)
nbr_infographic = fields.Integer('Infographics',
compute='_compute_slides_statistics',
store=True)
nbr_webpage = fields.Integer("Webpages",
compute='_compute_slides_statistics',
store=True)
nbr_quiz = fields.Integer("Number of Quizs",
compute='_compute_slides_statistics',
store=True)
total_slides = fields.Integer('Content',
compute='_compute_slides_statistics',
store=True)
total_views = fields.Integer('Visits',
compute='_compute_slides_statistics',
store=True)
total_votes = fields.Integer('Votes',
compute='_compute_slides_statistics',
store=True)
total_time = fields.Float('Duration',
compute='_compute_slides_statistics',
digits=(10, 2),
store=True)
rating_avg_stars = fields.Float("Rating Average (Stars)",
compute='_compute_rating_stats',
digits=(16, 1))
# configuration
allow_comment = fields.Boolean(
"Allow rating on Course",
default=False,
help="If checked it allows members to either:\n"
" * like content and post comments on documentation course;\n"
" * post comment and review on training course;")
publish_template_id = fields.Many2one(
'mail.template',
string='New Content Email',
help="Email template to send slide publication through email",
default=lambda self: self.env['ir.model.data'].xmlid_to_res_id(
'website_slides.slide_template_published'))
share_template_id = fields.Many2one(
'mail.template',
string='Share Template',
help="Email template used when sharing a slide",
default=lambda self: self.env['ir.model.data'].xmlid_to_res_id(
'website_slides.slide_template_shared'))
enroll = fields.Selection(
[('public', 'Public'), ('invite', 'On Invitation')],
default='public',
string='Enroll Policy',
required=True,
help=
'Condition to enroll: everyone, on invite, on payment (sale bridge).')
enroll_msg = fields.Html('Enroll Message',
help="Message explaining the enroll process",
default=False,
translate=tools.html_translate,
sanitize_attributes=False)
enroll_group_ids = fields.Many2many(
'res.groups',
string='Auto Enroll Groups',
help=
"Members of those groups are automatically added as members of the channel."
)
visibility = fields.Selection(
[('public', 'Public'), ('members', 'Members Only')],
default='public',
string='Visibility',
required=True,
help=
'Applied directly as ACLs. Allow to hide channels and their content for non members.'
)
partner_ids = fields.Many2many('res.partner',
'slide_channel_partner',
'channel_id',
'partner_id',
string='Members',
help="All members of the channel.",
context={'active_test': False},
copy=False,
depends=['channel_partner_ids'])
members_count = fields.Integer('Attendees count',
compute='_compute_members_count')
members_done_count = fields.Integer('Attendees Done Count',
compute='_compute_members_done_count')
is_member = fields.Boolean(string='Is Member',
compute='_compute_is_member')
channel_partner_ids = fields.One2many(
'slide.channel.partner',
'channel_id',
string='Members Information',
groups='website.group_website_publisher',
depends=['partner_ids'])
upload_group_ids = fields.Many2many(
'res.groups',
'rel_upload_groups',
'channel_id',
'group_id',
string='Upload Groups',
help=
"Group of users allowed to publish contents on a documentation course."
)
# not stored access fields, depending on each user
completed = fields.Boolean('Done',
compute='_compute_user_statistics',
compute_sudo=False)
completion = fields.Integer('Completion',
compute='_compute_user_statistics',
compute_sudo=False)
can_upload = fields.Boolean('Can Upload',
compute='_compute_can_upload',
compute_sudo=False)
# karma generation
karma_gen_slide_vote = fields.Integer(string='Lesson voted', default=1)
karma_gen_channel_rank = fields.Integer(string='Course ranked', default=5)
karma_gen_channel_finish = fields.Integer(string='Course finished',
default=10)
# Karma based actions
karma_review = fields.Integer(
'Add Review',
default=10,
help="Karma needed to add a review on the course")
karma_slide_comment = fields.Integer(
'Add Comment',
default=3,
help="Karma needed to add a comment on a slide of this course")
karma_slide_vote = fields.Integer(
'Vote',
default=3,
help="Karma needed to like/dislike a slide of this course.")
can_review = fields.Boolean('Can Review',
compute='_compute_action_rights',
compute_sudo=False)
can_comment = fields.Boolean('Can Comment',
compute='_compute_action_rights',
compute_sudo=False)
can_vote = fields.Boolean('Can Vote',
compute='_compute_action_rights',
compute_sudo=False)
@api.depends('slide_ids.is_published')
def _compute_slide_last_update(self):
for record in self:
record.slide_last_update = fields.Date.today()
@api.depends('channel_partner_ids.channel_id')
def _compute_members_count(self):
read_group_res = self.env['slide.channel.partner'].sudo().read_group(
[('channel_id', 'in', self.ids)], ['channel_id'], 'channel_id')
data = dict((res['channel_id'][0], res['channel_id_count'])
for res in read_group_res)
for channel in self:
channel.members_count = data.get(channel.id, 0)
@api.depends('channel_partner_ids.channel_id',
'channel_partner_ids.completed')
def _compute_members_done_count(self):
read_group_res = self.env['slide.channel.partner'].sudo().read_group(
['&', ('channel_id', 'in', self.ids),
('completed', '=', True)], ['channel_id'], 'channel_id')
data = dict((res['channel_id'][0], res['channel_id_count'])
for res in read_group_res)
for channel in self:
channel.members_done_count = data.get(channel.id, 0)
@api.depends('channel_partner_ids.partner_id')
@api.model
def _compute_is_member(self):
channel_partners = self.env['slide.channel.partner'].sudo().search([
('channel_id', 'in', self.ids),
])
result = dict()
for cp in channel_partners:
result.setdefault(cp.channel_id.id, []).append(cp.partner_id.id)
for channel in self:
channel.is_member = channel.is_member = self.env.user.partner_id.id in result.get(
channel.id, [])
@api.depends('slide_ids.is_category')
def _compute_category_and_slide_ids(self):
for channel in self:
channel.slide_category_ids = channel.slide_ids.filtered(
lambda slide: slide.is_category)
channel.slide_content_ids = channel.slide_ids - channel.slide_category_ids
@api.depends('slide_ids.slide_type', 'slide_ids.is_published',
'slide_ids.completion_time', 'slide_ids.likes',
'slide_ids.dislikes', 'slide_ids.total_views',
'slide_ids.is_category', 'slide_ids.active')
def _compute_slides_statistics(self):
default_vals = dict(total_views=0,
total_votes=0,
total_time=0,
total_slides=0)
keys = [
'nbr_%s' % slide_type for slide_type in
self.env['slide.slide']._fields['slide_type'].get_values(self.env)
]
default_vals.update(dict((key, 0) for key in keys))
result = dict((cid, dict(default_vals)) for cid in self.ids)
read_group_res = self.env['slide.slide'].read_group(
[('active', '=', True), ('is_published', '=', True),
('channel_id', 'in', self.ids), ('is_category', '=', False)], [
'channel_id', 'slide_type', 'likes', 'dislikes',
'total_views', 'completion_time'
],
groupby=['channel_id', 'slide_type'],
lazy=False)
for res_group in read_group_res:
cid = res_group['channel_id'][0]
result[cid]['total_views'] += res_group.get('total_views', 0)
result[cid]['total_votes'] += res_group.get('likes', 0)
result[cid]['total_votes'] -= res_group.get('dislikes', 0)
result[cid]['total_time'] += res_group.get('completion_time', 0)
type_stats = self._compute_slides_statistics_type(read_group_res)
for cid, cdata in type_stats.items():
result[cid].update(cdata)
for record in self:
record.update(result.get(record.id, default_vals))
def _compute_slides_statistics_type(self, read_group_res):
""" Compute statistics based on all existing slide types """
slide_types = self.env['slide.slide']._fields['slide_type'].get_values(
self.env)
keys = ['nbr_%s' % slide_type for slide_type in slide_types]
result = dict((cid, dict((key, 0) for key in keys + ['total_slides']))
for cid in self.ids)
for res_group in read_group_res:
cid = res_group['channel_id'][0]
slide_type = res_group.get('slide_type')
if slide_type:
slide_type_count = res_group.get('__count', 0)
result[cid]['nbr_%s' % slide_type] = slide_type_count
result[cid]['total_slides'] += slide_type_count
return result
def _compute_rating_stats(self):
super(Channel, self)._compute_rating_stats()
for record in self:
record.rating_avg_stars = record.rating_avg / 2
@api.depends('slide_partner_ids', 'total_slides')
@api.depends_context('uid')
def _compute_user_statistics(self):
current_user_info = self.env['slide.channel.partner'].sudo().search([
('channel_id', 'in', self.ids),
('partner_id', '=', self.env.user.partner_id.id)
])
mapped_data = dict(
(info.channel_id.id, (info.completed, info.completion))
for info in current_user_info)
for record in self:
completed, completion = mapped_data.get(record.id, (False, 0))
record.completed = completed
record.completion = round(100.0 * completion /
(record.total_slides or 1))
@api.depends('upload_group_ids', 'user_id')
@api.depends_context('uid')
def _compute_can_upload(self):
for record in self:
if record.user_id == self.env.user:
record.can_upload = True
elif record.upload_group_ids:
record.can_upload = bool(record.upload_group_ids
& self.env.user.groups_id)
else:
record.can_upload = self.env.user.has_group(
'website.group_website_publisher')
@api.depends('channel_type', 'user_id', 'can_upload')
def _compute_can_publish(self):
""" For channels of type 'training', only the responsible (see user_id field) can publish slides.
The 'sudo' user needs to be handled because he's the one used for uploads done on the front-end when the
logged in user is not publisher but fulfills the upload_group_ids condition. """
for record in self:
if not record.can_upload:
record.can_publish = False
elif record.user_id == self.env.user or self.env.is_superuser():
record.can_publish = True
else:
record.can_publish = self.env.user.has_group(
'website.group_website_publisher')
@api.model
def _get_can_publish_error_message(self):
return _(
"Publishing is restricted to the responsible of training courses or members of the publisher group for documentation courses"
)
@api.depends('name', 'website_id.domain')
def _compute_website_url(self):
super(Channel, self)._compute_website_url()
for channel in self:
if channel.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
base_url = channel.get_base_url()
channel.website_url = '%s/slides/%s' % (base_url,
slug(channel))
def get_backend_menu_id(self):
return self.env.ref('website_slides.website_slides_menu_root').id
def _compute_action_rights(self):
user_karma = self.env.user.karma
for channel in self:
if channel.can_publish:
channel.can_vote = channel.can_comment = channel.can_review = True
elif not channel.is_member:
channel.can_vote = channel.can_comment = channel.can_review = False
else:
channel.can_review = user_karma >= channel.karma_review
channel.can_comment = user_karma >= channel.karma_slide_comment
channel.can_vote = user_karma >= channel.karma_slide_vote
# ---------------------------------------------------------
# ORM Overrides
# ---------------------------------------------------------
def _init_column(self, column_name):
""" Initialize the value of the given column for existing rows.
Overridden here because we need to generate different access tokens
and by default _init_column calls the default method once and applies
it for every record.
"""
if column_name != 'access_token':
super(Channel, self)._init_column(column_name)
else:
query = """
UPDATE %(table_name)s
SET %(column_name)s = md5(md5(random()::varchar || id::varchar) || clock_timestamp()::varchar)::uuid::varchar
WHERE %(column_name)s IS NULL
""" % {
'table_name': self._table,
'column_name': column_name
}
self.env.cr.execute(query)
@api.model
def create(self, vals):
# Ensure creator is member of its channel it is easier for him to manage it (unless it is harpiyabot)
if not vals.get('channel_partner_ids') and not self.env.is_superuser():
vals['channel_partner_ids'] = [(0, 0, {
'partner_id':
self.env.user.partner_id.id
})]
channel = super(
Channel,
self.with_context(mail_create_nosubscribe=True)).create(vals)
if channel.user_id:
channel._action_add_members(channel.user_id.partner_id)
if 'enroll_group_ids' in vals:
channel._add_groups_members()
return channel
def write(self, vals):
res = super(Channel, self).write(vals)
if vals.get('user_id'):
self._action_add_members(self.env['res.users'].sudo().browse(
vals['user_id']).partner_id)
if 'active' in vals:
# archiving/unarchiving a channel does it on its slides, too
self.with_context(active_test=False).mapped('slide_ids').write(
{'active': vals['active']})
if 'enroll_group_ids' in vals:
self._add_groups_members()
return res
@api.returns('mail.message', lambda value: value.id)
def message_post(self, *, parent_id=False, subtype=None, **kwargs):
""" Temporary workaround to avoid spam. If someone replies on a channel
through the 'Presentation Published' email, it should be considered as a
note as we don't want all channel followers to be notified of this answer. """
self.ensure_one()
if kwargs.get('message_type') == 'comment' and not self.can_review:
raise AccessError(_('Not enough karma to review'))
if parent_id:
parent_message = self.env['mail.message'].sudo().browse(parent_id)
if parent_message.subtype_id and parent_message.subtype_id == self.env.ref(
'website_slides.mt_channel_slide_published'):
if kwargs.get('subtype_id'):
kwargs['subtype_id'] = False
subtype = 'mail.mt_note'
return super(Channel, self).message_post(parent_id=parent_id,
subtype=subtype,
**kwargs)
# ---------------------------------------------------------
# Business / Actions
# ---------------------------------------------------------
def action_redirect_to_members(self, state=None):
action = self.env.ref(
'website_slides.slide_channel_partner_action').read()[0]
action['domain'] = [('channel_id', 'in', self.ids)]
if len(self) == 1:
action['display_name'] = _('Attendees of %s') % self.name
action['context'] = {
'active_test': False,
'default_channel_id': self.id
}
if state:
action['domain'] += [('completed', '=', state == 'completed')]
return action
def action_redirect_to_running_members(self):
return self.action_redirect_to_members('running')
def action_redirect_to_done_members(self):
return self.action_redirect_to_members('completed')
def action_channel_invite(self):
self.ensure_one()
template = self.env.ref(
'website_slides.mail_template_slide_channel_invite',
raise_if_not_found=False)
local_context = dict(
self.env.context,
default_channel_id=self.id,
default_use_template=bool(template),
default_template_id=template and template.id or False,
notif_layout='mail.mail_notification_light',
)
return {
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'slide.channel.invite',
'target': 'new',
'context': local_context,
}
def action_add_member(self, **member_values):
""" Adds the logged in user in the channel members.
(see '_action_add_members' for more info)
Returns True if added successfully, False otherwise."""
return bool(
self._action_add_members(self.env.user.partner_id,
**member_values))
def _action_add_members(self, target_partners, **member_values):
""" Add the target_partner as a member of the channel (to its slide.channel.partner).
This will make the content (slides) of the channel available to that partner.
Returns the added 'slide.channel.partner's (! as sudo !)
"""
to_join = self._filter_add_members(target_partners, **member_values)
if to_join:
existing = self.env['slide.channel.partner'].sudo().search([
('channel_id', 'in', self.ids),
('partner_id', 'in', target_partners.ids)
])
existing_map = dict((cid, list()) for cid in self.ids)
for item in existing:
existing_map[item.channel_id.id].append(item.partner_id.id)
to_create_values = [
dict(channel_id=channel.id,
partner_id=partner.id,
**member_values) for channel in to_join
for partner in target_partners
if partner.id not in existing_map[channel.id]
]
slide_partners_sudo = self.env['slide.channel.partner'].sudo(
).create(to_create_values)
to_join.message_subscribe(
partner_ids=target_partners.ids,
subtype_ids=[
self.env.ref(
'website_slides.mt_channel_slide_published').id
])
return slide_partners_sudo
return self.env['slide.channel.partner'].sudo()
def _filter_add_members(self, target_partners, **member_values):
allowed = self.filtered(lambda channel: channel.enroll == 'public')
on_invite = self.filtered(lambda channel: channel.enroll == 'invite')
if on_invite:
try:
on_invite.check_access_rights('write')
on_invite.check_access_rule('write')
except:
pass
else:
allowed |= on_invite
return allowed
def _add_groups_members(self):
for channel in self:
channel._action_add_members(
channel.mapped('enroll_group_ids.users.partner_id'))
def _get_earned_karma(self, partner_ids):
""" Compute the number of karma earned by partners on a channel
Warning: this count will not be accurate if the configuration has been
modified after the completion of a course!
"""
total_karma = defaultdict(int)
slide_completed = self.env['slide.slide.partner'].sudo().search([
('partner_id', 'in', partner_ids), ('channel_id', 'in', self.ids),
('completed', '=', True), ('quiz_attempts_count', '>', 0)
])
for partner_slide in slide_completed:
slide = partner_slide.slide_id
if not slide.question_ids:
continue
gains = [
slide.quiz_first_attempt_reward,
slide.quiz_second_attempt_reward,
slide.quiz_third_attempt_reward,
slide.quiz_fourth_attempt_reward
]
attempts = min(partner_slide.quiz_attempts_count - 1, 3)
total_karma[partner_slide.partner_id.id] += gains[attempts]
channel_completed = self.env['slide.channel.partner'].sudo().search([
('partner_id', 'in', partner_ids), ('channel_id', 'in', self.ids),
('completed', '=', True)
])
for partner_channel in channel_completed:
channel = partner_channel.channel_id
total_karma[partner_channel.partner_id.
id] += channel.karma_gen_channel_finish
return total_karma
def _remove_membership(self, partner_ids):
""" Unlink (!!!) the relationships between the passed partner_ids
and the channels and their slides (done in the unlink of slide.channel.partner model).
Remove earned karma when completed quizz """
if not partner_ids:
raise ValueError(
"Do not use this method with an empty partner_id recordset")
earned_karma = self._get_earned_karma(partner_ids)
users = self.env['res.users'].sudo().search([
('partner_id', 'in', list(earned_karma)),
])
for user in users:
if earned_karma[user.partner_id.id]:
user.add_karma(-1 * earned_karma[user.partner_id.id])
removed_channel_partner_domain = []
for channel in self:
removed_channel_partner_domain = expression.OR([
removed_channel_partner_domain,
[('partner_id', 'in', partner_ids),
('channel_id', '=', channel.id)]
])
self.message_unsubscribe(partner_ids=partner_ids)
if removed_channel_partner_domain:
self.env['slide.channel.partner'].sudo().search(
removed_channel_partner_domain).unlink()
def action_view_slides(self):
action = self.env.ref('website_slides.slide_slide_action').read()[0]
action['context'] = {
'search_default_published': 1,
'default_channel_id': self.id
}
action['domain'] = [('channel_id', "=", self.id),
('is_category', '=', False)]
return action
def action_view_ratings(self):
action = self.env.ref(
'website_slides.rating_rating_action_slide_channel').read()[0]
action['name'] = _('Rating of %s') % (self.name)
action['domain'] = [('res_id', 'in', self.ids)]
return action
# ---------------------------------------------------------
# Rating Mixin API
# ---------------------------------------------------------
def _rating_domain(self):
""" Only take the published rating into account to compute avg and count """
domain = super(Channel, self)._rating_domain()
return expression.AND([domain, [('website_published', '=', True)]])
# ---------------------------------------------------------
# Data / Misc
# ---------------------------------------------------------
def _get_categorized_slides(self,
base_domain,
order,
force_void=True,
limit=False,
offset=False):
""" Return an ordered structure of slides by categories within a given
base_domain that must fulfill slides. As a course structure is based on
its slides sequences, uncategorized slides must have the lowest sequences.
Example
* category 1 (sequence 1), category 2 (sequence 3)
* slide 1 (sequence 0), slide 2 (sequence 2)
* course structure is: slide 1, category 1, slide 2, category 2
* slide 1 is uncategorized,
* category 1 has one slide : Slide 2
* category 2 is empty.
Backend and frontend ordering is the same, uncategorized first. It
eases resequencing based on DOM / displayed order, notably when
drag n drop is involved. """
self.ensure_one()
all_categories = self.env['slide.slide'].sudo().search([
('channel_id', '=', self.id), ('is_category', '=', True)
])
all_slides = self.env['slide.slide'].sudo().search(base_domain,
order=order)
category_data = []
# Prepare all categories by natural order
for category in all_categories:
category_slides = all_slides.filtered(
lambda slide: slide.category_id == category)
if not category_slides and not force_void:
continue
category_data.append({
'category':
category,
'id':
category.id,
'name':
category.name,
'slug_name':
slug(category),
'total_slides':
len(category_slides),
'slides':
category_slides[(offset or 0):(
limit + offset or len(category_slides))],
})
# Add uncategorized slides in first position
uncategorized_slides = all_slides.filtered(
lambda slide: not slide.category_id)
if uncategorized_slides or force_void:
category_data.insert(
0, {
'category':
False,
'id':
False,
'name':
_('Uncategorized'),
'slug_name':
_('Uncategorized'),
'total_slides':
len(uncategorized_slides),
'slides':
uncategorized_slides[(offset or 0):(
offset + limit or len(uncategorized_slides))],
})
return category_data
def _resequence_slides(self, slide, force_category=False):
ids_to_resequence = self.slide_ids.ids
index_of_added_slide = ids_to_resequence.index(slide.id)
next_category_id = None
if self.slide_category_ids:
force_category_id = force_category.id if force_category else slide.category_id.id
index_of_category = self.slide_category_ids.ids.index(
force_category_id) if force_category_id else None
if index_of_category is None:
next_category_id = self.slide_category_ids.ids[0]
elif index_of_category < len(self.slide_category_ids.ids) - 1:
next_category_id = self.slide_category_ids.ids[
index_of_category + 1]
if next_category_id:
added_slide_id = ids_to_resequence.pop(index_of_added_slide)
index_of_next_category = ids_to_resequence.index(next_category_id)
ids_to_resequence.insert(index_of_next_category, added_slide_id)
for i, record in enumerate(
self.env['slide.slide'].browse(ids_to_resequence)):
record.write({'sequence':
i + 1}) # start at 1 to make people scream
else:
slide.write({
'sequence':
self.env['slide.slide'].browse(ids_to_resequence[-1]).sequence
+ 1
})
class SaleOrder(models.Model):
_inherit = "sale.order"
@api.model
def _default_warehouse_id(self):
company = self.env.company.id
warehouse_ids = self.env['stock.warehouse'].search(
[('company_id', '=', company)], limit=1)
return warehouse_ids
incoterm = fields.Many2one(
'account.incoterms',
'Incoterm',
help=
"International Commercial Terms are a series of predefined commercial terms used in international transactions."
)
picking_policy = fields.Selection(
[('direct', 'As soon as possible'),
('one', 'When all products are ready')],
string='Shipping Policy',
required=True,
readonly=True,
default='direct',
states={
'draft': [('readonly', False)],
'sent': [('readonly', False)]
},
help=
"If you deliver all products at once, the delivery order will be scheduled based on the greatest "
"product lead time. Otherwise, it will be based on the shortest.")
warehouse_id = fields.Many2one('stock.warehouse',
string='Warehouse',
required=True,
readonly=True,
states={
'draft': [('readonly', False)],
'sent': [('readonly', False)]
},
default=_default_warehouse_id,
check_company=True)
picking_ids = fields.One2many('stock.picking',
'sale_id',
string='Transfers')
delivery_count = fields.Integer(string='Delivery Orders',
compute='_compute_picking_ids')
procurement_group_id = fields.Many2one('procurement.group',
'Procurement Group',
copy=False)
effective_date = fields.Date(
"Effective Date",
compute='_compute_effective_date',
store=True,
help="Completion date of the first delivery order.")
expected_date = fields.Datetime(
help=
"Delivery date you can promise to the customer, computed from the minimum lead time of "
"the order lines in case of Service products. In case of shipping, the shipping policy of "
"the order will be taken into account to either use the minimum or maximum lead time of "
"the order lines.")
@api.depends('picking_ids.date_done')
def _compute_effective_date(self):
for order in self:
pickings = order.picking_ids.filtered(
lambda x: x.state == 'done' and x.location_dest_id.usage ==
'customer')
dates_list = [
date for date in pickings.mapped('date_done') if date
]
order.effective_date = min(
dates_list).date() if dates_list else False
@api.depends('picking_policy')
def _compute_expected_date(self):
super(SaleOrder, self)._compute_expected_date()
for order in self:
dates_list = []
for line in order.order_line.filtered(
lambda x: x.state != 'cancel' and not x._is_delivery()):
dt = line._expected_date()
dates_list.append(dt)
if dates_list:
expected_date = min(
dates_list) if order.picking_policy == 'direct' else max(
dates_list)
order.expected_date = fields.Datetime.to_string(expected_date)
@api.model
def create(self, vals):
if 'warehouse_id' not in vals and 'company_id' in vals and vals.get(
'company_id') != self.env.company.id:
vals['warehouse_id'] = self.env['stock.warehouse'].search(
[('company_id', '=', vals.get('company_id'))], limit=1).id
return super(SaleOrder, self).create(vals)
def write(self, values):
if values.get('order_line') and self.state == 'sale':
for order in self:
pre_order_line_qty = {
order_line: order_line.product_uom_qty
for order_line in order.mapped('order_line')
if not order_line.is_expense
}
if values.get('partner_shipping_id'):
new_partner = self.env['res.partner'].browse(
values.get('partner_shipping_id'))
for record in self:
picking = record.mapped('picking_ids').filtered(
lambda x: x.state not in ('done', 'cancel'))
addresses = (record.partner_shipping_id.display_name,
new_partner.display_name)
message = _(
"""The delivery address has been changed on the Sales Order<br/>
From <strong>"%s"</strong> To <strong>"%s"</strong>,
You should probably update the partner on this document."""
) % addresses
picking.activity_schedule('mail.mail_activity_data_warning',
note=message,
user_id=self.env.user.id)
res = super(SaleOrder, self).write(values)
if values.get('order_line') and self.state == 'sale':
for order in self:
to_log = {}
for order_line in order.order_line:
if float_compare(order_line.product_uom_qty,
pre_order_line_qty.get(order_line, 0.0),
order_line.product_uom.rounding) < 0:
to_log[order_line] = (order_line.product_uom_qty,
pre_order_line_qty.get(
order_line, 0.0))
if to_log:
documents = self.env[
'stock.picking']._log_activity_get_documents(
to_log, 'move_ids', 'UP')
documents = {
k: v
for k, v in documents.items() if k[0].state != 'cancel'
}
order._log_decrease_ordered_quantity(documents)
return res
def _action_confirm(self):
self.order_line._action_launch_stock_rule()
return super(SaleOrder, self)._action_confirm()
@api.depends('picking_ids')
def _compute_picking_ids(self):
for order in self:
order.delivery_count = len(order.picking_ids)
@api.onchange('company_id')
def _onchange_company_id(self):
if self.company_id:
warehouse_id = self.env['ir.default'].get_model_defaults(
'sale.order').get('warehouse_id')
self.warehouse_id = warehouse_id or self.env[
'stock.warehouse'].search(
[('company_id', '=', self.company_id.id)], limit=1)
@api.onchange('partner_shipping_id')
def _onchange_partner_shipping_id(self):
res = {}
pickings = self.picking_ids.filtered(
lambda p: p.state not in ['done', 'cancel'] and p.partner_id !=
self.partner_shipping_id)
if pickings:
res['warning'] = {
'title':
_('Warning!'),
'message':
_('Do not forget to change the partner on the following delivery orders: %s'
) % (','.join(pickings.mapped('name')))
}
return res
def action_view_delivery(self):
'''
This function returns an action that display existing delivery orders
of given sales order ids. It can either be a in a list or in a form
view, if there is only one delivery order to show.
'''
action = self.env.ref('stock.action_picking_tree_all').read()[0]
pickings = self.mapped('picking_ids')
if len(pickings) > 1:
action['domain'] = [('id', 'in', pickings.ids)]
elif pickings:
form_view = [(self.env.ref('stock.view_picking_form').id, 'form')]
if 'views' in action:
action['views'] = form_view + [
(state, view)
for state, view in action['views'] if view != 'form'
]
else:
action['views'] = form_view
action['res_id'] = pickings.id
# Prepare the context.
picking_id = pickings.filtered(
lambda l: l.picking_type_id.code == 'outgoing')
if picking_id:
picking_id = picking_id[0]
else:
picking_id = pickings[0]
action['context'] = dict(
self._context,
default_partner_id=self.partner_id.id,
default_picking_id=picking_id.id,
default_picking_type_id=picking_id.picking_type_id.id,
default_origin=self.name,
default_group_id=picking_id.group_id.id)
return action
def action_cancel(self):
documents = None
for sale_order in self:
if sale_order.state == 'sale' and sale_order.order_line:
sale_order_lines_quantities = {
order_line: (order_line.product_uom_qty, 0)
for order_line in sale_order.order_line
}
documents = self.env[
'stock.picking']._log_activity_get_documents(
sale_order_lines_quantities, 'move_ids', 'UP')
self.mapped('picking_ids').action_cancel()
if documents:
filtered_documents = {}
for (parent, responsible), rendering_context in documents.items():
if parent._name == 'stock.picking':
if parent.state == 'cancel':
continue
filtered_documents[(parent, responsible)] = rendering_context
self._log_decrease_ordered_quantity(filtered_documents,
cancel=True)
return super(SaleOrder, self).action_cancel()
def _prepare_invoice(self):
invoice_vals = super(SaleOrder, self)._prepare_invoice()
invoice_vals['invoice_incoterm_id'] = self.incoterm.id
return invoice_vals
@api.model
def _get_customer_lead(self, product_tmpl_id):
super(SaleOrder, self)._get_customer_lead(product_tmpl_id)
return product_tmpl_id.sale_delay
def _log_decrease_ordered_quantity(self, documents, cancel=False):
def _render_note_exception_quantity_so(rendering_context):
order_exceptions, visited_moves = rendering_context
visited_moves = list(visited_moves)
visited_moves = self.env[visited_moves[0]._name].concat(
*visited_moves)
order_line_ids = self.env['sale.order.line'].browse([
order_line.id for order in order_exceptions.values()
for order_line in order[0]
])
sale_order_ids = order_line_ids.mapped('order_id')
impacted_pickings = visited_moves.filtered(
lambda m: m.state not in ('done', 'cancel')).mapped(
'picking_id')
values = {
'sale_order_ids': sale_order_ids,
'order_exceptions': order_exceptions.values(),
'impacted_pickings': impacted_pickings,
'cancel': cancel
}
return self.env.ref('sale_stock.exception_on_so').render(
values=values)
self.env['stock.picking']._log_activity(
_render_note_exception_quantity_so, documents)
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', 'image.mixin']
_mail_post_access = 'read'
@api.model
def _default_image(self):
image_path = get_module_resource('hr', 'static/src/img', 'default_image.png')
return base64.b64encode(open(image_path, 'rb').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)
# 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")
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", default="male", 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 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 salary account')
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 Expire Date', groups="hr.group_hr_user", tracking=True)
additional_note = fields.Text(string='Additional Note', groups="hr.group_hr_user", tracking=True)
certificate = fields.Selection([
('bachelor', 'Bachelor'),
('master', 'Master'),
('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("Emergency Contact", groups="hr.group_hr_user", tracking=True)
emergency_phone = fields.Char("Emergency Phone", groups="hr.group_hr_user", tracking=True)
km_home_work = fields.Integer(string="Km Home-Work", groups="hr.group_hr_user", tracking=True)
image_1920 = fields.Image(default=_default_image)
phone = fields.Char(related='address_home_id.phone', related_sudo=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_manager",
string='Tags')
# misc
notes = fields.Text('Notes', groups="hr.group_hr_user")
color = fields.Integer('Color Index', default=0, groups="hr.group_hr_user")
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 Kiosk Mode (if enabled in Configuration).")
departure_reason = fields.Selection([
('fired', 'Fired'),
('resigned', 'Resigned'),
('retired', 'Retired')
], string="Departure Reason", groups="hr.group_hr_user", copy=False, tracking=True)
departure_description = fields.Text(string="Additional Information", groups="hr.group_hr_user", copy=False, tracking=True)
message_main_attachment_id = fields.Many2one(groups="hr.group_hr_user")
_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.")
]
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)
res = self.env['hr.employee.public'].browse(self.ids).read(fields)
for r in res:
record = self.browse(r['id'])
record._update_cache({k:v for k,v in r.items() if k in fields}, validate=False)
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 load_views(self, views, options=None):
if self.check_access_rights('read', raise_exception=False):
return super(HrEmployeePrivate, self).load_views(views, options=options)
return self.env['hr.employee.public'].load_views(views, options=options)
@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)
return self.env['hr.employee.public']._search(args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
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.check_access_rights('read', raise_exception=False):
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.check_access_rights('read', raise_exception=False):
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('job_id')
def _onchange_job_id(self):
if self.job_id:
self.job_title = self.job_id.name
@api.onchange('address_id')
def _onchange_address(self):
self.work_phone = self.address_id.phone
self.mobile_phone = self.address_id.mobile
@api.onchange('company_id')
def _onchange_company(self):
address = self.company_id.partner_id.address_get(['default'])
self.address_id = address['default'] if address else False
@api.onchange('department_id')
def _onchange_department(self):
if self.department_id.manager_id:
self.parent_id = self.department_id.manager_id
@api.onchange('user_id')
def _onchange_user(self):
if self.user_id:
self.update(self._sync_user(self.user_id))
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):
vals = dict(
image_1920=user.image_1920,
work_email=user.email,
user_id=user.id,
)
if user.tz:
vals['tz'] = user.tz
return vals
@api.model
def create(self, vals):
if vals.get('user_id'):
user = self.env['res.users'].browse(vals['user_id'])
vals.update(self._sync_user(user))
vals['name'] = vals.get('name', user.name)
employee = super(HrEmployeePrivate, self).create(vals)
url = '/web#%s' % url_encode({
'action': 'hr.plan_wizard_action',
'active_id': employee.id,
'active_model': 'hr.employee',
'menu_id': self.env.ref('hr.menu_hr_root').id,
})
employee._message_log(body=_('<b>Congratulations!</b> May I recommend you to setup an <a href="%s">onboarding plan?</a>') % (url))
if employee.department_id:
self.env['mail.channel'].sudo().search([
('subscription_department_ids', 'in', employee.department_id.id)
])._subscribe_users()
return employee
def write(self, vals):
if 'address_home_id' in vals:
account_id = vals.get('bank_account_id') or self.bank_account_id.id
if account_id:
self.env['res.partner.bank'].browse(account_id).partner_id = vals['address_home_id']
if vals.get('user_id'):
vals.update(self._sync_user(self.env['res.users'].browse(vals['user_id'])))
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()
return res
def unlink(self):
resources = self.mapped('resource_id')
super(HrEmployeePrivate, self).unlink()
return resources.unlink()
def toggle_active(self):
res = super(HrEmployeePrivate, self).toggle_active()
self.filtered(lambda employee: employee.active).write({
'departure_reason': False,
'departure_description': False,
})
if len(self) == 1 and not self.active:
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
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.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
# ---------------------------------------------------------
# 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 HarpiyaBot
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
# ---------------------------------------------------------
# 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']
