class ImageMixin(models.AbstractModel):
_name = 'image.mixin'
_description = "Image Mixin"
# all image fields are base64 encoded and PIL-supported
image_1920 = fields.Image("Image", max_width=1920, max_height=1920)
# resized fields stored (as attachment) for performance
image_1024 = fields.Image("Image 1024", related="image_1920", max_width=1024, max_height=1024, store=True)
image_512 = fields.Image("Image 512", related="image_1920", max_width=512, max_height=512, store=True)
image_256 = fields.Image("Image 256", related="image_1920", max_width=256, max_height=256, store=True)
image_128 = fields.Image("Image 128", related="image_1920", max_width=128, max_height=128, store=True)
class Website(models.Model):
_inherit = "website"
app_icon = fields.Image(string='Website App Icon', compute='_compute_app_icon', store=True, readonly=True, help='This field holds the image used as mobile app icon on the website (PNG format).')
events_app_name = fields.Char(string='Events App Name', compute='_compute_events_app_name', store=True, readonly=False, help="This fields holds the Event's Progressive Web App name.")
@api.depends('name')
def _compute_events_app_name(self):
for website in self:
if not website.events_app_name:
website.events_app_name = _('%s Events') % website.name
@api.constrains('events_app_name')
def _check_events_app_name(self):
for website in self:
if not website.events_app_name:
raise ValidationError(_('"Events App Name" field is required.'))
@api.depends('favicon')
def _compute_app_icon(self):
""" Computes a squared image based on the favicon to be used as mobile webapp icon.
App Icon should be in PNG format and size of at least 512x512.
"""
for website in self:
if not website.favicon:
website.app_icon = False
continue
image = ImageProcess(website.favicon)
w, h = image.image.size
square_size = w if w > h else h
image.crop_resize(square_size, square_size)
image.image = image.image.resize((512, 512))
image.operationsCount += 1
website.app_icon = image.image_base64(output_format='PNG')
class FleetVehicleModelBrand(models.Model):
_name = 'fleet.vehicle.model.brand'
_description = 'Brand of the vehicle'
_order = 'model_count desc, name asc'
name = fields.Char('Make', required=True)
image_128 = fields.Image("Logo", max_width=128, max_height=128)
model_count = fields.Integer(compute="_compute_model_count", string="", store=True)
model_ids = fields.One2many('fleet.vehicle.model', 'brand_id')
@api.depends('model_ids')
def _compute_model_count(self):
Model = self.env['fleet.vehicle.model']
for record in self:
record.model_count = Model.search_count([('brand_id', '=', record.id)])
def action_brand_model(self):
self.ensure_one()
view = {
'type': 'ir.actions.act_window',
'view_mode': 'tree,form',
'res_model': 'fleet.vehicle.model',
'name': 'Models',
'context': {'search_default_brand_id': self.id, 'default_brand_id': self.id}
}
return view
class FleetVehicleModel(models.Model):
_name = 'fleet.vehicle.model'
_description = 'Model of a vehicle'
_order = 'name asc'
name = fields.Char('Model name', required=True)
brand_id = fields.Many2one('fleet.vehicle.model.brand', 'Manufacturer', required=True, help='Manufacturer of the vehicle')
vendors = fields.Many2many('res.partner', 'fleet_vehicle_model_vendors', 'model_id', 'partner_id', string='Vendors')
manager_id = fields.Many2one('res.users', 'Fleet Manager', default=lambda self: self.env.uid,
domain=lambda self: [('groups_id', 'in', self.env.ref('fleet.fleet_group_manager').id)])
image_128 = fields.Image(related='brand_id.image_128', readonly=True)
active = fields.Boolean(default=True)
vehicle_type = fields.Selection([('car', 'Car'), ('bike', 'Bike')], default='car', required=True)
@api.depends('name', 'brand_id')
def name_get(self):
res = []
for record in self:
name = record.name
if record.brand_id.name:
name = record.brand_id.name + '/' + name
res.append((record.id, name))
return res
def write(self, vals):
if 'manager_id' in vals:
old_manager = self.manager_id.id if self.manager_id else None
self.env['fleet.vehicle'].search([('model_id', '=', self.id), ('manager_id', '=', old_manager)]).write({'manager_id': vals['manager_id']})
return super(FleetVehicleModel, self).write(vals)
class ModelImage(models.Model):
_name = 'test_new_api.model_image'
_description = 'Test Image field'
name = fields.Char(required=True)
image = fields.Image()
image_512 = fields.Image("Image 512",
related='image',
max_width=512,
max_height=512,
store=True,
readonly=False)
image_256 = fields.Image("Image 256",
related='image',
max_width=256,
max_height=256,
store=False,
readonly=False)
image_128 = fields.Image("Image 128", max_width=128, max_height=128)
class PosCategory(models.Model):
_name = "pos.category"
_description = "Point of Sale Category"
_order = "sequence, name"
@api.constrains('parent_id')
def _check_category_recursion(self):
if not self._check_recursion():
raise ValidationError(
_('Error ! You cannot create recursive categories.'))
name = fields.Char(string='Category Name', required=True, translate=True)
parent_id = fields.Many2one('pos.category',
string='Parent Category',
index=True)
child_id = fields.One2many('pos.category',
'parent_id',
string='Children Categories')
sequence = fields.Integer(
help=
"Gives the sequence order when displaying a list of product categories."
)
image_128 = fields.Image("Image", max_width=128, max_height=128)
def name_get(self):
def get_names(cat):
res = []
while cat:
res.append(cat.name)
cat = cat.parent_id
return res
return [(cat.id, " / ".join(reversed(get_names(cat)))) for cat in self]
def unlink(self):
if self.search_count([('id', 'in', self.ids)]):
if self.env['pos.session'].sudo().search_count([('state', '!=',
'closed')]):
raise UserError(
_('You cannot delete a point of sale category while a session is still opened.'
))
return super(PosCategory, self).unlink()
class SurveyQuestionAnswer(models.Model):
""" A preconfigured answer for a question. This model stores values used
for
* simple choice, multiple choice: proposed values for the selection /
radio;
* matrix: row and column values;
"""
_name = 'survey.question.answer'
_rec_name = 'value'
_order = 'sequence, id'
_description = 'Survey Label'
question_id = fields.Many2one('survey.question',
string='Question',
ondelete='cascade')
matrix_question_id = fields.Many2one('survey.question',
string='Question (as matrix row)',
ondelete='cascade')
sequence = fields.Integer('Label Sequence order', default=10)
value = fields.Char('Suggested value', translate=True, required=True)
value_image = fields.Image('Image', max_width=256, max_height=256)
is_correct = fields.Boolean('Is a correct answer')
answer_score = fields.Float(
'Score for this choice',
help=
"A positive score indicates a correct choice; a negative or null score indicates a wrong answer"
)
@api.constrains('question_id', 'matrix_question_id')
def _check_question_not_empty(self):
"""Ensure that field question_id XOR field matrix_question_id is not null"""
for label in self:
if not bool(label.question_id) != bool(label.matrix_question_id):
raise ValidationError(
_("A label must be attached to only one question."))
class LunchProductCategory(models.Model):
""" Category of the product such as pizza, sandwich, pasta, chinese, burger... """
_name = 'lunch.product.category'
_inherit = 'image.mixin'
_description = 'Lunch Product Category'
@api.model
def _default_image(self):
image_path = get_module_resource('lunch', 'static/img', 'lunch.png')
return base64.b64encode(open(image_path, 'rb').read())
name = fields.Char('Product Category', required=True, translate=True)
company_id = fields.Many2one('res.company')
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
topping_label_1 = fields.Char('Extra 1 Label', required=True, default='Extras')
topping_label_2 = fields.Char('Extra 2 Label', required=True, default='Beverages')
topping_label_3 = fields.Char('Extra 3 Label', required=True, default='Extra Label 3')
topping_ids_1 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 1)])
topping_ids_2 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 2)])
topping_ids_3 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 3)])
topping_quantity_1 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 1 Quantity', default='0_more', required=True)
topping_quantity_2 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 2 Quantity', default='0_more', required=True)
topping_quantity_3 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 3 Quantity', default='0_more', required=True)
product_count = fields.Integer(compute='_compute_product_count', help="The number of products related to this category")
active = fields.Boolean(string='Active', default=True)
image_1920 = fields.Image(default=_default_image)
def _compute_product_count(self):
product_data = self.env['lunch.product'].read_group([('category_id', 'in', self.ids)], ['category_id'], ['category_id'])
data = {product['category_id'][0]: product['category_id_count'] for product in product_data}
for category in self:
category.product_count = data.get(category.id, 0)
@api.model
def create(self, vals):
for topping in vals.get('topping_ids_2', []):
topping[2].update({'topping_category': 2})
for topping in vals.get('topping_ids_3', []):
topping[2].update({'topping_category': 3})
return super(LunchProductCategory, self).create(vals)
def write(self, vals):
for topping in vals.get('topping_ids_2', []):
topping_values = topping[2]
if topping_values:
topping_values.update({'topping_category': 2})
for topping in vals.get('topping_ids_3', []):
topping_values = topping[2]
if topping_values:
topping_values.update({'topping_category': 3})
return super(LunchProductCategory, self).write(vals)
def toggle_active(self):
""" Archiving related lunch product """
res = super().toggle_active()
Product = self.env['lunch.product'].with_context(active_test=False)
all_products = Product.search([('category_id', 'in', self.ids)])
all_products._sync_active_from_related()
return res
class LunchProductReport(models.Model):
_name = "lunch.product.report"
_description = 'Product report'
_auto = False
_order = 'is_favorite desc, is_new desc, last_order_date asc, product_id asc'
id = fields.Integer('ID')
product_id = fields.Many2one('lunch.product', 'Product')
name = fields.Char('Product Name', related='product_id.name')
category_id = fields.Many2one('lunch.product.category', 'Product Category')
description = fields.Text('Description', related='product_id.description')
price = fields.Float('Price')
supplier_id = fields.Many2one('lunch.supplier', 'Vendor')
company_id = fields.Many2one('res.company')
currency_id = fields.Many2one('res.currency',
related='company_id.currency_id')
is_favorite = fields.Boolean('Favorite')
user_id = fields.Many2one('res.users')
is_new = fields.Boolean('New')
active = fields.Boolean('Active')
last_order_date = fields.Date('Last Order Date')
image_128 = fields.Image(compute="_compute_image_128")
# This field is used only for searching
is_available_at = fields.Many2one('lunch.location',
'Product Availability',
compute='_compute_is_available_at',
search='_search_is_available_at')
def _compute_image_128(self):
for product_r in self:
product = product_r.product_id
category = product_r.sudo().category_id
if product.image_128:
product_r.image_128 = product.image_128
elif category.image_128:
product_r.image_128 = category.image_128
else:
product_r.image_128 = False
def compute_concurrency_field(self):
"""Image caching is based on the `__last_update` field (=self.CONCURRENCY_CHECK_FIELD)
But the image is never cached by the browser because the value fallbacks to
`now` when access logging is disabled. This override sets a "real" value based on the
product or category last update.
"""
for report in self:
product_last_update = report.product_id[
self.CONCURRENCY_CHECK_FIELD]
category_last_update = report.category_id[
self.CONCURRENCY_CHECK_FIELD]
report[self.CONCURRENCY_CHECK_FIELD] = max(product_last_update,
category_last_update)
def _compute_is_available_at(self):
"""
Is available_at is always false when browsing it
this field is there only to search (see _search_is_available_at)
"""
for product in self:
product.is_available_at = False
def _search_is_available_at(self, operator, value):
supported_operators = ['in', 'not in', '=', '!=']
if not operator in supported_operators:
return expression.TRUE_DOMAIN
if isinstance(value, int):
value = [value]
if operator in expression.NEGATIVE_TERM_OPERATORS:
return expression.AND([[
('supplier_id.available_location_ids', 'not in', value)
], [('supplier_id.available_location_ids', '!=', False)]])
return expression.OR([[
('supplier_id.available_location_ids', 'in', value)
], [('supplier_id.available_location_ids', '=', False)]])
def write(self, values):
if 'is_favorite' in values:
if values['is_favorite']:
commands = [(4, product_id)
for product_id in self.mapped('product_id').ids]
else:
commands = [(3, product_id)
for product_id in self.mapped('product_id').ids]
self.env.user.write({
'favorite_lunch_product_ids': commands,
})
def init(self):
tools.drop_view_if_exists(self._cr, self._table)
self._cr.execute(
"""
CREATE or REPLACE view %s AS (
SELECT
row_number() over (ORDER BY users.id,product.id) AS id,
product.id AS product_id,
product.category_id,
product.price,
product.supplier_id,
product.company_id,
product.active,
users.id AS user_id,
fav.user_id IS NOT NULL AS is_favorite,
product.new_until >= current_date AS is_new,
orders.last_order_date
FROM lunch_product product
CROSS JOIN res_users users
INNER JOIN res_groups_users_rel groups ON groups.uid = users.id -- only generate for internal users
LEFT JOIN LATERAL (select max(date) AS last_order_date FROM lunch_order where user_id=users.id and product_id=product.id) AS orders ON TRUE
LEFT JOIN LATERAL (select user_id FROM lunch_product_favorite_user_rel where user_id=users.id and product_id=product.id) AS fav ON TRUE
WHERE users.active AND product.active AND groups.gid = %%s --only take into account active products and users
);
""" % self._table, (self.env.ref('base.group_user').id, ))
class Thumbnail(models.AbstractModel):
_name = "dms.mixins.thumbnail"
_description = "Thumbnail Mixin"
custom_thumbnail = fields.Image(
string="Custom Thumbnail",
max_width=2048,
max_height=2048,
attachment=False,
prefetch=False,
)
custom_thumbnail_medium = fields.Image(
"Medium Custom Thumbnail",
related="custom_thumbnail",
max_width=512,
max_height=512,
prefetch=False,
)
custom_thumbnail_small = fields.Image(
"Small Custom Thumbnail",
related="custom_thumbnail",
max_width=512,
max_height=512,
prefetch=False,
)
thumbnail = fields.Image(
compute="_compute_thumbnail",
string="Thumbnail",
max_width=2048,
max_height=2048,
prefetch=False,
)
thumbnail_medium = fields.Image(
"Medium Thumbnail",
related="thumbnail",
max_width=512,
max_height=512,
prefetch=False,
)
thumbnail_small = fields.Image(
"SmallThumbnail",
related="thumbnail",
max_width=512,
max_height=512,
prefetch=False,
)
# ----------------------------------------------------------
# Helper
# ----------------------------------------------------------
@api.model
def _get_thumbnail_placeholder_image(self, size, name):
path = self._get_thumbnail_path(size, name)
with open(path, "rb") as image:
return base64.b64encode(image.read())
@api.model
def _get_thumbnail_path(self, size, name):
folders = ["static", "lib", "img", "thumbnails"]
path = get_resource_path("dms", *folders, name)
if not os.path.isfile(path):
path = get_resource_path("dms", *folders, "file_unkown.svg")
return path
def _get_thumbnail_placeholder_name(self):
return "folder.svg"
@api.depends("custom_thumbnail")
def _compute_thumbnail(self):
for record in self:
if record.custom_thumbnail:
record.thumbnail = record.custom_thumbnail
else:
record.thumbnail = self._get_thumbnail_placeholder_image(
"original", record._get_thumbnail_placeholder_name())
class Track(models.Model):
_name = "event.track"
_description = 'Event Track'
_order = 'priority, date'
_inherit = [
'mail.thread', 'mail.activity.mixin', 'website.seo.metadata',
'website.published.mixin'
]
@api.model
def _get_default_stage_id(self):
return self.env['event.track.stage'].search([], limit=1).id
# description
name = fields.Char('Title', required=True, translate=True)
event_id = fields.Many2one('event.event', 'Event', required=True)
active = fields.Boolean(default=True)
user_id = fields.Many2one('res.users',
'Responsible',
tracking=True,
default=lambda self: self.env.user)
company_id = fields.Many2one('res.company', related='event_id.company_id')
tag_ids = fields.Many2many('event.track.tag', string='Tags')
description = fields.Html(translate=html_translate,
sanitize_attributes=False,
sanitize_form=False)
color = fields.Integer('Color')
priority = fields.Selection([('0', 'Low'), ('1', 'Medium'), ('2', 'High'),
('3', 'Highest')],
'Priority',
required=True,
default='1')
# management
stage_id = fields.Many2one('event.track.stage',
string='Stage',
ondelete='restrict',
index=True,
copy=False,
default=_get_default_stage_id,
group_expand='_read_group_stage_ids',
required=True,
tracking=True)
is_accepted = fields.Boolean('Is Accepted',
related='stage_id.is_accepted',
readonly=True)
kanban_state = fields.Selection(
[('normal', 'Grey'), ('done', 'Green'), ('blocked', 'Red')],
string='Kanban State',
copy=False,
default='normal',
required=True,
tracking=True,
help=
"A track's kanban state indicates special situations affecting it:\n"
" * Grey is the default situation\n"
" * Red indicates something is preventing the progress of this track\n"
" * Green indicates the track is ready to be pulled to the next stage")
# speaker
partner_id = fields.Many2one('res.partner', 'Speaker')
partner_name = fields.Char(string='Name',
compute='_compute_partner_name',
readonly=False,
store=True,
tracking=10)
partner_email = fields.Char(string='Email',
compute='_compute_partner_email',
readonly=False,
store=True,
tracking=20)
partner_phone = fields.Char(string='Phone',
compute='_compute_partner_phone',
readonly=False,
store=True,
tracking=30)
partner_biography = fields.Html(string='Biography',
compute='_compute_partner_biography',
readonly=False,
store=True)
partner_function = fields.Char('Job Position',
related='partner_id.function',
compute_sudo=True,
readonly=True)
partner_company_name = fields.Char('Company Name',
related='partner_id.parent_name',
compute_sudo=True,
readonly=True)
image = fields.Image(string="Speaker Photo",
compute="_compute_speaker_image",
readonly=False,
store=True,
max_width=256,
max_height=256)
location_id = fields.Many2one('event.track.location', 'Location')
# time information
date = fields.Datetime('Track Date')
date_end = fields.Datetime('Track End Date',
compute='_compute_end_date',
store=True)
duration = fields.Float('Duration',
default=1.5,
help="Track duration in hours.")
is_track_live = fields.Boolean('Is Track Live',
compute='_compute_track_time_data',
help="Track has started and is ongoing")
is_track_soon = fields.Boolean('Is Track Soon',
compute='_compute_track_time_data',
help="Track begins soon")
is_track_today = fields.Boolean('Is Track Today',
compute='_compute_track_time_data',
help="Track begins today")
is_track_upcoming = fields.Boolean('Is Track Upcoming',
compute='_compute_track_time_data',
help="Track is not yet started")
is_track_done = fields.Boolean('Is Track Done',
compute='_compute_track_time_data',
help="Track is finished")
track_start_remaining = fields.Integer(
'Minutes before track starts',
compute='_compute_track_time_data',
help="Remaining time before track starts (seconds)")
track_start_relative = fields.Integer(
'Minutes compare to track start',
compute='_compute_track_time_data',
help="Relative time compared to track start (seconds)")
# frontend description
website_image = fields.Image(string="Website Image",
max_width=1024,
max_height=1024)
website_image_url = fields.Char(string='Image URL',
compute='_compute_website_image_url',
compute_sudo=True,
store=False)
# wishlist / visitors management
event_track_visitor_ids = fields.One2many('event.track.visitor',
'track_id',
string="Track Visitors",
groups="event.group_event_user")
is_reminder_on = fields.Boolean('Is Reminder On',
compute='_compute_is_reminder_on')
wishlist_visitor_ids = fields.Many2many(
'website.visitor',
string="Visitor Wishlist",
compute="_compute_wishlist_visitor_ids",
compute_sudo=True,
search="_search_wishlist_visitor_ids",
groups="event.group_event_user")
wishlist_visitor_count = fields.Integer(
string="# Wishlisted",
compute="_compute_wishlist_visitor_ids",
compute_sudo=True,
groups="event.group_event_user")
wishlisted_by_default = fields.Boolean(
string='Always Wishlisted',
help=
"""If set, the talk will be starred for each attendee registered to the event. The attendee won't be able to un-star this talk."""
)
# Call to action
website_cta = fields.Boolean('Magic Button')
website_cta_title = fields.Char('Button Title')
website_cta_url = fields.Char('Button Target URL')
website_cta_delay = fields.Integer('Button appears')
# time information for CTA
is_website_cta_live = fields.Boolean('Is CTA Live',
compute='_compute_cta_time_data',
help="CTA button is available")
website_cta_start_remaining = fields.Integer(
'Minutes before CTA starts',
compute='_compute_cta_time_data',
help="Remaining time before CTA starts (seconds)")
@api.depends('name')
def _compute_website_url(self):
super(Track, self)._compute_website_url()
for track in self:
if track.id:
track.website_url = '/event/%s/track/%s' % (slug(
track.event_id), slug(track))
# SPEAKER
@api.depends('partner_id')
def _compute_partner_name(self):
for track in self:
if not track.partner_name or track.partner_id:
track.partner_name = track.partner_id.name
@api.depends('partner_id')
def _compute_partner_email(self):
for track in self:
if not track.partner_email or track.partner_id:
track.partner_email = track.partner_id.email
@api.depends('partner_id')
def _compute_partner_phone(self):
for track in self:
if not track.partner_phone or track.partner_id:
track.partner_phone = track.partner_id.phone
@api.depends('partner_id')
def _compute_partner_biography(self):
for track in self:
if not track.partner_biography:
track.partner_biography = track.partner_id.website_description
elif track.partner_id and is_html_empty(track.partner_biography) and \
not is_html_empty(track.partner_id.website_description):
track.partner_biography = track.partner_id.website_description
@api.depends('partner_id')
def _compute_speaker_image(self):
for track in self:
if not track.image:
track.image = track.partner_id.image_256
# TIME
@api.depends('date', 'duration')
def _compute_end_date(self):
for track in self:
if track.date:
delta = timedelta(minutes=60 * track.duration)
track.date_end = track.date + delta
else:
track.date_end = False
# FRONTEND DESCRIPTION
@api.depends('image', 'partner_id.image_256')
def _compute_website_image_url(self):
for track in self:
if track.website_image:
track.website_image_url = self.env['website'].image_url(
track, 'website_image', size=1024)
else:
track.website_image_url = '/website_event_track/static/src/img/event_track_default_%d.jpeg' % (
track.id % 2)
# WISHLIST / VISITOR MANAGEMENT
@api.depends('wishlisted_by_default', 'event_track_visitor_ids.visitor_id',
'event_track_visitor_ids.partner_id',
'event_track_visitor_ids.is_wishlisted',
'event_track_visitor_ids.is_blacklisted')
@api.depends_context('uid')
def _compute_is_reminder_on(self):
current_visitor = self.env[
'website.visitor']._get_visitor_from_request(force_create=False)
if self.env.user._is_public() and not current_visitor:
for track in self:
track.is_reminder_on = track.wishlisted_by_default
else:
if self.env.user._is_public():
domain = [('visitor_id', '=', current_visitor.id)]
elif current_visitor:
domain = [
'|', ('partner_id', '=', self.env.user.partner_id.id),
('visitor_id', '=', current_visitor.id)
]
else:
domain = [('partner_id', '=', self.env.user.partner_id.id)]
event_track_visitors = self.env['event.track.visitor'].sudo(
).search_read(
expression.AND([domain, [('track_id', 'in', self.ids)]]),
fields=['track_id', 'is_wishlisted', 'is_blacklisted'])
wishlist_map = {
track_visitor['track_id'][0]: {
'is_wishlisted': track_visitor['is_wishlisted'],
'is_blacklisted': track_visitor['is_blacklisted']
}
for track_visitor in event_track_visitors
}
for track in self:
if wishlist_map.get(track.id):
track.is_reminder_on = wishlist_map.get(
track.id)['is_wishlisted'] or (
track.wishlisted_by_default
and not wishlist_map[track.id]['is_blacklisted'])
else:
track.is_reminder_on = track.wishlisted_by_default
@api.depends('event_track_visitor_ids.visitor_id',
'event_track_visitor_ids.is_wishlisted')
def _compute_wishlist_visitor_ids(self):
results = self.env['event.track.visitor'].read_group(
[('track_id', 'in', self.ids), ('is_wishlisted', '=', True)],
['track_id', 'visitor_id:array_agg'], ['track_id'])
visitor_ids_map = {
result['track_id'][0]: result['visitor_id']
for result in results
}
for track in self:
track.wishlist_visitor_ids = visitor_ids_map.get(track.id, [])
track.wishlist_visitor_count = len(
visitor_ids_map.get(track.id, []))
def _search_wishlist_visitor_ids(self, operator, operand):
if operator == "not in":
raise NotImplementedError(
"Unsupported 'Not In' operation on track wishlist visitors")
track_visitors = self.env['event.track.visitor'].sudo().search([
('visitor_id', operator, operand), ('is_wishlisted', '=', True)
])
return [('id', 'in', track_visitors.track_id.ids)]
# TIME
@api.depends('date', 'date_end')
def _compute_track_time_data(self):
""" Compute start and remaining time for track itself. Do everything in
UTC as we compute only time deltas here. """
now_utc = utc.localize(fields.Datetime.now().replace(microsecond=0))
for track in self:
if not track.date:
track.is_track_live = track.is_track_soon = track.is_track_today = track.is_track_upcoming = track.is_track_done = False
track.track_start_relative = track.track_start_remaining = 0
continue
date_begin_utc = utc.localize(track.date, is_dst=False)
date_end_utc = utc.localize(track.date_end, is_dst=False)
track.is_track_live = date_begin_utc <= now_utc < date_end_utc
track.is_track_soon = (date_begin_utc - now_utc).total_seconds(
) < 30 * 60 if date_begin_utc > now_utc else False
track.is_track_today = date_begin_utc.date() == now_utc.date()
track.is_track_upcoming = date_begin_utc > now_utc
track.is_track_done = date_end_utc <= now_utc
if date_begin_utc >= now_utc:
track.track_start_relative = int(
(date_begin_utc - now_utc).total_seconds())
track.track_start_remaining = track.track_start_relative
else:
track.track_start_relative = int(
(now_utc - date_begin_utc).total_seconds())
track.track_start_remaining = 0
@api.depends('date', 'date_end', 'website_cta', 'website_cta_delay')
def _compute_cta_time_data(self):
""" Compute start and remaining time for track itself. Do everything in
UTC as we compute only time deltas here. """
now_utc = utc.localize(fields.Datetime.now().replace(microsecond=0))
for track in self:
if not track.website_cta:
track.is_website_cta_live = track.website_cta_start_remaining = False
continue
date_begin_utc = utc.localize(
track.date,
is_dst=False) + timedelta(minutes=track.website_cta_delay or 0)
date_end_utc = utc.localize(track.date_end, is_dst=False)
track.is_website_cta_live = date_begin_utc <= now_utc <= date_end_utc
if date_begin_utc >= now_utc:
td = date_begin_utc - now_utc
track.website_cta_start_remaining = int(td.total_seconds())
else:
track.website_cta_start_remaining = 0
# ------------------------------------------------------------
# CRUD
# ------------------------------------------------------------
@api.model_create_multi
def create(self, vals_list):
for values in vals_list:
if values.get('website_cta_url'):
values['website_cta_url'] = self.env[
'res.partner']._clean_website(values['website_cta_url'])
tracks = super(Track, self).create(vals_list)
for track in tracks:
email_values = {} if self.env.user.email else {
'email_from': self.env.company.catchall_formatted
}
track.event_id.message_post_with_view(
'website_event_track.event_track_template_new',
values={'track': track},
subject=track.name,
subtype_id=self.env.ref(
'website_event_track.mt_event_track').id,
**email_values,
)
track._synchronize_with_stage(track.stage_id)
return tracks
def write(self, vals):
if vals.get('website_cta_url'):
vals['website_cta_url'] = self.env['res.partner']._clean_website(
vals['website_cta_url'])
if 'stage_id' in vals and 'kanban_state' not in vals:
vals['kanban_state'] = 'normal'
if vals.get('stage_id'):
stage = self.env['event.track.stage'].browse(vals['stage_id'])
self._synchronize_with_stage(stage)
res = super(Track, self).write(vals)
if vals.get('partner_id'):
self.message_subscribe([vals['partner_id']])
return res
@api.model
def _read_group_stage_ids(self, stages, domain, order):
""" Always display all stages """
return stages.search([], order=order)
def _synchronize_with_stage(self, stage):
if stage.is_done:
self.is_published = True
elif stage.is_cancel:
self.is_published = False
# ------------------------------------------------------------
# MESSAGING
# ------------------------------------------------------------
def _track_template(self, changes):
res = super(Track, self)._track_template(changes)
track = self[0]
if 'stage_id' in changes and track.stage_id.mail_template_id:
res['stage_id'] = (track.stage_id.mail_template_id, {
'composition_mode':
'comment',
'auto_delete_message':
True,
'subtype_id':
self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
'email_layout_xmlid':
'mail.mail_notification_light'
})
return res
def _track_subtype(self, init_values):
self.ensure_one()
if 'kanban_state' in init_values and self.kanban_state == 'blocked':
return self.env.ref('website_event_track.mt_track_blocked')
elif 'kanban_state' in init_values and self.kanban_state == 'done':
return self.env.ref('website_event_track.mt_track_ready')
return super(Track, self)._track_subtype(init_values)
def _message_get_suggested_recipients(self):
recipients = super(Track, self)._message_get_suggested_recipients()
for track in self:
if track.partner_email and track.partner_email != track.partner_id.email:
track._message_add_suggested_recipient(
recipients,
email=track.partner_email,
reason=_('Speaker Email'))
return recipients
def _message_post_after_hook(self, message, msg_vals):
if self.partner_email and not self.partner_id:
# we consider that posting a message with a specified recipient (not a follower, a specific one)
# on a document without customer means that it was created through the chatter using
# suggested recipients. This heuristic allows to avoid ugly hacks in JS.
new_partner = message.partner_ids.filtered(
lambda partner: partner.email == self.partner_email)
if new_partner:
self.search([
('partner_id', '=', False),
('partner_email', '=', new_partner.email),
('stage_id.is_cancel', '=', False),
]).write({'partner_id': new_partner.id})
return super(Track, self)._message_post_after_hook(message, msg_vals)
# ------------------------------------------------------------
# ACTION
# ------------------------------------------------------------
def open_track_speakers_list(self):
return {
'name': _('Speakers'),
'domain': [('id', 'in', self.mapped('partner_id').ids)],
'view_mode': 'kanban,form',
'res_model': 'res.partner',
'view_id': False,
'type': 'ir.actions.act_window',
}
def get_backend_menu_id(self):
return self.env.ref('event.event_main_menu').id
# ------------------------------------------------------------
# TOOLS
# ------------------------------------------------------------
def _get_event_track_visitors(self, force_create=False):
self.ensure_one()
force_visitor_create = self.env.user._is_public()
visitor_sudo = self.env['website.visitor']._get_visitor_from_request(
force_create=force_visitor_create)
if visitor_sudo:
visitor_sudo._update_visitor_last_visit()
if self.env.user._is_public():
domain = [('visitor_id', '=', visitor_sudo.id)]
elif visitor_sudo:
domain = [
'|', ('partner_id', '=', self.env.user.partner_id.id),
('visitor_id', '=', visitor_sudo.id)
]
else:
domain = [('partner_id', '=', self.env.user.partner_id.id)]
track_visitors = self.env['event.track.visitor'].sudo().search(
expression.AND([domain, [('track_id', 'in', self.ids)]]))
missing = self - track_visitors.track_id
if missing and force_create:
track_visitors += self.env['event.track.visitor'].sudo().create([{
'visitor_id':
visitor_sudo.id,
'partner_id':
self.env.user.partner_id.id
if not self.env.user._is_public() else False,
'track_id':
track.id,
} for track in missing])
return track_visitors
def _get_track_suggestions(self, restrict_domain=None, limit=None):
""" Returns the next tracks suggested after going to the current one
given by self. Tracks always belong to the same event.
Heuristic is
* live first;
* then ordered by start date, finished being sent to the end;
* wishlisted (manually or by default);
* tag matching with current track;
* location matching with current track;
* finally a random to have an "equivalent wave" randomly given;
:param restrict_domain: an additional domain to restrict candidates;
:param limit: number of tracks to return;
"""
self.ensure_one()
base_domain = [
'&',
('event_id', '=', self.event_id.id),
('id', '!=', self.id),
]
if restrict_domain:
base_domain = expression.AND([base_domain, restrict_domain])
track_candidates = self.search(base_domain,
limit=None,
order='date asc')
if not track_candidates:
return track_candidates
track_candidates = track_candidates.sorted(
lambda track: (
track.is_published,
track.track_start_remaining ==
0 # First get the tracks that started less than 10 minutes ago ...
and track.track_start_relative <
(10 * 60) and not track.is_track_done, # ... AND not finished
track.track_start_remaining >
0, # Then the one that will begin later (the sooner come first)
-1 * track.track_start_remaining,
track.is_reminder_on,
not track.wishlisted_by_default,
len(track.tag_ids & self.tag_ids),
track.location_id == self.location_id,
randint(0, 20),
),
reverse=True)
return track_candidates[:limit]
class ProductProduct(models.Model):
_name = "product.product"
_description = "Product"
_inherits = {'product.template': 'product_tmpl_id'}
_inherit = ['mail.thread', 'mail.activity.mixin']
_order = 'default_code, name, id'
# price: total price, context dependent (partner, pricelist, quantity)
price = fields.Float('Price',
compute='_compute_product_price',
digits='Product Price',
inverse='_set_product_price')
# price_extra: catalog extra value only, sum of variant extra attributes
price_extra = fields.Float(
'Variant Price Extra',
compute='_compute_product_price_extra',
digits='Product Price',
help="This is the sum of the extra price of all attributes")
# lst_price: catalog value + extra, context dependent (uom)
lst_price = fields.Float(
'Public Price',
compute='_compute_product_lst_price',
digits='Product Price',
inverse='_set_product_lst_price',
help=
"The sale price is managed from the product template. Click on the 'Configure Variants' button to set the extra attribute prices."
)
default_code = fields.Char('Internal Reference', index=True)
code = fields.Char('Reference', compute='_compute_product_code')
partner_ref = fields.Char('Customer Ref', compute='_compute_partner_ref')
active = fields.Boolean(
'Active',
default=True,
help=
"If unchecked, it will allow you to hide the product without removing it."
)
product_tmpl_id = fields.Many2one('product.template',
'Product Template',
auto_join=True,
index=True,
ondelete="cascade",
required=True)
barcode = fields.Char(
'Barcode',
copy=False,
help="International Article Number used for product identification.")
product_template_attribute_value_ids = fields.Many2many(
'product.template.attribute.value',
relation='product_variant_combination',
string="Attribute Values",
ondelete='restrict')
combination_indices = fields.Char(compute='_compute_combination_indices',
store=True,
index=True)
is_product_variant = fields.Boolean(compute='_compute_is_product_variant')
standard_price = fields.Float(
'Cost',
company_dependent=True,
digits='Product Price',
groups="base.group_user",
help=
"""In Standard Price & AVCO: value of the product (automatically computed in AVCO).
In FIFO: value of the last unit that left the stock (automatically computed).
Used to value the product when the purchase cost is not known (e.g. inventory adjustment).
Used to compute margins on sale orders.""")
volume = fields.Float('Volume', digits='Volume')
weight = fields.Float('Weight', digits='Stock Weight')
pricelist_item_count = fields.Integer(
"Number of price rules", compute="_compute_variant_item_count")
packaging_ids = fields.One2many(
'product.packaging',
'product_id',
'Product Packages',
help="Gives the different ways to package the same product.")
# all image fields are base64 encoded and PIL-supported
# all image_variant fields are technical and should not be displayed to the user
image_variant_1920 = fields.Image("Variant Image",
max_width=1920,
max_height=1920)
# resized fields stored (as attachment) for performance
image_variant_1024 = fields.Image("Variant Image 1024",
related="image_variant_1920",
max_width=1024,
max_height=1024,
store=True)
image_variant_512 = fields.Image("Variant Image 512",
related="image_variant_1920",
max_width=512,
max_height=512,
store=True)
image_variant_256 = fields.Image("Variant Image 256",
related="image_variant_1920",
max_width=256,
max_height=256,
store=True)
image_variant_128 = fields.Image("Variant Image 128",
related="image_variant_1920",
max_width=128,
max_height=128,
store=True)
can_image_variant_1024_be_zoomed = fields.Boolean(
"Can Variant Image 1024 be zoomed",
compute='_compute_can_image_variant_1024_be_zoomed',
store=True)
# Computed fields that are used to create a fallback to the template if
# necessary, it's recommended to display those fields to the user.
image_1920 = fields.Image("Image",
compute='_compute_image_1920',
inverse='_set_image_1920')
image_1024 = fields.Image("Image 1024", compute='_compute_image_1024')
image_512 = fields.Image("Image 512", compute='_compute_image_512')
image_256 = fields.Image("Image 256", compute='_compute_image_256')
image_128 = fields.Image("Image 128", compute='_compute_image_128')
can_image_1024_be_zoomed = fields.Boolean(
"Can Image 1024 be zoomed",
compute='_compute_can_image_1024_be_zoomed')
@api.depends('image_variant_1920', 'image_variant_1024')
def _compute_can_image_variant_1024_be_zoomed(self):
for record in self:
record.can_image_variant_1024_be_zoomed = record.image_variant_1920 and tools.is_image_size_above(
record.image_variant_1920, record.image_variant_1024)
def _compute_image_1920(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.image_1920 = record.image_variant_1920 or record.product_tmpl_id.image_1920
def _set_image_1920(self):
for record in self:
if (
# We are trying to remove an image even though it is already
# not set, remove it from the template instead.
not record.image_1920 and not record.image_variant_1920 or
# We are trying to add an image, but the template image is
# not set, write on the template instead.
record.image_1920 and not record.product_tmpl_id.image_1920
or
# There is only one variant, always write on the template.
self.search_count([
('product_tmpl_id', '=', record.product_tmpl_id.id),
('active', '=', True),
]) <= 1):
record.image_variant_1920 = False
record.product_tmpl_id.image_1920 = record.image_1920
else:
record.image_variant_1920 = record.image_1920
def _compute_image_1024(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.image_1024 = record.image_variant_1024 or record.product_tmpl_id.image_1024
def _compute_image_512(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.image_512 = record.image_variant_512 or record.product_tmpl_id.image_512
def _compute_image_256(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.image_256 = record.image_variant_256 or record.product_tmpl_id.image_256
def _compute_image_128(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.image_128 = record.image_variant_128 or record.product_tmpl_id.image_128
def _compute_can_image_1024_be_zoomed(self):
"""Get the image from the template if no image is set on the variant."""
for record in self:
record.can_image_1024_be_zoomed = record.can_image_variant_1024_be_zoomed if record.image_variant_1920 else record.product_tmpl_id.can_image_1024_be_zoomed
def init(self):
"""Ensure there is at most one active variant for each combination.
There could be no variant for a combination if using dynamic attributes.
"""
self.env.cr.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS product_product_combination_unique ON %s (product_tmpl_id, combination_indices) WHERE active is true"
% self._table)
_sql_constraints = [
('barcode_uniq', 'unique(barcode)',
"A barcode can only be assigned to one product !"),
]
def _get_invoice_policy(self):
return False
@api.depends('product_template_attribute_value_ids')
def _compute_combination_indices(self):
for product in self:
product.combination_indices = product.product_template_attribute_value_ids._ids2str(
)
def _compute_is_product_variant(self):
self.is_product_variant = True
@api.depends_context('pricelist', 'partner', 'quantity', 'uom', 'date',
'no_variant_attributes_price_extra')
def _compute_product_price(self):
prices = {}
pricelist_id_or_name = self._context.get('pricelist')
if pricelist_id_or_name:
pricelist = None
partner = self.env.context.get('partner', False)
quantity = self.env.context.get('quantity', 1.0)
# Support context pricelists specified as list, display_name or ID for compatibility
if isinstance(pricelist_id_or_name, list):
pricelist_id_or_name = pricelist_id_or_name[0]
if isinstance(pricelist_id_or_name, str):
pricelist_name_search = self.env[
'product.pricelist'].name_search(pricelist_id_or_name,
operator='=',
limit=1)
if pricelist_name_search:
pricelist = self.env['product.pricelist'].browse(
[pricelist_name_search[0][0]])
elif isinstance(pricelist_id_or_name, int):
pricelist = self.env['product.pricelist'].browse(
pricelist_id_or_name)
if pricelist:
quantities = [quantity] * len(self)
partners = [partner] * len(self)
prices = pricelist.get_products_price(self, quantities,
partners)
for product in self:
product.price = prices.get(product.id, 0.0)
def _set_product_price(self):
for product in self:
if self._context.get('uom'):
value = self.env['uom.uom'].browse(
self._context['uom'])._compute_price(
product.price, product.uom_id)
else:
value = product.price
value -= product.price_extra
product.write({'list_price': value})
def _set_product_lst_price(self):
for product in self:
if self._context.get('uom'):
value = self.env['uom.uom'].browse(
self._context['uom'])._compute_price(
product.lst_price, product.uom_id)
else:
value = product.lst_price
value -= product.price_extra
product.write({'list_price': value})
def _compute_product_price_extra(self):
for product in self:
product.price_extra = sum(
product.product_template_attribute_value_ids.mapped(
'price_extra'))
@api.depends('list_price', 'price_extra')
@api.depends_context('uom')
def _compute_product_lst_price(self):
to_uom = None
if 'uom' in self._context:
to_uom = self.env['uom.uom'].browse(self._context['uom'])
for product in self:
if to_uom:
list_price = product.uom_id._compute_price(
product.list_price, to_uom)
else:
list_price = product.list_price
product.lst_price = list_price + product.price_extra
@api.depends_context('partner_id')
def _compute_product_code(self):
for product in self:
for supplier_info in product.seller_ids:
if supplier_info.name.id == product._context.get('partner_id'):
product.code = supplier_info.product_code or product.default_code
break
else:
product.code = product.default_code
@api.depends_context('partner_id')
def _compute_partner_ref(self):
for product in self:
for supplier_info in product.seller_ids:
if supplier_info.name.id == product._context.get('partner_id'):
product_name = supplier_info.product_name or product.default_code or product.name
product.partner_ref = '%s%s' % (product.code
and '[%s] ' % product.code
or '', product_name)
break
else:
product.partner_ref = product.display_name
def _compute_variant_item_count(self):
for product in self:
domain = [
'|', '&', ('product_tmpl_id', '=', product.product_tmpl_id.id),
('applied_on', '=', '1_product'), '&',
('product_id', '=', product.id),
('applied_on', '=', '0_product_variant')
]
product.pricelist_item_count = self.env[
'product.pricelist.item'].search_count(domain)
@api.onchange('uom_id')
def _onchange_uom_id(self):
if self.uom_id:
self.uom_po_id = self.uom_id.id
@api.onchange('uom_po_id')
def _onchange_uom(self):
if self.uom_id and self.uom_po_id and self.uom_id.category_id != self.uom_po_id.category_id:
self.uom_po_id = self.uom_id
@api.model_create_multi
def create(self, vals_list):
products = super(
ProductProduct,
self.with_context(create_product_product=True)).create(vals_list)
# `_get_variant_id_for_combination` depends on existing variants
self.clear_caches()
return products
def write(self, values):
res = super(ProductProduct, self).write(values)
if 'product_template_attribute_value_ids' in values:
# `_get_variant_id_for_combination` depends on `product_template_attribute_value_ids`
self.clear_caches()
if 'active' in values:
# prefetched o2m have to be reloaded (because of active_test)
# (eg. product.template: product_variant_ids)
self.flush()
self.invalidate_cache()
# `_get_first_possible_variant_id` depends on variants active state
self.clear_caches()
return res
def unlink(self):
unlink_products = self.env['product.product']
unlink_templates = self.env['product.template']
for product in self:
# If there is an image set on the variant and no image set on the
# template, move the image to the template.
if product.image_variant_1920 and not product.product_tmpl_id.image_1920:
product.product_tmpl_id.image_1920 = product.image_variant_1920
# Check if product still exists, in case it has been unlinked by unlinking its template
if not product.exists():
continue
# Check if the product is last product of this template...
other_products = self.search([('product_tmpl_id', '=',
product.product_tmpl_id.id),
('id', '!=', product.id)])
# ... and do not delete product template if it's configured to be created "on demand"
if not other_products and not product.product_tmpl_id.has_dynamic_attributes(
):
unlink_templates |= product.product_tmpl_id
unlink_products |= product
res = super(ProductProduct, unlink_products).unlink()
# delete templates after calling super, as deleting template could lead to deleting
# products due to ondelete='cascade'
unlink_templates.unlink()
# `_get_variant_id_for_combination` depends on existing variants
self.clear_caches()
return res
def _filter_to_unlink(self, check_access=True):
return self
def _unlink_or_archive(self, check_access=True):
"""Unlink or archive products.
Try in batch as much as possible because it is much faster.
Use dichotomy when an exception occurs.
"""
# Avoid access errors in case the products is shared amongst companies
# but the underlying objects are not. If unlink fails because of an
# AccessError (e.g. while recomputing fields), the 'write' call will
# fail as well for the same reason since the field has been set to
# recompute.
if check_access:
self.check_access_rights('unlink')
self.check_access_rule('unlink')
self.check_access_rights('write')
self.check_access_rule('write')
self = self.sudo()
to_unlink = self._filter_to_unlink()
to_archive = self - to_unlink
to_archive.write({'active': False})
self = to_unlink
try:
with self.env.cr.savepoint(), tools.mute_logger('flectra.sql_db'):
self.unlink()
except Exception:
# We catch all kind of exceptions to be sure that the operation
# doesn't fail.
if len(self) > 1:
self[:len(self) // 2]._unlink_or_archive(check_access=False)
self[len(self) // 2:]._unlink_or_archive(check_access=False)
else:
if self.active:
# Note: this can still fail if something is preventing
# from archiving.
# This is the case from existing stock reordering rules.
self.write({'active': False})
@api.returns('self', lambda value: value.id)
def copy(self, default=None):
"""Variants are generated depending on the configuration of attributes
and values on the template, so copying them does not make sense.
For convenience the template is copied instead and its first variant is
returned.
"""
return self.product_tmpl_id.copy(default=default).product_variant_id
@api.model
def _search(self,
args,
offset=0,
limit=None,
order=None,
count=False,
access_rights_uid=None):
# TDE FIXME: strange
if self._context.get('search_default_categ_id'):
args.append((('categ_id', 'child_of',
self._context['search_default_categ_id'])))
return super(ProductProduct,
self)._search(args,
offset=offset,
limit=limit,
order=order,
count=count,
access_rights_uid=access_rights_uid)
@api.depends_context('display_default_code')
def _compute_display_name(self):
# `display_name` is calling `name_get()`` which is overidden on product
# to depend on `display_default_code`
return super()._compute_display_name()
def name_get(self):
# TDE: this could be cleaned a bit I think
def _name_get(d):
name = d.get('name', '')
code = self._context.get('display_default_code', True) and d.get(
'default_code', False) or False
if code:
name = '[%s] %s' % (code, name)
return (d['id'], name)
partner_id = self._context.get('partner_id')
if partner_id:
partner_ids = [
partner_id, self.env['res.partner'].browse(
partner_id).commercial_partner_id.id
]
else:
partner_ids = []
company_id = self.env.context.get('company_id')
# all user don't have access to seller and partner
# check access and use superuser
self.check_access_rights("read")
self.check_access_rule("read")
result = []
# Prefetch the fields used by the `name_get`, so `browse` doesn't fetch other fields
# Use `load=False` to not call `name_get` for the `product_tmpl_id`
self.sudo().read(['name', 'default_code', 'product_tmpl_id'],
load=False)
product_template_ids = self.sudo().mapped('product_tmpl_id').ids
if partner_ids:
supplier_info = self.env['product.supplierinfo'].sudo().search([
('product_tmpl_id', 'in', product_template_ids),
('name', 'in', partner_ids),
])
# Prefetch the fields used by the `name_get`, so `browse` doesn't fetch other fields
# Use `load=False` to not call `name_get` for the `product_tmpl_id` and `product_id`
supplier_info.sudo().read([
'product_tmpl_id', 'product_id', 'product_name', 'product_code'
],
load=False)
supplier_info_by_template = {}
for r in supplier_info:
supplier_info_by_template.setdefault(r.product_tmpl_id,
[]).append(r)
for product in self.sudo():
variant = product.product_template_attribute_value_ids._get_combination_name(
)
name = variant and "%s (%s)" % (product.name,
variant) or product.name
sellers = []
if partner_ids:
product_supplier_info = supplier_info_by_template.get(
product.product_tmpl_id, [])
sellers = [
x for x in product_supplier_info
if x.product_id and x.product_id == product
]
if not sellers:
sellers = [
x for x in product_supplier_info if not x.product_id
]
# Filter out sellers based on the company. This is done afterwards for a better
# code readability. At this point, only a few sellers should remain, so it should
# not be a performance issue.
if company_id:
sellers = [
x for x in sellers
if x.company_id.id in [company_id, False]
]
if sellers:
for s in sellers:
seller_variant = s.product_name and (
variant and "%s (%s)" %
(s.product_name, variant) or s.product_name) or False
mydict = {
'id': product.id,
'name': seller_variant or name,
'default_code': s.product_code or product.default_code,
}
temp = _name_get(mydict)
if temp not in result:
result.append(temp)
else:
mydict = {
'id': product.id,
'name': name,
'default_code': product.default_code,
}
result.append(_name_get(mydict))
return result
@api.model
def _name_search(self,
name,
args=None,
operator='ilike',
limit=100,
name_get_uid=None):
if not args:
args = []
if name:
positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
product_ids = []
if operator in positive_operators:
product_ids = list(
self._search([('default_code', '=', name)] + args,
limit=limit,
access_rights_uid=name_get_uid))
if not product_ids:
product_ids = list(
self._search([('barcode', '=', name)] + args,
limit=limit,
access_rights_uid=name_get_uid))
if not product_ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
# Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
# on a database with thousands of matching products, due to the huge merge+unique needed for the
# OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
# Performing a quick memory merge of ids in Python will give much better performance
product_ids = list(
self._search(args + [('default_code', operator, name)],
limit=limit))
if not limit or len(product_ids) < limit:
# we may underrun the limit because of dupes in the results, that's fine
limit2 = (limit - len(product_ids)) if limit else False
product2_ids = self._search(
args + [('name', operator, name),
('id', 'not in', product_ids)],
limit=limit2,
access_rights_uid=name_get_uid)
product_ids.extend(product2_ids)
elif not product_ids and operator in expression.NEGATIVE_TERM_OPERATORS:
domain = expression.OR([
[
'&', ('default_code', operator, name),
('name', operator, name)
],
[
'&', ('default_code', '=', False),
('name', operator, name)
],
])
domain = expression.AND([args, domain])
product_ids = list(
self._search(domain,
limit=limit,
access_rights_uid=name_get_uid))
if not product_ids and operator in positive_operators:
ptrn = re.compile('(\[(.*?)\])')
res = ptrn.search(name)
if res:
product_ids = list(
self._search([('default_code', '=', res.group(2))] +
args,
limit=limit,
access_rights_uid=name_get_uid))
# still no results, partner in context: search on supplier info as last hope to find something
if not product_ids and self._context.get('partner_id'):
suppliers_ids = self.env['product.supplierinfo']._search(
[('name', '=', self._context.get('partner_id')), '|',
('product_code', operator, name),
('product_name', operator, name)],
access_rights_uid=name_get_uid)
if suppliers_ids:
product_ids = self._search(
[('product_tmpl_id.seller_ids', 'in', suppliers_ids)],
limit=limit,
access_rights_uid=name_get_uid)
else:
product_ids = self._search(args,
limit=limit,
access_rights_uid=name_get_uid)
return product_ids
@api.model
def view_header_get(self, view_id, view_type):
if self._context.get('categ_id'):
return _(
'Products: %(category)s',
category=self.env['product.category'].browse(
self.env.context['categ_id']).name,
)
return super().view_header_get(view_id, view_type)
def open_pricelist_rules(self):
self.ensure_one()
domain = [
'|', '&', ('product_tmpl_id', '=', self.product_tmpl_id.id),
('applied_on', '=', '1_product'), '&',
('product_id', '=', self.id),
('applied_on', '=', '0_product_variant')
]
return {
'name':
_('Price Rules'),
'view_mode':
'tree,form',
'views': [(self.env.ref(
'product.product_pricelist_item_tree_view_from_product').id,
'tree'), (False, 'form')],
'res_model':
'product.pricelist.item',
'type':
'ir.actions.act_window',
'target':
'current',
'domain':
domain,
'context': {
'default_product_id': self.id,
'default_applied_on': '0_product_variant',
}
}
def open_product_template(self):
""" Utility method used to add an "Open Template" button in product views """
self.ensure_one()
return {
'type': 'ir.actions.act_window',
'res_model': 'product.template',
'view_mode': 'form',
'res_id': self.product_tmpl_id.id,
'target': 'new'
}
def _prepare_sellers(self, params=False):
return self.seller_ids.filtered(lambda s: s.name.active).sorted(
lambda s: (s.sequence, -s.min_qty, s.price, s.id))
def _select_seller(self,
partner_id=False,
quantity=0.0,
date=None,
uom_id=False,
params=False):
self.ensure_one()
if date is None:
date = fields.Date.context_today(self)
precision = self.env['decimal.precision'].precision_get(
'Product Unit of Measure')
res = self.env['product.supplierinfo']
sellers = self._prepare_sellers(params)
sellers = sellers.filtered(lambda s: not s.company_id or s.company_id.
id == self.env.company.id)
for seller in sellers:
# Set quantity in UoM of seller
quantity_uom_seller = quantity
if quantity_uom_seller and uom_id and uom_id != seller.product_uom:
quantity_uom_seller = uom_id._compute_quantity(
quantity_uom_seller, seller.product_uom)
if seller.date_start and seller.date_start > date:
continue
if seller.date_end and seller.date_end < date:
continue
if partner_id and seller.name not in [
partner_id, partner_id.parent_id
]:
continue
if float_compare(quantity_uom_seller,
seller.min_qty,
precision_digits=precision) == -1:
continue
if seller.product_id and seller.product_id != self:
continue
if not res or res.name == seller.name:
res |= seller
return res.sorted('price')[:1]
def price_compute(self,
price_type,
uom=False,
currency=False,
company=None):
# TDE FIXME: delegate to template or not ? fields are reencoded here ...
# compatibility about context keys used a bit everywhere in the code
if not uom and self._context.get('uom'):
uom = self.env['uom.uom'].browse(self._context['uom'])
if not currency and self._context.get('currency'):
currency = self.env['res.currency'].browse(
self._context['currency'])
products = self
if price_type == 'standard_price':
# standard_price field can only be seen by users in base.group_user
# Thus, in order to compute the sale price from the cost for users not in this group
# We fetch the standard price as the superuser
products = self.with_company(company or self.env.company).sudo()
prices = dict.fromkeys(self.ids, 0.0)
for product in products:
prices[product.id] = product[price_type] or 0.0
if price_type == 'list_price':
prices[product.id] += product.price_extra
# we need to add the price from the attributes that do not generate variants
# (see field product.attribute create_variant)
if self._context.get('no_variant_attributes_price_extra'):
# we have a list of price_extra that comes from the attribute values, we need to sum all that
prices[product.id] += sum(
self._context.get('no_variant_attributes_price_extra'))
if uom:
prices[product.id] = product.uom_id._compute_price(
prices[product.id], uom)
# Convert from current user company currency to asked one
# This is right cause a field cannot be in more than one currency
if currency:
prices[product.id] = product.currency_id._convert(
prices[product.id], currency, product.company_id,
fields.Date.today())
return prices
@api.model
def get_empty_list_help(self, help):
self = self.with_context(empty_list_help_document_name=_("product"), )
return super(ProductProduct, self).get_empty_list_help(help)
def get_product_multiline_description_sale(self):
""" Compute a multiline description of this product, in the context of sales
(do not use for purchases or other display reasons that don't intend to use "description_sale").
It will often be used as the default description of a sale order line referencing this product.
"""
name = self.display_name
if self.description_sale:
name += '\n' + self.description_sale
return name
def _is_variant_possible(self, parent_combination=None):
"""Return whether the variant is possible based on its own combination,
and optionally a parent combination.
See `_is_combination_possible` for more information.
:param parent_combination: combination from which `self` is an
optional or accessory product.
:type parent_combination: recordset `product.template.attribute.value`
:return: ẁhether the variant is possible based on its own combination
:rtype: bool
"""
self.ensure_one()
return self.product_tmpl_id._is_combination_possible(
self.product_template_attribute_value_ids,
parent_combination=parent_combination,
ignore_no_variant=True)
def toggle_active(self):
""" Archiving related product.template if there is not any more active product.product
(and vice versa, unarchiving the related product template if there is now an active product.product) """
result = super().toggle_active()
# We deactivate product templates which are active with no active variants.
tmpl_to_deactivate = self.filtered(lambda product: (
product.product_tmpl_id.active and not product.product_tmpl_id.
product_variant_ids)).mapped('product_tmpl_id')
# We activate product templates which are inactive with active variants.
tmpl_to_activate = self.filtered(lambda product: (
not product.product_tmpl_id.active and product.product_tmpl_id.
product_variant_ids)).mapped('product_tmpl_id')
(tmpl_to_deactivate + tmpl_to_activate).toggle_active()
return result
class ImLivechatChannel(models.Model):
""" Livechat Channel
Define a communication channel, which can be accessed with 'script_external' (script tag to put on
external website), 'script_internal' (code to be integrated with flectra website) or via 'web_page' link.
It provides rating tools, and access rules for anonymous people.
"""
_name = 'im_livechat.channel'
_inherit = ['rating.parent.mixin']
_description = 'Livechat Channel'
_rating_satisfaction_days = 7 # include only last 7 days to compute satisfaction
def _default_image(self):
image_path = modules.get_module_resource('im_livechat',
'static/src/img',
'default.png')
return base64.b64encode(open(image_path, 'rb').read())
def _default_user_ids(self):
return [(6, 0, [self._uid])]
# attribute fields
name = fields.Char('Name', required=True, help="The name of the channel")
button_text = fields.Char(
'Text of the Button',
default='Have a Question? Chat with us.',
help="Default text displayed on the Livechat Support Button")
default_message = fields.Char(
'Welcome Message',
default='How may I help you?',
help=
"This is an automated 'welcome' message that your visitor will see when they initiate a new conversation."
)
input_placeholder = fields.Char(
'Chat Input Placeholder',
help='Text that prompts the user to initiate the chat.')
header_background_color = fields.Char(
default="#009EFB",
help="Default background color of the channel header once open")
title_color = fields.Char(
default="#FFFFFF", help="Default title color of the channel once open")
button_background_color = fields.Char(
default="#878787",
help="Default background color of the Livechat button")
button_text_color = fields.Char(
default="#FFFFFF", help="Default text color of the Livechat button")
# computed fields
web_page = fields.Char(
'Web Page',
compute='_compute_web_page_link',
store=False,
readonly=True,
help=
"URL to a static page where you client can discuss with the operator of the channel."
)
are_you_inside = fields.Boolean(string='Are you inside the matrix?',
compute='_are_you_inside',
store=False,
readonly=True)
script_external = fields.Text('Script (external)',
compute='_compute_script_external',
store=False,
readonly=True)
nbr_channel = fields.Integer('Number of conversation',
compute='_compute_nbr_channel',
store=False,
readonly=True)
image_128 = fields.Image("Image",
max_width=128,
max_height=128,
default=_default_image)
# relationnal fields
user_ids = fields.Many2many('res.users',
'im_livechat_channel_im_user',
'channel_id',
'user_id',
string='Operators',
default=_default_user_ids)
channel_ids = fields.One2many('mail.channel', 'livechat_channel_id',
'Sessions')
rule_ids = fields.One2many('im_livechat.channel.rule', 'channel_id',
'Rules')
def _are_you_inside(self):
for channel in self:
channel.are_you_inside = bool(
self.env.uid in [u.id for u in channel.user_ids])
def _compute_script_external(self):
view = self.env['ir.model.data'].get_object('im_livechat',
'external_loader')
values = {
"url":
self.env['ir.config_parameter'].sudo().get_param('web.base.url'),
"dbname": self._cr.dbname,
}
for record in self:
values["channel_id"] = record.id
record.script_external = view._render(
values) if record.id else False
def _compute_web_page_link(self):
base_url = self.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
for record in self:
record.web_page = "%s/im_livechat/support/%i" % (
base_url, record.id) if record.id else False
@api.depends('channel_ids')
def _compute_nbr_channel(self):
data = self.env['mail.channel'].read_group(
[('livechat_channel_id', 'in', self._ids),
('channel_message_ids', '!=', False)], ['__count'],
['livechat_channel_id'],
lazy=False)
channel_count = {
x['livechat_channel_id'][0]: x['__count']
for x in data
}
for record in self:
record.nbr_channel = channel_count.get(record.id, 0)
# --------------------------
# Action Methods
# --------------------------
def action_join(self):
self.ensure_one()
return self.write({'user_ids': [(4, self._uid)]})
def action_quit(self):
self.ensure_one()
return self.write({'user_ids': [(3, self._uid)]})
def action_view_rating(self):
""" Action to display the rating relative to the channel, so all rating of the
sessions of the current channel
:returns : the ir.action 'action_view_rating' with the correct domain
"""
self.ensure_one()
action = self.env['ir.actions.act_window']._for_xml_id(
'im_livechat.rating_rating_action_view_livechat_rating')
action['domain'] = [('parent_res_id', '=', self.id),
('parent_res_model', '=', 'im_livechat.channel')]
return action
# --------------------------
# Channel Methods
# --------------------------
def _get_available_users(self):
""" get available user of a given channel
:retuns : return the res.users having their im_status online
"""
self.ensure_one()
return self.user_ids.filtered(lambda user: user.im_status == 'online')
def _get_livechat_mail_channel_vals(self,
anonymous_name,
operator,
user_id=None,
country_id=None):
# partner to add to the mail.channel
operator_partner_id = operator.partner_id.id
channel_partner_to_add = [(4, operator_partner_id)]
visitor_user = False
if user_id:
visitor_user = self.env['res.users'].browse(user_id)
if visitor_user and visitor_user.active: # valid session user (not public)
channel_partner_to_add.append((4, visitor_user.partner_id.id))
return {
'channel_partner_ids':
channel_partner_to_add,
'livechat_active':
True,
'livechat_operator_id':
operator_partner_id,
'livechat_channel_id':
self.id,
'anonymous_name':
False if user_id else anonymous_name,
'country_id':
country_id,
'channel_type':
'livechat',
'name':
' '.join([
visitor_user.display_name if visitor_user else anonymous_name,
operator.livechat_username
if operator.livechat_username else operator.name
]),
'public':
'private',
'email_send':
False,
}
def _open_livechat_mail_channel(self,
anonymous_name,
previous_operator_id=None,
user_id=None,
country_id=None):
""" Return a mail.channel given a livechat channel. It creates one with a connected operator, or return false otherwise
:param anonymous_name : the name of the anonymous person of the channel
:param previous_operator_id : partner_id.id of the previous operator that this visitor had in the past
:param user_id : the id of the logged in visitor, if any
:param country_code : the country of the anonymous person of the channel
:type anonymous_name : str
:return : channel header
:rtype : dict
If this visitor already had an operator within the last 7 days (information stored with the 'im_livechat_previous_operator_pid' cookie),
the system will first try to assign that operator if he's available (to improve user experience).
"""
self.ensure_one()
operator = False
if previous_operator_id:
available_users = self._get_available_users()
# previous_operator_id is the partner_id of the previous operator, need to convert to user
if previous_operator_id in available_users.mapped(
'partner_id').ids:
operator = next(
available_user for available_user in available_users
if available_user.partner_id.id == previous_operator_id)
if not operator:
operator = self._get_random_operator()
if not operator:
# no one available
return False
# create the session, and add the link with the given channel
mail_channel_vals = self._get_livechat_mail_channel_vals(
anonymous_name, operator, user_id=user_id, country_id=country_id)
mail_channel = self.env["mail.channel"].with_context(
mail_create_nosubscribe=False).sudo().create(mail_channel_vals)
mail_channel._broadcast([operator.partner_id.id])
return mail_channel.sudo().channel_info()[0]
def _get_random_operator(self):
""" Return a random operator from the available users of the channel that have the lowest number of active livechats.
A livechat is considered 'active' if it has at least one message within the 30 minutes.
(Some annoying conversions have to be made on the fly because this model holds 'res.users' as available operators
and the mail_channel model stores the partner_id of the randomly selected operator)
:return : user
:rtype : res.users
"""
operators = self._get_available_users()
if len(operators) == 0:
return False
self.env.cr.execute(
"""SELECT COUNT(DISTINCT c.id), c.livechat_operator_id
FROM mail_channel c
LEFT OUTER JOIN mail_message_mail_channel_rel r ON c.id = r.mail_channel_id
LEFT OUTER JOIN mail_message m ON r.mail_message_id = m.id
WHERE c.channel_type = 'livechat'
AND c.livechat_operator_id in %s
AND m.create_date > ((now() at time zone 'UTC') - interval '30 minutes')
GROUP BY c.livechat_operator_id
ORDER BY COUNT(DISTINCT c.id) asc""",
(tuple(operators.mapped('partner_id').ids), ))
active_channels = self.env.cr.dictfetchall()
# If inactive operator(s), return one of them
active_channel_operator_ids = [
active_channel['livechat_operator_id']
for active_channel in active_channels
]
inactive_operators = [
operator for operator in operators
if operator.partner_id.id not in active_channel_operator_ids
]
if inactive_operators:
return random.choice(inactive_operators)
# If no inactive operator, active_channels is not empty as len(operators) > 0 (see above).
# Get the less active operator using the active_channels first element's count (since they are sorted 'ascending')
lowest_number_of_conversations = active_channels[0]['count']
less_active_operator = random.choice([
active_channel['livechat_operator_id']
for active_channel in active_channels
if active_channel['count'] == lowest_number_of_conversations
])
# convert the selected 'partner_id' to its corresponding res.users
return next(operator for operator in operators
if operator.partner_id.id == less_active_operator)
def _get_channel_infos(self):
self.ensure_one()
return {
'header_background_color': self.header_background_color,
'button_background_color': self.button_background_color,
'title_color': self.title_color,
'button_text_color': self.button_text_color,
'button_text': self.button_text,
'input_placeholder': self.input_placeholder,
'default_message': self.default_message,
"channel_name": self.name,
"channel_id": self.id,
}
def get_livechat_info(self, username='******'):
self.ensure_one()
if username == 'Visitor':
username = _('Visitor')
info = {}
info['available'] = len(self._get_available_users()) > 0
info['server_url'] = self.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
if info['available']:
info['options'] = self._get_channel_infos()
info['options']['current_partner_id'] = self.env.user.partner_id.id
info['options']["default_username"] = username
return info
class Lang(models.Model):
_name = "res.lang"
_description = "Languages"
_order = "active desc,name"
_disallowed_datetime_patterns = list(tools.DATETIME_FORMATS_MAP)
_disallowed_datetime_patterns.remove(
'%y') # this one is in fact allowed, just not good practice
name = fields.Char(required=True)
code = fields.Char(string='Locale Code',
required=True,
help='This field is used to set/get locales for user')
iso_code = fields.Char(
string='ISO code',
help='This ISO code is the name of po files to use for translations')
url_code = fields.Char('URL Code',
required=True,
help='The Lang Code displayed in the URL')
active = fields.Boolean()
direction = fields.Selection([('ltr', 'Left-to-Right'),
('rtl', 'Right-to-Left')],
required=True,
default='ltr')
date_format = fields.Char(string='Date Format',
required=True,
default=DEFAULT_DATE_FORMAT)
time_format = fields.Char(string='Time Format',
required=True,
default=DEFAULT_TIME_FORMAT)
week_start = fields.Selection([('1', 'Monday'), ('2', 'Tuesday'),
('3', 'Wednesday'), ('4', 'Thursday'),
('5', 'Friday'), ('6', 'Saturday'),
('7', 'Sunday')],
string='First Day of Week',
required=True,
default='7')
grouping = fields.Char(
string='Separator Format',
required=True,
default='[]',
help=
"The Separator Format should be like [,n] where 0 < n :starting from Unit digit. "
"-1 will end the separation. e.g. [3,2,-1] will represent 106500 to be 1,06,500; "
"[1,2,-1] will represent it to be 106,50,0;[3] will represent it as 106,500. "
"Provided ',' as the thousand separator in each case.")
decimal_point = fields.Char(string='Decimal Separator',
required=True,
default='.',
trim=False)
thousands_sep = fields.Char(string='Thousands Separator',
default=',',
trim=False)
@api.depends('code', 'flag_image')
def _compute_field_flag_image_url(self):
for lang in self:
if lang.flag_image:
lang.flag_image_url = f"/web/image/res.lang/{lang.id}/flag_image"
else:
lang.flag_image_url = f"/base/static/img/country_flags/{lang.code.lower().rsplit('_')[-1]}.png"
flag_image = fields.Image("Image")
flag_image_url = fields.Char(compute=_compute_field_flag_image_url)
_sql_constraints = [
('name_uniq', 'unique(name)',
'The name of the language must be unique !'),
('code_uniq', 'unique(code)',
'The code of the language must be unique !'),
('url_code_uniq', 'unique(url_code)',
'The URL code of the language must be unique !'),
]
@api.constrains('active')
def _check_active(self):
# do not check during installation
if self.env.registry.ready and not self.search_count([]):
raise ValidationError(_('At least one language must be active.'))
@api.constrains('time_format', 'date_format')
def _check_format(self):
for lang in self:
for pattern in lang._disallowed_datetime_patterns:
if (lang.time_format and pattern in lang.time_format) or \
(lang.date_format and pattern in lang.date_format):
raise ValidationError(
_('Invalid date/time format directive specified. '
'Please refer to the list of allowed directives, '
'displayed when you edit a language.'))
@api.constrains('grouping')
def _check_grouping(self):
warning = _(
'The Separator Format should be like [,n] where 0 < n :starting from Unit digit. '
'-1 will end the separation. e.g. [3,2,-1] will represent 106500 to be 1,06,500;'
'[1,2,-1] will represent it to be 106,50,0;[3] will represent it as 106,500. '
'Provided as the thousand separator in each case.')
for lang in self:
try:
if any(not isinstance(x, int)
for x in json.loads(lang.grouping)):
raise ValidationError(warning)
except Exception:
raise ValidationError(warning)
def _register_hook(self):
# check that there is at least one active language
if not self.search_count([]):
_logger.error("No language is active.")
# TODO remove me after v14
def load_lang(self, lang, lang_name=None):
_logger.warning(
"Call to deprecated method load_lang, use _create_lang or _activate_lang instead"
)
language = self._activate_lang(lang) or self._create_lang(
lang, lang_name)
return language.id
def _activate_lang(self, code):
""" Activate languages
:param code: code of the language to activate
:return: the language matching 'code' activated
"""
lang = self.with_context(active_test=False).search([('code', '=', code)
])
if lang and not lang.active:
lang.active = True
return lang
def _create_lang(self, lang, lang_name=None):
""" Create the given language and make it active. """
# create the language with locale information
fail = True
iso_lang = tools.get_iso_codes(lang)
for ln in tools.get_locales(lang):
try:
locale.setlocale(locale.LC_ALL, str(ln))
fail = False
break
except locale.Error:
continue
if fail:
lc = locale.getdefaultlocale()[0]
msg = 'Unable to get information for locale %s. Information from the default locale (%s) have been used.'
_logger.warning(msg, lang, lc)
if not lang_name:
lang_name = lang
def fix_xa0(s):
"""Fix badly-encoded non-breaking space Unicode character from locale.localeconv(),
coercing to utf-8, as some platform seem to output localeconv() in their system
encoding, e.g. Windows-1252"""
if s == '\xa0':
return '\xc2\xa0'
return s
def fix_datetime_format(format):
"""Python's strftime supports only the format directives
that are available on the platform's libc, so in order to
be 100% cross-platform we map to the directives required by
the C standard (1989 version), always available on platforms
with a C standard implementation."""
# For some locales, nl_langinfo returns a D_FMT/T_FMT that contains
# unsupported '%-' patterns, e.g. for cs_CZ
format = format.replace('%-', '%')
for pattern, replacement in tools.DATETIME_FORMATS_MAP.items():
format = format.replace(pattern, replacement)
return str(format)
conv = locale.localeconv()
lang_info = {
'code': lang,
'iso_code': iso_lang,
'name': lang_name,
'active': True,
'date_format':
fix_datetime_format(locale.nl_langinfo(locale.D_FMT)),
'time_format':
fix_datetime_format(locale.nl_langinfo(locale.T_FMT)),
'decimal_point': fix_xa0(str(conv['decimal_point'])),
'thousands_sep': fix_xa0(str(conv['thousands_sep'])),
'grouping': str(conv.get('grouping', [])),
}
try:
return self.create(lang_info)
finally:
tools.resetlocale()
@api.model
def install_lang(self):
"""
This method is called from flectra/addons/base/data/res_lang_data.xml to load
some language and set it as the default for every partners. The
language is set via tools.config by the '_initialize_db' method on the
'db' object. This is a fragile solution and something else should be
found.
"""
# config['load_language'] is a comma-separated list or None
lang_code = (tools.config.get('load_language')
or 'en_US').split(',')[0]
lang = self._activate_lang(lang_code) or self._create_lang(lang_code)
IrDefault = self.env['ir.default']
default_value = IrDefault.get('res.partner', 'lang')
if default_value is None:
IrDefault.set('res.partner', 'lang', lang_code)
# set language of main company, created directly by db bootstrap SQL
partner = self.env.company.partner_id
if not partner.lang:
partner.write({'lang': lang_code})
return True
@tools.ormcache('code')
def _lang_get_id(self, code):
return self.with_context(active_test=True).search([('code', '=', code)
]).id
@tools.ormcache('url_code')
def _lang_get_code(self, url_code):
return self.with_context(active_test=True).search(
[('url_code', '=', url_code)]).code or url_code
def _lang_get(self, code):
""" Return the language using this code if it is active """
return self.browse(self._lang_get_id(code))
@tools.ormcache('self.code', 'monetary')
def _data_get(self, monetary=False):
conv = locale.localeconv()
thousands_sep = self.thousands_sep or conv[
monetary and 'mon_thousands_sep' or 'thousands_sep']
decimal_point = self.decimal_point
grouping = self.grouping
return grouping, thousands_sep, decimal_point
@api.model
@tools.ormcache()
def get_available(self):
""" Return the available languages as a list of (code, url_code, name,
active) sorted by name.
"""
langs = self.with_context(active_test=False).search([])
return langs.get_sorted()
def get_sorted(self):
return sorted([(lang.code, lang.url_code, lang.name, lang.active,
lang.flag_image_url) for lang in self],
key=itemgetter(2))
@tools.ormcache('self.id')
def _get_cached_values(self):
self.ensure_one()
return {
'id': self.id,
'code': self.code,
'url_code': self.url_code,
'name': self.name,
}
def _get_cached(self, field):
return self._get_cached_values()[field]
@api.model
@tools.ormcache('code')
def _lang_code_to_urlcode(self, code):
for c, urlc, name, *_ in self.get_available():
if c == code:
return urlc
return self._lang_get(code).url_code
@api.model
@tools.ormcache()
def get_installed(self):
""" Return the installed languages as a list of (code, name) sorted by name. """
langs = self.with_context(active_test=True).search([])
return sorted([(lang.code, lang.name) for lang in langs],
key=itemgetter(1))
def toggle_active(self):
super().toggle_active()
# Automatically load translation
active_lang = [lang.code for lang in self.filtered(lambda l: l.active)]
if active_lang:
mods = self.env['ir.module.module'].search([('state', '=',
'installed')])
mods._update_translations(active_lang)
@api.model_create_multi
def create(self, vals_list):
self.clear_caches()
for vals in vals_list:
if not vals.get('url_code'):
vals['url_code'] = vals.get('iso_code') or vals['code']
return super(Lang, self).create(vals_list)
def write(self, vals):
lang_codes = self.mapped('code')
if 'code' in vals and any(code != vals['code'] for code in lang_codes):
raise UserError(_("Language code cannot be modified."))
if vals.get('active') == False:
if self.env['res.users'].search_count([('lang', 'in', lang_codes)
]):
raise UserError(
_("Cannot deactivate a language that is currently used by users."
))
if self.env['res.partner'].search_count([('lang', 'in', lang_codes)
]):
raise UserError(
_("Cannot deactivate a language that is currently used by contacts."
))
# delete linked ir.default specifying default partner's language
self.env['ir.default'].discard_values('res.partner', 'lang',
lang_codes)
res = super(Lang, self).write(vals)
self.flush()
self.clear_caches()
return res
def unlink(self):
for language in self:
if language.code == 'en_US':
raise UserError(_("Base Language 'en_US' can not be deleted."))
ctx_lang = self._context.get('lang')
if ctx_lang and (language.code == ctx_lang):
raise UserError(
_("You cannot delete the language which is the user's preferred language."
))
if language.active:
raise UserError(
_("You cannot delete the language which is Active!\nPlease de-activate the language first."
))
self.env['ir.translation'].search([('lang', '=', language.code)
]).unlink()
self.clear_caches()
return super(Lang, self).unlink()
def format(self, percent, value, grouping=False, monetary=False):
""" Format() will return the language-specific output for float values"""
self.ensure_one()
if percent[0] != '%':
raise ValueError(
_("format() must be given exactly one %char format specifier"))
formatted = percent % value
# floats and decimal ints need special action!
if grouping:
lang_grouping, thousands_sep, decimal_point = self._data_get(
monetary)
eval_lang_grouping = ast.literal_eval(lang_grouping)
if percent[-1] in 'eEfFgG':
parts = formatted.split('.')
parts[0] = intersperse(parts[0], eval_lang_grouping,
thousands_sep)[0]
formatted = decimal_point.join(parts)
elif percent[-1] in 'diu':
formatted = intersperse(formatted, eval_lang_grouping,
thousands_sep)[0]
return formatted
class ProductImage(models.Model):
_name = 'product.image'
_description = "Product Image"
_inherit = ['image.mixin']
_order = 'sequence, id'
name = fields.Char("Name", required=True)
sequence = fields.Integer(default=10, index=True)
image_1920 = fields.Image(required=True)
product_tmpl_id = fields.Many2one('product.template',
"Product Template",
index=True,
ondelete='cascade')
product_variant_id = fields.Many2one('product.product',
"Product Variant",
index=True,
ondelete='cascade')
video_url = fields.Char('Video URL',
help='URL of a video for showcasing your product.')
embed_code = fields.Char(compute="_compute_embed_code")
can_image_1024_be_zoomed = fields.Boolean(
"Can Image 1024 be zoomed",
compute='_compute_can_image_1024_be_zoomed',
store=True)
@api.depends('image_1920', 'image_1024')
def _compute_can_image_1024_be_zoomed(self):
for image in self:
image.can_image_1024_be_zoomed = image.image_1920 and tools.is_image_size_above(
image.image_1920, image.image_1024)
@api.depends('video_url')
def _compute_embed_code(self):
for image in self:
image.embed_code = get_video_embed_code(image.video_url)
@api.constrains('video_url')
def _check_valid_video_url(self):
for image in self:
if image.video_url and not image.embed_code:
raise ValidationError(
_(
"Provided video URL for '%s' is not valid. Please enter a valid video URL.",
image.name))
@api.model_create_multi
def create(self, vals_list):
"""
We don't want the default_product_tmpl_id from the context
to be applied if we have a product_variant_id set to avoid
having the variant images to show also as template images.
But we want it if we don't have a product_variant_id set.
"""
context_without_template = self.with_context({
k: v
for k, v in self.env.context.items()
if k != 'default_product_tmpl_id'
})
normal_vals = []
variant_vals_list = []
for vals in vals_list:
if vals.get('product_variant_id'
) and 'default_product_tmpl_id' in self.env.context:
variant_vals_list.append(vals)
else:
normal_vals.append(vals)
return super().create(normal_vals) + super(
ProductImage, context_without_template).create(variant_vals_list)
class Sponsor(models.Model):
_name = "event.sponsor"
_description = 'Event Sponsor'
_order = "sequence, sponsor_type_id"
_rec_name = 'name'
_inherit = ['mail.thread', 'mail.activity.mixin']
event_id = fields.Many2one('event.event', 'Event', required=True)
sponsor_type_id = fields.Many2one('event.sponsor.type', 'Sponsoring Type', required=True)
url = fields.Char('Sponsor Website', compute='_compute_url', readonly=False, store=True)
sequence = fields.Integer('Sequence')
active = fields.Boolean(default=True)
# contact information
partner_id = fields.Many2one('res.partner', 'Sponsor/Customer', required=True)
partner_name = fields.Char('Name', related='partner_id.name')
partner_email = fields.Char('Email', related='partner_id.email')
partner_phone = fields.Char('Phone', related='partner_id.phone')
partner_mobile = fields.Char('Mobile', related='partner_id.mobile')
name = fields.Char('Sponsor Name', compute='_compute_name', readonly=False, store=True)
email = fields.Char('Sponsor Email', compute='_compute_email', readonly=False, store=True)
phone = fields.Char('Sponsor Phone', compute='_compute_phone', readonly=False, store=True)
mobile = fields.Char('Sponsor Mobile', compute='_compute_mobile', readonly=False, store=True)
# image
image_512 = fields.Image(
string="Logo", max_width=512, max_height=512,
compute='_compute_image_512', readonly=False, store=True)
image_256 = fields.Image("Image 256", related="image_512", max_width=256, max_height=256, store=False)
image_128 = fields.Image("Image 128", related="image_512", max_width=128, max_height=128, store=False)
website_image_url = fields.Char(
string='Image URL',
compute='_compute_website_image_url', compute_sudo=True, store=False)
@api.depends('partner_id')
def _compute_url(self):
for sponsor in self:
if sponsor.partner_id.website or not sponsor.url:
sponsor.url = sponsor.partner_id.website
@api.depends('partner_id')
def _compute_name(self):
self._synchronize_with_partner('name')
@api.depends('partner_id')
def _compute_email(self):
self._synchronize_with_partner('email')
@api.depends('partner_id')
def _compute_phone(self):
self._synchronize_with_partner('phone')
@api.depends('partner_id')
def _compute_mobile(self):
self._synchronize_with_partner('mobile')
@api.depends('partner_id')
def _compute_image_512(self):
self._synchronize_with_partner('image_512')
@api.depends('image_256', 'partner_id.image_256')
def _compute_website_image_url(self):
for sponsor in self:
if sponsor.image_256:
sponsor.website_image_url = self.env['website'].image_url(sponsor, 'image_256', size=256)
elif sponsor.partner_id.image_256:
sponsor.website_image_url = self.env['website'].image_url(sponsor.partner_id, 'image_256', size=256)
else:
sponsor.website_image_url = get_resource_path('website_event_track', 'static/src/img', 'event_sponsor_default_%d.png' % (sponsor.id % 1))
def _synchronize_with_partner(self, fname):
""" Synchronize with partner if not set. Setting a value does not write
on partner as this may be event-specific information. """
for sponsor in self:
if not sponsor[fname]:
sponsor[fname] = sponsor.partner_id[fname]
# ------------------------------------------------------------
# MESSAGING
# ------------------------------------------------------------
def _message_get_suggested_recipients(self):
recipients = super(Sponsor, self)._message_get_suggested_recipients()
for sponsor in self:
if sponsor.partner_id:
sponsor._message_add_suggested_recipient(
recipients,
partner=sponsor.partner_id,
reason=_('Sponsor')
)
return recipients
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)
company_id = fields.Many2one('res.company', required=True)
# 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",
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([
('graduate', 'Graduate'),
('bachelor', 'Bachelor'),
('master', 'Master'),
('doctor', 'Doctor'),
('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="Home-Work Distance",
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,
readonly=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)
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)
departure_date = fields.Date(string="Departure Date",
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)
ids = self.env['hr.employee.public']._search(
args,
offset=offset,
limit=limit,
order=order,
count=count,
access_rights_uid=access_rights_uid)
if not count and isinstance(ids, Query):
# the result is expected from this table, so we should link tables
ids = super(HrEmployeePrivate,
self.sudo())._search([('id', 'in', ids)])
return ids
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('user_id')
def _onchange_user(self):
if self.user_id:
self.update(self._sync_user(self.user_id, bool(self.image_1920)))
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, employee_has_image=False):
vals = dict(
work_email=user.email,
user_id=user.id,
)
if not employee_has_image:
vals['image_1920'] = user.image_1920
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.get('image_1920') == self._default_image()))
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'):
# Update the profile pictures with user, except if provided
vals.update(
self._sync_user(self.env['res.users'].browse(vals['user_id']),
bool(vals.get('image_1920'))))
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()
unarchived_employees = self.filtered(lambda employee: employee.active)
unarchived_employees.write({
'departure_reason': False,
'departure_description': False,
'departure_date': False
})
archived_addresses = unarchived_employees.mapped(
'address_home_id').filtered(lambda addr: not addr.active)
archived_addresses.toggle_active()
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 FlectraBot
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']
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)
description = fields.Text("Vehicle Description")
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',
compute='_compute_manager_id',
domain=lambda self: [('groups_id', 'in',
self.env.ref('fleet.fleet_group_manager').id)],
store=True,
readonly=False)
@api.depends('model_id')
def _compute_manager_id(self):
for vehicle in self:
if vehicle.model_id:
vehicle.manager_id = vehicle.model_id.manager_id
else:
vehicle.manager_id = None
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='Assignment Logs')
log_services = fields.One2many('fleet.vehicle.log.services', 'vehicle_id',
'Services Logs')
log_contracts = fields.One2many('fleet.vehicle.log.contract', 'vehicle_id',
'Contracts')
contract_count = fields.Integer(compute="_compute_count_all",
string='Contract Count')
service_count = fields.Integer(compute="_compute_count_all",
string='Services')
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(
'Assignment 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', 'km'), ('miles', 'mi')],
'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=True)
contract_renewal_due_soon = fields.Boolean(
compute='_compute_contract_reminder',
search='_search_contract_renewal_due_soon',
string='Has Contracts to renew')
contract_renewal_overdue = fields.Boolean(
compute='_compute_contract_reminder',
search='_search_get_overdue_contract_reminder',
string='Has Contracts Overdue')
contract_renewal_name = fields.Text(
compute='_compute_contract_reminder',
string='Name of contract to renew soon')
contract_renewal_total = fields.Text(
compute='_compute_contract_reminder',
string='Total of contracts due or overdue minus one')
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 vehicle")
residual_value = fields.Float()
plan_to_change_car = fields.Boolean(related='driver_id.plan_to_change_car',
store=True,
readonly=False)
vehicle_type = fields.Selection(related='model_id.vehicle_type')
@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']
LogService = self.env['fleet.vehicle.log.services']
LogContract = self.env['fleet.vehicle.log.contract']
for record in self:
record.odometer_count = Odometer.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.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',
'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', '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.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 _get_analytic_name(self):
# This function is used in fleet_account and is overrided in l10n_be_hr_payroll_fleet
return self.license_plate or _('No plate')
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))
res_ids = self.env['fleet.vehicle.log.contract'].search([
('expiration_date', '>', today),
('expiration_date', '<', limit_date),
('state', 'in', ['open', 'expired'])
]).mapped('vehicle_id').ids
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)
res_ids = self.env['fleet.vehicle.log.contract'].search([
('expiration_date', '!=', False), ('expiration_date', '<', today),
('state', 'in', ['open', 'expired'])
]).mapped('vehicle_id').ids
res.append(('id', search_operator, res_ids))
return res
@api.model
def create(self, vals):
# Fleet administrator may not have rights to create the plan_to_change_car value when the driver_id is a res.user
# This trick is used to prevent access right error.
ptc_value = 'plan_to_change_car' in vals.keys() and {
'plan_to_change_car': vals.pop('plan_to_change_car')
}
res = super(FleetVehicle, self).create(vals)
if ptc_value:
res.sudo().write(ptc_value)
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):
self._close_driver_history()
# 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 read_group(self,
domain,
fields,
groupby,
offset=0,
limit=None,
orderby=False,
lazy=True):
if 'co2' in fields:
fields.remove('co2')
return super(FleetVehicle,
self).read_group(domain, fields, groupby, offset, limit,
orderby, lazy)
@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)
]
return self._search(expression.AND([domain, args]),
limit=limit,
access_rights_uid=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.%s' %
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': 'Assignment 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 HrEmployeePublic(models.Model):
_name = "hr.employee.public"
_inherit = ["hr.employee.base"]
_description = 'Public Employee'
_order = 'name'
_auto = False
_log_access = True # Include magic fields
# Fields coming from hr.employee.base
create_date = fields.Datetime(readonly=True)
name = fields.Char(readonly=True)
active = fields.Boolean(readonly=True)
department_id = fields.Many2one(readonly=True)
job_id = fields.Many2one(readonly=True)
job_title = fields.Char(readonly=True)
company_id = fields.Many2one(readonly=True)
address_id = fields.Many2one(readonly=True)
mobile_phone = fields.Char(readonly=True)
work_phone = fields.Char(readonly=True)
work_email = fields.Char(readonly=True)
work_location = fields.Char(readonly=True)
user_id = fields.Many2one(readonly=True)
resource_id = fields.Many2one(readonly=True)
resource_calendar_id = fields.Many2one(readonly=True)
tz = fields.Selection(readonly=True)
color = fields.Integer(readonly=True)
# hr.employee.public specific fields
child_ids = fields.One2many('hr.employee.public',
'parent_id',
string='Direct subordinates',
readonly=True)
image_1920 = fields.Image("Original Image",
compute='_compute_image',
compute_sudo=True)
image_1024 = fields.Image("Image 1024",
compute='_compute_image',
compute_sudo=True)
image_512 = fields.Image("Image 512",
compute='_compute_image',
compute_sudo=True)
image_256 = fields.Image("Image 256",
compute='_compute_image',
compute_sudo=True)
image_128 = fields.Image("Image 128",
compute='_compute_image',
compute_sudo=True)
parent_id = fields.Many2one('hr.employee.public', 'Manager', readonly=True)
coach_id = fields.Many2one('hr.employee.public', 'Coach', readonly=True)
user_partner_id = fields.Many2one(related='user_id.partner_id',
related_sudo=False,
string="User's partner")
def _compute_image(self):
for employee in self:
# We have to be in sudo to have access to the images
employee_id = self.sudo().env['hr.employee'].browse(employee.id)
employee.image_1920 = employee_id.image_1920
employee.image_1024 = employee_id.image_1024
employee.image_512 = employee_id.image_512
employee.image_256 = employee_id.image_256
employee.image_128 = employee_id.image_128
@api.model
def _get_fields(self):
return ','.join(
'emp.%s' % name for name, field in self._fields.items()
if field.store and field.type not in ['many2many', 'one2many'])
def init(self):
tools.drop_view_if_exists(self.env.cr, self._table)
self.env.cr.execute("""CREATE or REPLACE VIEW %s as (
SELECT
%s
FROM hr_employee emp
)""" % (self._table, self._get_fields()))
