# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import logging import random from datetime import datetime from dateutil.relativedelta import relativedelta from odoo import api, models, fields, _ from odoo.http import request from odoo.osv import expression from odoo.exceptions import UserError, ValidationError _logger = logging.getLogger(__name__) class SaleOrder(models.Model): _inherit = "sale.order" website_order_line = fields.One2many( 'sale.order.line', compute='_compute_website_order_line', string='Order Lines displayed on Website', help='Order Lines to be displayed on the website. They should not be used for computation purpose.', ) cart_quantity = fields.Integer(compute='_compute_cart_info', string='Cart Quantity') only_services = fields.Boolean(compute='_compute_cart_info', string='Only Services') is_abandoned_cart = fields.Boolean('Abandoned Cart', compute='_compute_abandoned_cart', search='_search_abandoned_cart') cart_recovery_email_sent = fields.Boolean('Cart recovery email already sent') website_id = fields.Many2one('website', string='Website', readonly=True, help='Website through which this order was placed.') @api.model def _default_note_url(self): website = self.env['website'].get_current_website() if website: return website.get_base_url() return super()._default_note_url() @api.depends('order_line') def _compute_website_order_line(self): for order in self: order.website_order_line = order.order_line @api.depends('order_line.product_uom_qty', 'order_line.product_id') def _compute_cart_info(self): for order in self: order.cart_quantity = int(sum(order.mapped('website_order_line.product_uom_qty'))) order.only_services = all(l.product_id.type == 'service' for l in order.website_order_line) @api.depends('website_id', 'date_order', 'order_line', 'state', 'partner_id') def _compute_abandoned_cart(self): for order in self: # a quotation can be considered as an abandonned cart if it is linked to a website, # is in the 'draft' state and has an expiration date if order.website_id and order.state == 'draft' and order.date_order: public_partner_id = order.website_id.user_id.partner_id # by default the expiration date is 1 hour if not specified on the website configuration abandoned_delay = order.website_id.cart_abandoned_delay or 1.0 abandoned_datetime = datetime.utcnow() - relativedelta(hours=abandoned_delay) order.is_abandoned_cart = bool(order.date_order <= abandoned_datetime and order.partner_id != public_partner_id and order.order_line) else: order.is_abandoned_cart = False def _search_abandoned_cart(self, operator, value): website_ids = self.env['website'].search_read(fields=['id', 'cart_abandoned_delay', 'partner_id']) deadlines = [[ '&', '&', ('website_id', '=', website_id['id']), ('date_order', '<=', fields.Datetime.to_string(datetime.utcnow() - relativedelta(hours=website_id['cart_abandoned_delay'] or 1.0))), ('partner_id', '!=', website_id['partner_id'][0]) ] for website_id in website_ids] abandoned_domain = [ ('state', '=', 'draft'), ('order_line', '!=', False) ] abandoned_domain.extend(expression.OR(deadlines)) abandoned_domain = expression.normalize_domain(abandoned_domain) # is_abandoned domain possibilities if (operator not in expression.NEGATIVE_TERM_OPERATORS and value) or (operator in expression.NEGATIVE_TERM_OPERATORS and not value): return abandoned_domain return expression.distribute_not(['!'] + abandoned_domain) # negative domain def _cart_find_product_line(self, product_id=None, line_id=None, **kwargs): """Find the cart line matching the given parameters. If a product_id is given, the line will match the product only if the line also has the same special attributes: `no_variant` attributes and `is_custom` values. """ self.ensure_one() product = self.env['product.product'].browse(product_id) # split lines with the same product if it has untracked attributes if product and (product.product_tmpl_id.has_dynamic_attributes() or product.product_tmpl_id._has_no_variant_attributes()) and not line_id and not kwargs.get('force_search', False): return self.env['sale.order.line'] domain = [('order_id', '=', self.id), ('product_id', '=', product_id)] if line_id: domain += [('id', '=', line_id)] else: domain += [('product_custom_attribute_value_ids', '=', False)] return self.env['sale.order.line'].sudo().search(domain) def _website_product_id_change(self, order_id, product_id, qty=0, **kwargs): order = self.sudo().browse(order_id) product_context = dict(self.env.context) product_context.setdefault('lang', order.partner_id.lang) product_context.update({ 'partner': order.partner_id, 'quantity': qty, 'date': order.date_order, 'pricelist': order.pricelist_id.id, }) product = self.env['product.product'].with_context(product_context).with_company(order.company_id.id).browse(product_id) discount = 0 if order.pricelist_id.discount_policy == 'without_discount': # This part is pretty much a copy-paste of the method '_onchange_discount' of # 'sale.order.line'. price, rule_id = order.pricelist_id.with_context(product_context).get_product_price_rule(product, qty or 1.0, order.partner_id) pu, currency = request.env['sale.order.line'].with_context(product_context)._get_real_price_currency(product, rule_id, qty, product.uom_id, order.pricelist_id.id) if order.pricelist_id and order.partner_id: order_line = order._cart_find_product_line(product.id) if order_line: price = product._get_tax_included_unit_price( self.company_id, order.currency_id, order.date_order, 'sale', fiscal_position=order.fiscal_position_id, product_price_unit=price, product_currency=order.currency_id ) pu = product._get_tax_included_unit_price( self.company_id, order.currency_id, order.date_order, 'sale', fiscal_position=order.fiscal_position_id, product_price_unit=pu, product_currency=order.currency_id ) if pu != 0: if order.pricelist_id.currency_id != currency: # we need new_list_price in the same currency as price, which is in the SO's pricelist's currency date = order.date_order or fields.Date.today() pu = currency._convert(pu, order.pricelist_id.currency_id, order.company_id, date) discount = (pu - price) / pu * 100 if discount < 0: # In case the discount is negative, we don't want to show it to the customer, # but we still want to use the price defined on the pricelist discount = 0 pu = price else: # In case the price_unit equal 0 and therefore not able to calculate the discount, # we fallback on the price defined on the pricelist. pu = price else: pu = product.price if order.pricelist_id and order.partner_id: order_line = order._cart_find_product_line(product.id, force_search=True) if order_line: pu = product._get_tax_included_unit_price( self.company_id, order.currency_id, order.date_order, 'sale', fiscal_position=order.fiscal_position_id, product_price_unit=product.price, product_currency=order.currency_id ) return { 'product_id': product_id, 'product_uom_qty': qty, 'order_id': order_id, 'product_uom': product.uom_id.id, 'price_unit': pu, 'discount': discount, } def _cart_update(self, product_id=None, line_id=None, add_qty=0, set_qty=0, **kwargs): """ Add or set product quantity, add_qty can be negative """ self.ensure_one() product_context = dict(self.env.context) product_context.setdefault('lang', self.sudo().partner_id.lang) SaleOrderLineSudo = self.env['sale.order.line'].sudo().with_context(product_context) # change lang to get correct name of attributes/values product_with_context = self.env['product.product'].with_context(product_context) product = product_with_context.browse(int(product_id)).exists() if not product or (not line_id and not product._is_add_to_cart_allowed()): raise UserError(_("The given product does not exist therefore it cannot be added to cart.")) try: if add_qty: add_qty = int(add_qty) except ValueError: add_qty = 1 try: if set_qty: set_qty = int(set_qty) except ValueError: set_qty = 0 quantity = 0 order_line = False if self.state != 'draft': request.session['sale_order_id'] = None raise UserError(_('It is forbidden to modify a sales order which is not in draft status.')) if line_id is not False: order_line = self._cart_find_product_line(product_id, line_id, **kwargs)[:1] # Create line if no line with product_id can be located if not order_line: no_variant_attribute_values = kwargs.get('no_variant_attribute_values') or [] received_no_variant_values = product.env['product.template.attribute.value'].browse([int(ptav['value']) for ptav in no_variant_attribute_values]) received_combination = product.product_template_attribute_value_ids | received_no_variant_values product_template = product.product_tmpl_id # handle all cases where incorrect or incomplete data are received combination = product_template._get_closest_possible_combination(received_combination) # get or create (if dynamic) the correct variant product = product_template._create_product_variant(combination) if not product: raise UserError(_("The given combination does not exist therefore it cannot be added to cart.")) product_id = product.id values = self._website_product_id_change(self.id, product_id, qty=1, **kwargs) # add no_variant attributes that were not received for ptav in combination.filtered(lambda ptav: ptav.attribute_id.create_variant == 'no_variant' and ptav not in received_no_variant_values): no_variant_attribute_values.append({ 'value': ptav.id, }) # save no_variant attributes values if no_variant_attribute_values: values['product_no_variant_attribute_value_ids'] = [ (6, 0, [int(attribute['value']) for attribute in no_variant_attribute_values]) ] # add is_custom attribute values that were not received custom_values = kwargs.get('product_custom_attribute_values') or [] received_custom_values = product.env['product.template.attribute.value'].browse([int(ptav['custom_product_template_attribute_value_id']) for ptav in custom_values]) for ptav in combination.filtered(lambda ptav: ptav.is_custom and ptav not in received_custom_values): custom_values.append({ 'custom_product_template_attribute_value_id': ptav.id, 'custom_value': '', }) # save is_custom attributes values if custom_values: values['product_custom_attribute_value_ids'] = [(0, 0, { 'custom_product_template_attribute_value_id': custom_value['custom_product_template_attribute_value_id'], 'custom_value': custom_value['custom_value'] }) for custom_value in custom_values] # create the line order_line = SaleOrderLineSudo.create(values) try: order_line._compute_tax_id() except ValidationError as e: # The validation may occur in backend (eg: taxcloud) but should fail silently in frontend _logger.debug("ValidationError occurs during tax compute. %s" % (e)) if add_qty: add_qty -= 1 # compute new quantity if set_qty: quantity = set_qty elif add_qty is not None: quantity = order_line.product_uom_qty + (add_qty or 0) # Remove zero of negative lines if quantity <= 0: linked_line = order_line.linked_line_id order_line.unlink() if linked_line: # update description of the parent linked_product = product_with_context.browse(linked_line.product_id.id) linked_line.name = linked_line.get_sale_order_line_multiline_description_sale(linked_product) else: # update line no_variant_attributes_price_extra = [ptav.price_extra for ptav in order_line.product_no_variant_attribute_value_ids] values = self.with_context(no_variant_attributes_price_extra=tuple(no_variant_attributes_price_extra))._website_product_id_change(self.id, product_id, qty=quantity, **kwargs) order = self.sudo().browse(self.id) if self.pricelist_id.discount_policy == 'with_discount' and not self.env.context.get('fixed_price'): product_context.update({ 'partner': order.partner_id, 'quantity': quantity, 'date': order.date_order, 'pricelist': order.pricelist_id.id, }) product_with_context = self.env['product.product'].with_context(product_context).with_company(order.company_id.id) product = product_with_context.browse(product_id) order_line.write(values) # link a product to the sales order if kwargs.get('linked_line_id'): linked_line = SaleOrderLineSudo.browse(kwargs['linked_line_id']) order_line.write({ 'linked_line_id': linked_line.id, }) linked_product = product_with_context.browse(linked_line.product_id.id) linked_line.name = linked_line.get_sale_order_line_multiline_description_sale(linked_product) # Generate the description with everything. This is done after # creating because the following related fields have to be set: # - product_no_variant_attribute_value_ids # - product_custom_attribute_value_ids # - linked_line_id order_line.name = order_line.get_sale_order_line_multiline_description_sale(product) option_lines = self.order_line.filtered(lambda l: l.linked_line_id.id == order_line.id) return {'line_id': order_line.id, 'quantity': quantity, 'option_ids': list(set(option_lines.ids))} def _cart_accessories(self): """ Suggest accessories based on 'Accessory Products' of products in cart """ for order in self: products = order.website_order_line.mapped('product_id') accessory_products = self.env['product.product'] for line in order.website_order_line.filtered(lambda l: l.product_id): combination = line.product_id.product_template_attribute_value_ids + line.product_no_variant_attribute_value_ids accessory_products |= line.product_id.product_tmpl_id._get_website_accessory_product().filtered(lambda product: product not in products and product._is_variant_possible(parent_combination=combination) and (product.company_id == line.company_id or not product.company_id) ) return random.sample(accessory_products, len(accessory_products)) def action_recovery_email_send(self): for order in self: order._portal_ensure_token() composer_form_view_id = self.env.ref('mail.email_compose_message_wizard_form').id template_id = self._get_cart_recovery_template().id return { 'type': 'ir.actions.act_window', 'view_mode': 'form', 'res_model': 'mail.compose.message', 'view_id': composer_form_view_id, 'target': 'new', 'context': { 'default_composition_mode': 'mass_mail' if len(self.ids) > 1 else 'comment', 'default_res_id': self.ids[0], 'default_model': 'sale.order', 'default_use_template': bool(template_id), 'default_template_id': template_id, 'website_sale_send_recovery_email': True, 'active_ids': self.ids, }, } def _get_cart_recovery_template(self): """ Return the cart recovery template record for a set of orders. If they all belong to the same website, we return the website-specific template; otherwise we return the default template. If the default is not found, the empty ['mail.template'] is returned. """ websites = self.mapped('website_id') template = websites.cart_recovery_mail_template_id if len(websites) == 1 else False template = template or self.env.ref('website_sale.mail_template_sale_cart_recovery', raise_if_not_found=False) return template or self.env['mail.template'] def _cart_recovery_email_send(self): """Send the cart recovery email on the current recordset, making sure that the portal token exists to avoid broken links, and marking the email as sent. Similar method to action_recovery_email_send, made to be called in automated actions. Contrary to the former, it will use the website-specific template for each order.""" sent_orders = self.env['sale.order'] for order in self: template = order._get_cart_recovery_template() if template: order._portal_ensure_token() template.send_mail(order.id) sent_orders |= order sent_orders.write({'cart_recovery_email_sent': True}) def action_confirm(self): res = super(SaleOrder, self).action_confirm() for order in self: if not order.transaction_ids and not order.amount_total and self._context.get('send_email'): order._send_order_confirmation_mail() return res class SaleOrderLine(models.Model): _inherit = "sale.order.line" name_short = fields.Char(compute="_compute_name_short") linked_line_id = fields.Many2one('sale.order.line', string='Linked Order Line', domain="[('order_id', '=', order_id)]", ondelete='cascade', copy=False, index=True) option_line_ids = fields.One2many('sale.order.line', 'linked_line_id', string='Options Linked') def get_sale_order_line_multiline_description_sale(self, product): description = super(SaleOrderLine, self).get_sale_order_line_multiline_description_sale(product) if self.linked_line_id: description += "\n" + _("Option for: %s", self.linked_line_id.product_id.display_name) if self.option_line_ids: description += "\n" + '\n'.join([_("Option: %s", option_line.product_id.display_name) for option_line in self.option_line_ids]) return description @api.depends('product_id.display_name') def _compute_name_short(self): """ Compute a short name for this sale order line, to be used on the website where we don't have much space. To keep it short, instead of using the first line of the description, we take the product name without the internal reference. """ for record in self: record.name_short = record.product_id.with_context(display_default_code=False).display_name def get_description_following_lines(self): return self.name.splitlines()[1:]