# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import binascii from odoo import fields, http, SUPERUSER_ID, _ from odoo.exceptions import AccessError, MissingError, ValidationError from odoo.fields import Command from odoo.http import request from odoo.addons.payment.controllers import portal as payment_portal from odoo.addons.payment import utils as payment_utils from odoo.addons.portal.controllers.mail import _message_post_helper from odoo.addons.portal.controllers import portal from odoo.addons.portal.controllers.portal import pager as portal_pager, get_records_pager class CustomerPortal(portal.CustomerPortal): def _prepare_home_portal_values(self, counters): values = super()._prepare_home_portal_values(counters) partner = request.env.user.partner_id SaleOrder = request.env['sale.order'] if 'quotation_count' in counters: values['quotation_count'] = SaleOrder.search_count(self._prepare_quotations_domain(partner)) \ if SaleOrder.check_access_rights('read', raise_exception=False) else 0 if 'order_count' in counters: values['order_count'] = SaleOrder.search_count(self._prepare_orders_domain(partner)) \ if SaleOrder.check_access_rights('read', raise_exception=False) else 0 return values def _prepare_quotations_domain(self, partner): return [ ('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]), ('state', 'in', ['sent', 'cancel']) ] def _prepare_orders_domain(self, partner): return [ ('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]), ('state', 'in', ['sale', 'done']) ] # # Quotations and Sales Orders # def _get_sale_searchbar_sortings(self): return { 'date': {'label': _('Order Date'), 'order': 'date_order desc'}, 'name': {'label': _('Reference'), 'order': 'name'}, 'stage': {'label': _('Stage'), 'order': 'state'}, } @http.route(['/my/quotes', '/my/quotes/page/'], type='http', auth="user", website=True) def portal_my_quotes(self, page=1, date_begin=None, date_end=None, sortby=None, **kw): values = self._prepare_portal_layout_values() partner = request.env.user.partner_id SaleOrder = request.env['sale.order'] domain = self._prepare_quotations_domain(partner) searchbar_sortings = self._get_sale_searchbar_sortings() # default sortby order if not sortby: sortby = 'date' sort_order = searchbar_sortings[sortby]['order'] if date_begin and date_end: domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)] # count for pager quotation_count = SaleOrder.search_count(domain) # make pager pager = portal_pager( url="/my/quotes", url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby}, total=quotation_count, page=page, step=self._items_per_page ) # search the count to display, according to the pager data quotations = SaleOrder.search(domain, order=sort_order, limit=self._items_per_page, offset=pager['offset']) request.session['my_quotations_history'] = quotations.ids[:100] values.update({ 'date': date_begin, 'quotations': quotations.sudo(), 'page_name': 'quote', 'pager': pager, 'default_url': '/my/quotes', 'searchbar_sortings': searchbar_sortings, 'sortby': sortby, }) return request.render("sale.portal_my_quotations", values) @http.route(['/my/orders', '/my/orders/page/'], type='http', auth="user", website=True) def portal_my_orders(self, page=1, date_begin=None, date_end=None, sortby=None, **kw): values = self._prepare_portal_layout_values() partner = request.env.user.partner_id SaleOrder = request.env['sale.order'] domain = self._prepare_orders_domain(partner) searchbar_sortings = self._get_sale_searchbar_sortings() # default sortby order if not sortby: sortby = 'date' sort_order = searchbar_sortings[sortby]['order'] if date_begin and date_end: domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)] # count for pager order_count = SaleOrder.search_count(domain) # pager pager = portal_pager( url="/my/orders", url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby}, total=order_count, page=page, step=self._items_per_page ) # content according to pager orders = SaleOrder.search(domain, order=sort_order, limit=self._items_per_page, offset=pager['offset']) request.session['my_orders_history'] = orders.ids[:100] values.update({ 'date': date_begin, 'orders': orders.sudo(), 'page_name': 'order', 'pager': pager, 'default_url': '/my/orders', 'searchbar_sortings': searchbar_sortings, 'sortby': sortby, }) return request.render("sale.portal_my_orders", values) @http.route(['/my/orders/'], type='http', auth="public", website=True) def portal_order_page(self, order_id, report_type=None, access_token=None, message=False, download=False, **kw): try: order_sudo = self._document_check_access('sale.order', order_id, access_token=access_token) except (AccessError, MissingError): return request.redirect('/my') if report_type in ('html', 'pdf', 'text'): return self._show_report(model=order_sudo, report_type=report_type, report_ref='sale.action_report_saleorder', download=download) # use sudo to allow accessing/viewing orders for public user # only if he knows the private token # Log only once a day if order_sudo: # store the date as a string in the session to allow serialization now = fields.Date.today().isoformat() session_obj_date = request.session.get('view_quote_%s' % order_sudo.id) if session_obj_date != now and request.env.user.share and access_token: request.session['view_quote_%s' % order_sudo.id] = now body = _('Quotation viewed by customer %s', order_sudo.partner_id.name) _message_post_helper( "sale.order", order_sudo.id, body, token=order_sudo.access_token, message_type="notification", subtype_xmlid="mail.mt_note", partner_ids=order_sudo.user_id.sudo().partner_id.ids, ) values = { 'sale_order': order_sudo, 'message': message, 'token': access_token, 'landing_route': '/shop/payment/validate', 'bootstrap_formatting': True, 'partner_id': order_sudo.partner_id.id, 'report_type': 'html', 'action': order_sudo._get_portal_return_action(), } if order_sudo.company_id: values['res_company'] = order_sudo.company_id # Payment values if order_sudo.has_to_be_paid(): logged_in = not request.env.user._is_public() acquirers_sudo = request.env['payment.acquirer'].sudo()._get_compatible_acquirers( order_sudo.company_id.id, order_sudo.partner_id.id, currency_id=order_sudo.currency_id.id, sale_order_id=order_sudo.id, ) # In sudo mode to read the fields of acquirers and partner (if not logged in) tokens = request.env['payment.token'].search([ ('acquirer_id', 'in', acquirers_sudo.ids), ('partner_id', '=', order_sudo.partner_id.id) ]) if logged_in else request.env['payment.token'] # Make sure that the partner's company matches the order's company. if not payment_portal.PaymentPortal._can_partner_pay_in_company( order_sudo.partner_id, order_sudo.company_id ): acquirers_sudo = request.env['payment.acquirer'].sudo() tokens = request.env['payment.token'] fees_by_acquirer = { acquirer: acquirer._compute_fees( order_sudo.amount_total, order_sudo.currency_id, order_sudo.partner_id.country_id, ) for acquirer in acquirers_sudo.filtered('fees_active') } # Prevent public partner from saving payment methods but force it for logged in partners # buying subscription products show_tokenize_input = logged_in \ and not request.env['payment.acquirer'].sudo()._is_tokenization_required( sale_order_id=order_sudo.id ) values.update({ 'acquirers': acquirers_sudo, 'tokens': tokens, 'fees_by_acquirer': fees_by_acquirer, 'show_tokenize_input': show_tokenize_input, 'amount': order_sudo.amount_total, 'currency': order_sudo.pricelist_id.currency_id, 'partner_id': order_sudo.partner_id.id, 'access_token': order_sudo.access_token, 'transaction_route': order_sudo.get_portal_url(suffix='/transaction'), 'landing_route': order_sudo.get_portal_url(), }) if order_sudo.state in ('draft', 'sent', 'cancel'): history = request.session.get('my_quotations_history', []) else: history = request.session.get('my_orders_history', []) values.update(get_records_pager(history, order_sudo)) return request.render('sale.sale_order_portal_template', values) @http.route(['/my/orders//accept'], type='json', auth="public", website=True) def portal_quote_accept(self, order_id, access_token=None, name=None, signature=None): # get from query string if not on json param access_token = access_token or request.httprequest.args.get('access_token') try: order_sudo = self._document_check_access('sale.order', order_id, access_token=access_token) except (AccessError, MissingError): return {'error': _('Invalid order.')} if not order_sudo.has_to_be_signed(): return {'error': _('The order is not in a state requiring customer signature.')} if not signature: return {'error': _('Signature is missing.')} try: order_sudo.write({ 'signed_by': name, 'signed_on': fields.Datetime.now(), 'signature': signature, }) request.env.cr.commit() except (TypeError, binascii.Error) as e: return {'error': _('Invalid signature data.')} if not order_sudo.has_to_be_paid(): order_sudo.action_confirm() order_sudo._send_order_confirmation_mail() pdf = request.env.ref('sale.action_report_saleorder').with_user(SUPERUSER_ID)._render_qweb_pdf([order_sudo.id])[0] _message_post_helper( 'sale.order', order_sudo.id, _('Order signed by %s') % (name,), attachments=[('%s.pdf' % order_sudo.name, pdf)], **({'token': access_token} if access_token else {})) query_string = '&message=sign_ok' if order_sudo.has_to_be_paid(True): query_string += '#allow_payment=yes' return { 'force_refresh': True, 'redirect_url': order_sudo.get_portal_url(query_string=query_string), } @http.route(['/my/orders//decline'], type='http', auth="public", methods=['POST'], website=True) def decline(self, order_id, access_token=None, **post): try: order_sudo = self._document_check_access('sale.order', order_id, access_token=access_token) except (AccessError, MissingError): return request.redirect('/my') message = post.get('decline_message') query_string = False if order_sudo.has_to_be_signed() and message: order_sudo.action_cancel() _message_post_helper('sale.order', order_id, message, **{'token': access_token} if access_token else {}) else: query_string = "&message=cant_reject" return request.redirect(order_sudo.get_portal_url(query_string=query_string)) class PaymentPortal(payment_portal.PaymentPortal): @http.route('/my/orders//transaction', type='json', auth='public') def portal_order_transaction(self, order_id, access_token, **kwargs): """ Create a draft transaction and return its processing values. :param int order_id: The sales order to pay, as a `sale.order` id :param str access_token: The access token used to authenticate the request :param dict kwargs: Locally unused data passed to `_create_transaction` :return: The mandatory values for the processing of the transaction :rtype: dict :raise: ValidationError if the invoice id or the access token is invalid """ # Check the order id and the access token try: order_sudo = self._document_check_access('sale.order', order_id, access_token) except MissingError as error: raise error except AccessError: raise ValidationError("The access token is invalid.") kwargs.update({ 'reference_prefix': None, # Allow the reference to be computed based on the order 'partner_id': order_sudo.partner_invoice_id.id, 'sale_order_id': order_id, # Include the SO to allow Subscriptions tokenizing the tx }) kwargs.pop('custom_create_values', None) # Don't allow passing arbitrary create values tx_sudo = self._create_transaction( custom_create_values={'sale_order_ids': [Command.set([order_id])]}, **kwargs, ) return tx_sudo._get_processing_values() # Payment overrides @http.route() def payment_pay(self, *args, amount=None, sale_order_id=None, access_token=None, **kwargs): """ Override of payment to replace the missing transaction values by that of the sale order. This is necessary for the reconciliation as all transaction values, excepted the amount, need to match exactly that of the sale order. :param str amount: The (possibly partial) amount to pay used to check the access token :param str sale_order_id: The sale order for which a payment id made, as a `sale.order` id :param str access_token: The access token used to authenticate the partner :return: The result of the parent method :rtype: str :raise: ValidationError if the order id is invalid """ # Cast numeric parameters as int or float and void them if their str value is malformed amount = self._cast_as_float(amount) sale_order_id = self._cast_as_int(sale_order_id) if sale_order_id: order_sudo = request.env['sale.order'].sudo().browse(sale_order_id).exists() if not order_sudo: raise ValidationError(_("The provided parameters are invalid.")) # Check the access token against the order values. Done after fetching the order as we # need the order fields to check the access token. if not payment_utils.check_access_token( access_token, order_sudo.partner_id.id, amount, order_sudo.currency_id.id ): raise ValidationError(_("The provided parameters are invalid.")) kwargs.update({ 'currency_id': order_sudo.currency_id.id, 'partner_id': order_sudo.partner_invoice_id.id, 'company_id': order_sudo.company_id.id, 'sale_order_id': sale_order_id, }) return super().payment_pay(*args, amount=amount, access_token=access_token, **kwargs) def _get_custom_rendering_context_values(self, sale_order_id=None, **kwargs): """ Override of payment to add the sale order id in the custom rendering context values. :param int sale_order_id: The sale order for which a payment id made, as a `sale.order` id :return: The extended rendering context values :rtype: dict """ rendering_context_values = super()._get_custom_rendering_context_values(**kwargs) if sale_order_id: rendering_context_values['sale_order_id'] = sale_order_id return rendering_context_values def _create_transaction(self, *args, sale_order_id=None, custom_create_values=None, **kwargs): """ Override of payment to add the sale order id in the custom create values. :param int sale_order_id: The sale order for which a payment id made, as a `sale.order` id :param dict custom_create_values: Additional create values overwriting the default ones :return: The result of the parent method :rtype: recordset of `payment.transaction` """ if sale_order_id: if custom_create_values is None: custom_create_values = {} # As this override is also called if the flow is initiated from sale or website_sale, we # need not to override whatever value these modules could have already set if 'sale_order_ids' not in custom_create_values: # We are in the payment module's flow custom_create_values['sale_order_ids'] = [Command.set([int(sale_order_id)])] return super()._create_transaction( *args, sale_order_id=sale_order_id, custom_create_values=custom_create_values, **kwargs )