path: root/fixco_custom/models/upload_ginee.py

from odoo import models, fields, api, _
from datetime import datetime
import base64
import xlrd
from odoo.exceptions import ValidationError, UserError
import requests
import json
import hmac
from hashlib import sha256

API_BASE_URL = "https://api.ginee.com"
BATCH_GET_URI = '/openapi/order/v1/batch-get'
LIST_ORDER_URI = '/openapi/order/v2/list-order'
ACCESS_KEY = '24bb6a1ec618ec6a'
SECRET_KEY = '32e4a78ad05ee230'

class UploadGinee(models.Model):
    _name = "upload.ginee"
    _description = "Upload Ginee"
    _order = "create_date desc"
    _rec_name = "number"

    ginee_lines = fields.One2many('upload.ginee.line', 'upload_ginee_id', 
                                  string='Lines', copy=False, auto_join=True)
    number = fields.Char('Number', copy=False)
    date_upload = fields.Datetime('Upload Date', copy=False)
    user_id = fields.Many2one('res.users', 'Created By', default=lambda self: self.env.user.id)
    excel_file = fields.Binary('Excel File', attachment=True)
    filename = fields.Char('File Name')
    upload_type = fields.Selection([
        ('rehit', 'Rehit'),
        ('blibli', 'Blibli'),
    ], 'Upload Type')

    @api.model
    def create(self, vals):
        vals['number'] = self.env['ir.sequence'].next_by_code('upload.ginee') or '/'
        return super().create(vals)

    def action_import_excel(self):
        self.ensure_one()
        if not self.excel_file:
            raise ValidationError(_("Please upload an Excel file first."))
        
        try:
            file_content = base64.b64decode(self.excel_file)
            workbook = xlrd.open_workbook(file_contents=file_content)
            sheet = workbook.sheet_by_index(0)
        except:
            raise ValidationError(_("Invalid Excel file format."))
        
        header = [str(sheet.cell(0, col).value).strip().lower() for col in range(sheet.ncols)]
        expected_headers = ['marketplace', 'shop', 'invoice']
        
        if not all(h in header for h in expected_headers):
            raise ValidationError(_("Invalid Excel format. Expected columns: Marketplace, Shop, Invoice"))
        
        marketplace_col = header.index('marketplace')
        shop_col = header.index('shop')
        invoice_col = header.index('invoice')
        
        # Store rows for validation and processing
        rows_data = []
        for row_idx in range(1, sheet.nrows):
            try:
                marketplace = str(sheet.cell(row_idx, marketplace_col).value).strip()
                shop = str(sheet.cell(row_idx, shop_col).value).strip()
                invoice_marketplace = str(sheet.cell(row_idx, invoice_col).value).strip()
                rows_data.append((row_idx + 1, marketplace, shop, invoice_marketplace))  # +1 for 1-based Excel row
            except Exception as e:
                continue
        
        # Validasi 1: Jika ada BLIBLI_ID di Marketplace, upload_type harus blibli
        has_blibli_id = any("BLIBLI_ID" in row[1].upper() for row in rows_data)
        if has_blibli_id and self.upload_type != 'blibli':
            raise ValidationError(_("Excel contains BLIBLI_ID in Marketplace. Please select Blibli as the upload type."))
        
        # Validasi 2: Untuk upload_type blibli, semua Marketplace harus mengandung BLIBLI_ID
        if self.upload_type == 'blibli':
            invalid_rows = []
            for row_data in rows_data:
                row_num = row_data[0]
                marketplace = row_data[1]
                if "BLIBLI_ID" not in marketplace.upper():
                    invalid_rows.append(str(row_num))
            
            if invalid_rows:
                error_msg = _("For Blibli uploads, 'Marketplace' must contain 'BLIBLI_ID'. Errors in rows: %s")
                raise ValidationError(error_msg % ", ".join(invalid_rows))
        
        # Validasi 3: Cek duplikat invoice_marketplace di sistem
        existing_invoices = set()
        invoice_to_check = [row_data[3] for row_data in rows_data]
        
        # Search in chunks to avoid too long SQL queries
        chunk_size = 500
        for i in range(0, len(invoice_to_check), chunk_size):
            chunk = invoice_to_check[i:i+chunk_size]
            existing_records = self.env['upload.ginee.line'].search([
                ('invoice_marketplace', 'in', chunk)
            ])
            existing_invoices.update(existing_records.mapped('invoice_marketplace'))
        
        duplicate_rows = []
        for row_data in rows_data:
            row_num = row_data[0]
            invoice_marketplace = row_data[3]
            if invoice_marketplace in existing_invoices:
                duplicate_rows.append(str(row_num))
        
        if duplicate_rows:
            error_msg = _("Invoice Marketplace already exists in the system. Duplicates found in rows: %s")
            raise ValidationError(error_msg % ", ".join(duplicate_rows))
        
        # Prepare lines for import
        line_vals_list = []
        for row_data in rows_data:
            marketplace = row_data[1]
            shop = row_data[2]
            invoice_marketplace = row_data[3]
            line_vals = {
                'marketplace': marketplace,
                'shop': shop,
                'invoice_marketplace': invoice_marketplace,
                'upload_ginee_id': self.id,
            }
            line_vals_list.append((0, 0, line_vals))
        
        # Update record
        self.ginee_lines.unlink()
        self.write({'ginee_lines': line_vals_list})
        
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': _('Success'),
                'message': _('Imported %s lines from Excel.') % len(line_vals_list),
                'sticky': False,
                'next': {'type': 'ir.actions.act_window_close'},
            }
        }


    def _show_notification(self, message):
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': _('Success'),
                'message': message,
                'sticky': False,
            }
        }

    def action_get_order_id(self):
        self.date_upload = datetime.utcnow()
        self.ginee_lines.get_order_id()

    def action_create_detail_order(self):
        self.date_upload = datetime.utcnow()
        self.ginee_lines.create_so_and_detail_order()

    def action_get_order_id_and_create_detail_order(self):
        self.date_upload = datetime.utcnow()
        self.ginee_lines.get_order_id()
        self.ginee_lines.create_so_and_detail_order()
            
