path: root/indoteknik_api/controllers/api_v1/sale_order.py

from .. import controller
from odoo import http
from datetime import datetime, timedelta
from odoo.http import request
import json


class SaleOrder(controller.Controller):
    prefix = '/api/v1/'
    PREFIX_PARTNER = prefix + 'partner/<partner_id>/'

    @http.route(prefix + "sale_order/<id>/reject/<product_id>", auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized()
    def reject_sale_order_line(self, **kw):
        so_id = int(kw.get('id', '0'))
        product_id = int(kw.get('product_id', '0'))
        params = self.get_request_params(kw, {
            'reason_reject': []
        })

        sale_order_line = request.env['sale.order.line'].search([
            ('product_id', '=', product_id), 
            ('order_id', '=', so_id)
            ], limit=1)

        if sale_order_line:
            parameters = {
                'sale_order_id': sale_order_line.order_id.id,
                'product_id': sale_order_line.product_id.id,
                'qty_reject': sale_order_line.product_uom_qty,
                'reason_reject': params['value']['reason_reject'],
            }

            sale_order_reject = request.env['sales.order.reject'].create(parameters)

            sale_order_line.unlink()

            return self.response('work')
        else:
            return self.response('Sale order line not found', status=404)
    
    @http.route(prefix + "sale_order_number", auth='public', method=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def get_number_sale_order(self, **kw):
        # for midtrans only
        sale_order_id = int(kw.get('sale_order_id', '0'))
        sale_number = str(kw.get('sale_number', ''))
        if sale_order_id > 0:
            query = [('id', '=', sale_order_id)]
            # sales = request.env['sale.order'].search_read([('id', '=', sale_order_id)], fields=['id', 'name', 'amount_total', 'state'])
            sales = request.env['sale.order'].search(query, limit=1)
        else:
            query = [('name', '=', sale_number)]
            # sales = request.env['sale.order'].search_read([('name', '=', sale_number)], fields=['id', 'name', 'amount_total', 'state'])
            sales = request.env['sale.order'].search(query, limit=1)
        data = []
        for sale in sales:
            product_name = ''
            product_not_in_id = 0
            for line in sale.order_line:
                product_name = line.product_id.name
                product_not_in_id = line.product_id.id
                break
            data.append({
                'id': sale.id,
                'name': sale.name,
                'date_order': self.time_to_str(sale.date_order, '%d/%m/%Y %H:%M:%S'),
                'state': sale.state,
                'amount_untaxed': sale.amount_untaxed,
                'amount_tax': sale.amount_tax,
                'amount_total': sale.amount_total,
                'product_name': product_name,
                'product_not_in_id': product_not_in_id,
                'details': [request.env['sale.order.line'].api_single_response(x, context='with_detail') for x in sale.order_line]
            })

        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order', auth='public', method=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def get_partner_sale_order(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'name': [],
            'site': [],
            'limit': ['default:0', 'number'],
            'offset': ['default:0', 'number'],
            'context': []
        })
        limit = params['value']['limit']
        offset = params['value']['offset']
        if not params['valid']:
            return self.response(code=400, description=params)

        partner_child_ids = self.get_partner_child_ids(
            params['value']['partner_id'])
        domain = [('partner_id', 'in', partner_child_ids)]

        context = params['value']['context']
        if context == 'quotation':
            domain += ["|", "|", ("state", "=", "draft"),
                       ("state", "=", "sent"), ("state", "=", "cancel")]
        if not context:
            domain += ["|", ("state", "=", "sale"), ("state", "=", "done")]

        if params['value']['name']:
            name = params['value']['name'].replace(' ', '%')
            domain += [
                '|',
                ('name', 'ilike', '%' + name + '%'),
                ('partner_purchase_order_name', 'ilike', '%' + name + '%')
            ]
        
        if params['value']['site']:
            site = params['value']['site'].replace(' ', '%')
            domain += [
                ('partner_id.site_id.name', 'ilike', '%' + site + '%')
            ]

        sale_orders = request.env['sale.order'].search(
            domain, offset=offset, limit=limit)
        data = {
            'sale_order_total': request.env['sale.order'].search_count(domain),
            'sale_orders': [request.env['sale.order'].api_v1_single_response(x) for x in sale_orders]
        }
        
        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>', auth='public', method=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def partner_get_sale_order_detail(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        if not params['valid']:
            return self.response(code=400, description=params)

        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [('id', '=', params['value']['id']), ('partner_id', 'in', partner_child_ids)]
        data = {}
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            data = request.env['sale.order'].api_v1_single_response(sale_order, context='with_detail')

        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/checkout', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def partner_checkout_sale_order_by_id(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number'],
            'status': ['boolean']
        })
        if not params['valid']:
            return self.response(code=400, description=params)

        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = {}
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            if 'status' in params['value']:
                sale_order.is_continue_transaction = params['value']['status']

            if sale_order._requires_approval_margin_leader():
                sale_order.approval_status = 'pengajuan2'
            elif sale_order._requires_approval_margin_manager():
                sale_order.approval_status = 'pengajuan1'
                
            data = request.env['sale.order'].api_v1_single_response(
                sale_order, context='with_detail')

        return self.response(data)
    
    @http.route(PREFIX_PARTNER + 'sale_order/<id>/approve', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def partner_approve_sale_order_by_id(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        
        if not params['valid']:
            return self.response(code=400, description=params)
        
        value = params['value']
        partner_child_ids = self.get_partner_child_ids(value['partner_id'])
        
        sale_order = request.env['sale.order'].search([
            ('id', '=', value['id']),
            ('partner_id', 'in', partner_child_ids)
        ])
        if not sale_order:
            return self.response(code=404, description='Sale Order not found')
        
        partner = request.env['res.partner'].browse(value['partner_id'])
        if not partner.web_role:
            return self.response(code=400, description='Unauthorized')
        
        if partner.web_role:
            sale_order.web_approval = 'cust_%s' % partner.web_role
            
        if sale_order.web_approval in ['cust_procurement', 'cust_director']:
            if sale_order._requires_approval_margin_leader():
                sale_order.approval_status = 'pengajuan2'
            elif sale_order._requires_approval_margin_manager():
                sale_order.approval_status = 'pengajuan1'

        return self.response('success')
    
    @http.route(PREFIX_PARTNER + 'sale_order/<id>/reject', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def partner_reject_sale_order_by_id(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        
        if not params['valid']:
            return self.response(code=400, description=params)
        
        value = params['value']
        partner_child_ids = self.get_partner_child_ids(value['partner_id'])
        
        sale_order = request.env['sale.order'].search([
            ('id', '=', value['id']),
            ('partner_id', 'in', partner_child_ids)
        ])
        if not sale_order:
            return self.response(code=404, description='Sale Order not found')
        
        partner = request.env['res.partner'].browse(value['partner_id'])
        if not partner.web_role:
            return self.response(code=400, description='Unauthorized')
        
        if partner.web_role:
            sale_order.web_approval = 'cust_%s' % partner.web_role
        
        sale_order.state = 'cancel'
        sale_order.approval_status = False

        return self.response('success')

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/upload_po', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    def partner_upload_po_sale_order(self, **kw):
        user_token = self.authenticate()
        if not user_token:
            return self.unauthorized_response()

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number'],
            'name': [],
            'file': []
        })
        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        if not params['valid']:
            return self.response(code=400, description=params)
        partner_child_ids = self.get_partner_child_ids(
            params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = False
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            sale_order.partner_purchase_order_name = params['value']['name']
            sale_order.client_order_ref = params['value']['name']
            sale_order.partner_purchase_order_file = params['value']['file']
            data = sale_order.id
        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/download_po/<token>', auth='none', method=['GET'])
    def partner_download_po_sale_order(self, id, token):
        id = int(id)

        rest_api = request.env['rest.api']
        md5_valid = rest_api.md5_salt_valid(id, 'sale.order', token)
        if not md5_valid:
            return self.response('Unauthorized')

        sale_order = request.env['sale.order'].sudo().search_read(
            [('id', '=', id)], ['partner_purchase_order_name'])
        attachment = rest_api.get_single_attachment(
            'sale.order', 'partner_purchase_order_file', id)
        if attachment and len(sale_order) > 0:
            return rest_api.response_attachment({
                'content': attachment['datas'],
                'decode_content': True,
                'mimetype': attachment['mimetype'],
                'filename': sale_order[0]['partner_purchase_order_name'] + '.pdf'
            })
        return self.response('Dokumen tidak ditemukan', code=404)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/download/<token>', auth='none', method=['GET'])
    def partner_download_sale_order(self, id, token):
        id = int(id)

        rest_api = request.env['rest.api']
        md5_valid = rest_api.md5_salt_valid(id, 'sale.order', token)
        if not md5_valid:
            return self.response('Unauthorized')

        sale_order = request.env['sale.order'].sudo().search_read([('id', '=', id)], ['name'])
        pdf, type = request.env['ir.actions.report'].sudo().search([('report_name', '=', 'quotation_so_new')]).render_jasper([id], {})
        # pdf, type = request.env['ir.actions.report'].sudo().search([('report_name', '=', 'indoteknik_custom.report_saleorder_website')])._render_qweb_pdf([id])
        
        if pdf and len(sale_order) > 0:
            return rest_api.response_attachment({
                'content': pdf,
                'mimetype': 'application/pdf',
                'filename': sale_order[0]['name'] + '.pdf'
            })
        return self.response('Dokumen tidak ditemukan', code=404)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/cancel', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def partner_cancel_sale_order(self, **kw):
        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        if not params['valid']:
            return self.response(code=400, description=params)

        partner_child_ids = self.get_partner_child_ids(
            params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = False
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            sale_order.state = 'cancel'
            data = sale_order.id
        return self.response(data)
        
    @http.route(prefix + 'user/<user_id>/sale_order/checkout', auth='public', method=['GET', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized(private=True, private_key='user_id')
    def get_user_checkout_so(self, user_id, **kw):
        m_voucher = request.env['voucher']
        m_cart = request.env['website.user.cart']
        
        voucher_code = kw.get('voucher')
        voucher_shipping_code = kw.get('voucher_shipping')
        source = kw.get('source')
        
        voucher = m_voucher.search([('code', '=', voucher_code), ('apply_type', 'in', ['all', 'brand'])], limit=1)
        voucher_shipping = m_voucher.search([('code', '=', voucher_shipping_code), ('apply_type', '=', 'shipping')], limit=1)
        result = m_cart.with_context(price_for="web").get_user_checkout(
            user_id, 
            voucher=voucher, 
            voucher_shipping=voucher_shipping, 
            source=source
        )
        return self.response(result)
    
    @http.route(PREFIX_PARTNER + 'sale_order/checkout', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    @controller.Controller.must_authorized()
    def create_partner_sale_order(self, **kw):
        config = request.env['ir.config_parameter']
        product_pricelist_default_discount_id = int(config.get_param('product.pricelist.tier1_v2'))
        user_pricelist = request.env.context.get('user_pricelist').id or False

        params = self.get_request_params(kw, {
            'user_id': ['number'],
            'partner_id': ['number'],
            'partner_shipping_id': ['required', 'number'],
            'partner_invoice_id': ['required', 'number'],
            'order_line': ['required', 'default:[]'],
            'po_number': [],
            'po_file': [],
            'type': [],
            'delivery_amount': ['number', 'default:0'],
            'carrier_id': [],
            'delivery_service_type': [],
            'flash_sale': ['boolean'],
            'note_website': [],
            'voucher': [],
            'source': [],
            'estimated_arrival_days': ['number', 'default:0'],
            'estimated_arrival_days_start': ['number', 'default:0']
        })
        
        if not params['valid']:
            return self.response(code=400, description=params)

        # Fetch partner details
        sales_partner = request.env['res.partner'].browse(params['value']['partner_id'])
        partner_invoice = request.env['res.partner'].browse(params['value']['partner_invoice_id'])
        main_partner = partner_invoice.get_main_parent()
        parameters = {
            'warehouse_id': 8,
            'carrier_id': 1,
            'sales_tax_id': 23,
            'pricelist_id': user_pricelist or product_pricelist_default_discount_id,
            'payment_term_id': 26,
            'team_id': 2,
            'company_id': 1,
            'currency_id': 12,
            'source_id': 59,
            'state': 'draft',
            'picking_policy': 'direct',
            'partner_id': params['value']['partner_id'],
            'partner_shipping_id': params['value']['partner_shipping_id'],
            'real_shipping_id': params['value']['partner_shipping_id'],
            'partner_invoice_id': main_partner.id,
            'real_invoice_id': params['value']['partner_invoice_id'],
            'partner_purchase_order_name': params['value']['po_number'],
            'partner_purchase_order_file': params['value']['po_file'],
            'delivery_amt': params['value']['delivery_amount'] * 1.10,
            'estimated_arrival_days': params['value']['estimated_arrival_days'],
            'estimated_arrival_days_start': params['value']['estimated_arrival_days_start'],
            'shipping_cost_covered': 'customer',
            'shipping_paid_by': 'customer',
            'carrier_id': params['value']['carrier_id'],
            'delivery_service_type': params['value']['delivery_service_type'],
            'flash_sale': params['value']['flash_sale'], 
            'note_website': params['value']['note_website'],
            'customer_type': sales_partner.customer_type if sales_partner else 'nonpkp',  # Get Customer Type from partner
            'npwp': sales_partner.npwp or '0',  # Get NPWP from partner
            'sppkp': sales_partner.sppkp,  # Get SPPKP from partner
            'email': sales_partner.email,  # Get Email from partner
            'user_id': 11314  # User ID: Boy Revandi
        }
        
        sales_partner = request.env['res.partner'].browse(parameters['partner_id'])
        if sales_partner and sales_partner.user_id and sales_partner.user_id.id not in [25]: # 25: System
            parameters['user_id'] = sales_partner.user_id.id    
            
        if params['value']['type'] == 'sale_order':
            parameters['approval_status'] = 'pengajuan1'
        sale_order = request.env['sale.order'].create([parameters])
        sale_order.onchange_partner_contact()

        user_id = params['value']['user_id']
        user_cart = request.env['website.user.cart']
        source = params['value']['source']
        carts = user_cart.get_product_by_user(user_id=user_id, selected=True, source=source)

        promotions = []
        for cart in carts:
            if cart['cart_type'] == 'product':
                order_line = request.env['sale.order.line'].create({
                    'company_id': 1,
                    'order_id': sale_order.id,
                    'product_id': cart['id'],
                    'product_uom_qty': cart['quantity'],
                    'product_available_quantity': cart['available_quantity']
                })
                order_line.product_id_change()
                order_line.onchange_vendor_id()
                order_line.price_unit = cart['price']['price']
                order_line.discount = cart['price']['discount_percentage']
            elif cart['cart_type'] == 'promotion':
                promotions.append({
                    'order_id': sale_order.id,
                    'program_line_id': cart['id'],
                    'quantity': cart['quantity']
                })
        
        sale_order._compute_etrts_date()

        request.env['sale.order.promotion'].create(promotions)
        
        if len(promotions) > 0:
            sale_order.apply_promotion_program()
            sale_order.add_free_product(promotions)

        voucher_code = params['value']['voucher']
        voucher = request.env['voucher'].search([('code', '=', voucher_code),('apply_type', 'in', ['all', 'brand'])], limit=1)
        voucher_shipping = request.env['voucher'].search([('code', '=', voucher_code),('apply_type', 'in', ['shipping'])], limit=1)
        if voucher and len(promotions) == 0:
            sale_order.voucher_id = voucher.id
            sale_order.apply_voucher()
        
        if voucher_shipping and len(promotions) == 0:
            sale_order.voucher_shipping_id = voucher_shipping.id
            sale_order.apply_voucher_shipping()

        cart_ids = [x['cart_id'] for x in carts]
        if sale_order._requires_approval_margin_leader(): #jika ada error tambahkan kondisi if params['value']['type'] == 'sale_order':
            sale_order.approval_status = 'pengajuan2'
        elif sale_order._requires_approval_margin_manager():
            sale_order.approval_status = 'pengajuan1'
        # user_cart.browse(cart_ids).unlink()
        return self.response({
            'id': sale_order.id,
            'name': sale_order.name
        })
    
    @http.route(PREFIX_PARTNER + 'sale-order/<id>/awb', auth='public', methods=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized(private=True, private_key='partner_id')
    def get_airway_bill_by_sale_order_id(self, **kw):
        id = int(kw.get('id', 0))
        response = {'airways': None}
        airway_bills = request.env['airway.bill'].search([('so_id', '=', id)])

        if not airway_bills:
            return self.response(response)

        airways = []
        for airway_bill in airway_bills:
            data = airway_bill.decode_response()
            delivery_order = airway_bill.do_id
            result = data['rajaongkir']['result'] 
            
            manifests_data = []
            for manifest in airway_bill.manifest_ids:
                manifest_data = {
                    'code': manifest.code,
                    'description': manifest.description,
                    'datetime': datetime.strftime(manifest.datetime, '%Y-%m-%d %H:%M:%S'),
                    'city': manifest.city,
                }
                manifests_data.append(manifest_data)
            
            airways.append({
                'delivery_order': {
                    'name': delivery_order.name,
                    'carrier': delivery_order.carrier_id.name,
                    'receiver_name': airway_bill.receiver_name,
                    'receiver_city': airway_bill.receiver_city,
                },
                'delivered': result['delivered'],  
                'waybill_number': result['summary']['waybill_number'],
                'delivery_status': result['delivery_status'],
                'manifests': manifests_data
            })
        response = {'airways': airways}

        return self.response(response)
        
    @http.route('/api/sale_order/invoiced', auth='public', methods=['GET'])
    def get_sale_order_invoiced_by_partner_id(self, **kw):
        if not self.authenticate():
            return self.unauthorized_response()

        partner_id = kw.get('partner_id')
        if not partner_id:
            return self.response(code=400, description='Field partner_id is required')

        partner_id = int(partner_id)
        # Get company member by partner_id
        parent_partner_id = request.env['res.partner'].search(
            [('id', '=', partner_id)], limit=1).parent_id.id
        partner_childs = request.env['res.partner'].search(
            [('parent_id', '=', int(parent_partner_id))])
        partner_child_ids = [v['id'] for v in partner_childs] + [partner_id]

        # Get sale order by company member and invoiced
        data = []
        default_domain = [
            ('partner_id', 'in', partner_child_ids),
            ('state', 'in', ['sale', 'done'])
        ]
        sale_orders = self.search_filter('sale.order', kw, default_domain)
        for sale_order in sale_orders:
            pickings = []
            for picking in sale_order.picking_ids:
                if picking.state in ['confirmed', 'assigned', 'done']:
                    pickings.append({
                        'id': picking.id,
                        'name': picking.name,
                        'delivery_address': picking.partner_id.street,
                        'delivery_tracking_no': picking.delivery_tracking_no,
                        'delivery_status': picking.delivery_status
                    })

            data.append({
                'id': sale_order.id,
                'name': sale_order.name,
                'amount_total': sale_order.amount_total,
                'salesperson': sale_order.user_id.name,
                'date_order': self.time_to_str(sale_order.date_order, '%d/%m/%Y'),
                'pickings': pickings,
                'access_token': sale_order.access_token
            })
        return self.response(data)

    @http.route('/api/sale_order/invoiced/detail', auth='public', methods=['GET'])
    def get_sale_order_invoiced_detail_by_partner(self, **kw):
        if not self.authenticate():
            return self.unauthorized_response()

        id = kw.get('id')
        partner_id = kw.get('partner_id')
        if not id:
            return self.response(code=400, description='Field id is required')
        if not partner_id:
            return self.response(code=400, description='Field partner_id is required')

        default_domain = [
            ('id', '=', id),
            ('state', 'in', ['sale', 'done'])
        ]
        parent_partner_id = request.env['res.partner'].search(
            [('id', '=', int(partner_id))], limit=1).parent_id.id
        partner_childs = request.env['res.partner'].search(
            [('parent_id', '=', int(parent_partner_id))])
        partner_child_ids = [v['id']
                             for v in partner_childs] + [int(partner_id)]
        default_domain.append(('partner_id', 'in', partner_child_ids))

        sale_order = self.search_filter('sale.order', kw, default_domain)
        orders = []
        for order in sale_order.order_line:
            orders.append({
                'name': order.name,
                'product_qty': order.product_qty,
                'price_unit': order.price_unit,
                'price_tax': order.price_tax,
                'price_total': order.price_total,
                'price_subtotal': order.price_subtotal,
                'tax': order.tax_id.name,
                'discount': order.discount,
            })

        data = {
            'id': sale_order.id,
            'name': sale_order.name,
            'carrier': sale_order.carrier_id.name,
            'partner': {
                'id': sale_order.partner_id.id,
                'name': sale_order.partner_id.name,
                'mobile': sale_order.partner_id.mobile,
                'email': sale_order.partner_id.email
            },
            'delivery_address': sale_order.partner_shipping_id.street,
            'delivery_method': sale_order.carrier_id.name,
            'payment_term': sale_order.payment_term_id.name,
            'salesperson': sale_order.user_id.name,
            'date_order': self.time_to_str(sale_order.date_order, '%d/%m/%Y %H:%M:%S'),
            'note': sale_order.note,
            'amount_untaxed': sale_order.amount_untaxed,
            'amount_tax': sale_order.amount_tax,
            'amount_total': sale_order.amount_total,
            'orders': orders
        }

        return self.response(data)

    @http.route(prefix + 'tracking_order', auth='public', method=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def tracking_get_sale_order_detail(self, **kw):
        # Extract 'so' and 'email' parameters from query parameters
        so = kw.get('so')
        email_user = kw.get('email')

        if not email_user or not so:
            return self.response({
                'code': 400,
                'so': so,
                'email': email_user,
                'description': "Email and Sale Order number are required."
            })

        # Search for the sale order by the name (so)
        sale_order = request.env['sale.order'].search([('name', '=', so)], limit=1)
        if not sale_order:
            return self.response({
                'code': 404,
                'so': so,
                'email': email_user,
                'description': "Sale Order not found."
            })

        # Get the partner associated with the sale order
        partner = sale_order.partner_id
        company_id = partner.company_id.id

        # Search for all partners within the same company
        partners_in_company = request.env['res.partner'].search([('company_id', '=', company_id)])

        # Check if the email matches any partner's email in the same company
        email_match = partners_in_company.filtered(lambda p: p.email == email_user)
        if not email_match:
            return self.response({
                'code': 403,
                'so': so,
                'email': email_user,
                'description': "Email does not match any partner in the same company as the Sale Order."
            })

        # Check for partner child ids if needed
        partner_child_ids = self.get_partner_child_ids(partner.id)
        if sale_order.partner_id.id not in partner_child_ids:
            return self.response({
                'code': 403,
                'so': so,
                'email': email_user,
                'description': "Unauthorized access to Sale Order details."
            })

        # Prepare the response data
        data = request.env['sale.order'].api_v1_single_response(sale_order, context='with_detail')

        return self.response(data)