class UploadGineeLine(models.Model):
    _name = "upload.ginee.line"
    _description = "Upload Ginee Line"
    _inherit = ['mail.thread']

    upload_ginee_id = fields.Many2one('upload.ginee', string='Upload')
    marketplace = fields.Char('Marketplace')
    shop = fields.Char('Shop')
    invoice_marketplace = fields.Char('Invoice Marketplace')
    order_id = fields.Char('Order ID')
    message_error = fields.Text('Error Message')
    detail_order_id = fields.Many2one('detail.order', string='Detail Order')
    is_grouped = fields.Boolean('Is Grouped', default=False)
    group_key = fields.Char('Group Key')

    def _process_grouped_blibli_orders(self, lines):
        """Process a group of BLIBLI orders with the same invoice prefix"""
        order_ids = [line.order_id for line in lines if line.order_id]
        
        if not order_ids:
            raise UserError(_('Order ID is empty for one or more records in group!'))
        
        # Check if any of these orders already exist
        existing_detail = self.env['detail.order'].search([
            ('detail_order', 'ilike', order_ids[0])
        ], limit=1)
        
        if existing_detail:
            return existing_detail
        
        # Call API with all order IDs in the group
        data = lines[0]._call_api(BATCH_GET_URI, {"orderIds": order_ids})
        
        # Combine items from all orders in the group
        combined_items = []
        for order_data in data.get('data', []):
            combined_items.extend(order_data.get('items', []))
        
        # Create a modified json_data structure that includes all items
        combined_json_data = {
            'data': [{
                **data.get('data', [{}])[0],  # Keep all original fields from first order
                'items': combined_items,       # Combined items from all orders
                'shopId': data.get('data', [{}])[0].get('shopId'),
                'externalOrderId': ', '.join([line.invoice_marketplace for line in lines]),
                'orderId': ', '.join(order_ids),  # Mark as grouped
            }]
        }
        
        detail_order = self.env['detail.order'].create({
            'detail_order': json.dumps(combined_json_data, indent=4),
            'source': 'manual',
        })
        return detail_order

    def _sign_request(self, uri):
        """Membuat tanda tangan sesuai format yang berhasil"""
        sign_data = f'POST${uri}$'
        signature = hmac.new(
            SECRET_KEY.encode('utf-8'),
            sign_data.encode('utf-8'),
            digestmod=sha256
        ).digest()
        return f"{ACCESS_KEY}:{base64.b64encode(signature).decode('ascii')}"

    def _call_api(self, uri, payload):
        """Memanggil API dengan autentikasi yang benar"""
        headers = {
            'Content-Type': 'application/json',
            'X-Advai-Country': 'ID',
            'Authorization': self._sign_request(uri)
        }
        
        response = requests.post(
            f"{API_BASE_URL}{uri}",
            headers=headers,
            data=json.dumps(payload)
        )
        
        if response.status_code != 200:
            error_msg = f"API Error ({response.status_code}): {response.text}"
            raise UserError(_(error_msg))
        
        return response.json()

    def create_so_and_detail_order(self):
        # First group BLIBLI orders by their invoice prefix
        grouped_lines = {}
        for rec in self:
            if rec.upload_ginee_id.upload_type == 'blibli' and '-' in rec.invoice_marketplace:
                prefix = rec.invoice_marketplace.split('-')[0]
                if prefix not in grouped_lines:
                    grouped_lines[prefix] = []
                grouped_lines[prefix].append(rec)
            else:
                # For non-BLIBLI or BLIBLI without dash, process individually
                grouped_lines[rec.id] = [rec]
        
        # Process each group
        for group_key, lines in grouped_lines.items():
            try:
                if len(lines) > 1:
                    # Process grouped BLIBLI orders
                    detail_order = self._process_grouped_blibli_orders(lines)
                    
                    # Update all lines in the group
                    for line in lines:
                        line.update({
                            'message_error': 'Success (grouped)',
                            'detail_order_id': detail_order.id
                        })
                        detail_order.execute_queue_detail()
                else:
                    # Process single line (non-grouped)
                    line = lines[0]
                    if not line.order_id:
                        raise UserError(_('Order ID is empty!'))
                    
                    if self.env['detail.order'].search([('detail_order', 'ilike', line.order_id)]):
                        raise UserError(_(
                            "Order ID %s already exists in Detail Orders") % line.order_id)
                    
                    data = line._call_api(BATCH_GET_URI, {"orderIds": [line.order_id]})
                    detail_order = self.env['detail.order'].create({
                        'detail_order': json.dumps(data, indent=4),
                        'source': 'manual',
                    })
                    detail_order.execute_queue_detail()
                    
                    line.update({
                        'message_error': 'Success',
                        'detail_order_id': detail_order.id
                    })
                    
            except Exception as e:
                # Update all lines in group with error if any
                for line in lines:
                    line.message_error = str(e)

    def get_order_id(self):
        for rec in self:
            try:
                if rec.order_id:
                    continue
                if self.search_count([
                    ('marketplace', '=', rec.marketplace),
                    ('invoice_marketplace', '=', rec.invoice_marketplace),
                    ('id', '!=', rec.id)
                ]):
                    raise UserError(_(
                        "Invoice %s already exists") % rec.invoice_marketplace)
                
                data = rec._call_api(
                    LIST_ORDER_URI,
                    {
                        "channel": rec.marketplace,
                        "orderNumbers": [rec.invoice_marketplace]
                    }
                )
                
                orders = data.get('data', {}).get('content', [])
                if orders:
                    rec.order_id = orders[0].get('orderId')
                    rec.message_error = 'Success'
                else:
                    raise UserError(_("No orders found for invoice: %s") % rec.invoice_marketplace)
            
            except Exception as e:
                rec.message_error = str(e)