path: root/indoteknik_custom/models/automatic_purchase.py

from odoo import models, api, fields
from odoo.exceptions import UserError
from datetime import datetime
import logging, math

_logger = logging.getLogger(__name__)


class AutomaticPurchase(models.Model):
    _name = 'automatic.purchase'
    _order = 'id desc'
    _inherit = ['mail.thread']
    _rec_name = 'number'

    number = fields.Char(string='Document No', index=True, copy=False, readonly=True)
    date_doc = fields.Date(string='Date', required=True, help='Isi tanggal hari ini')
    description = fields.Char(string='Description', help='bebas isi nya apa')
    purchase_lines = fields.One2many('automatic.purchase.line', 'automatic_purchase_id', string='Lines', auto_join=True)
    notification = fields.Char(string='Notification')
    is_po = fields.Boolean(string='Is PO')
    purchase_match = fields.One2many('automatic.purchase.match', 'automatic_purchase_id', string='PO Matches', auto_join=True)
    vendor_id = fields.Many2one('res.partner', string='Vendor', help='boleh kosong, jika diisi, maka hanya keluar data untuk vendor tersebut')
    responsible_id = fields.Many2one('res.users', string='Responsible', required=True)
    apo_type = fields.Selection([
        ('regular', 'Regular Fulfill SO'),
        ('reordering', 'Reordering Rule'),
    ], string='Type', tracking=3)
    sales_match = fields.One2many('automatic.purchase.sales.match', 'automatic_purchase_id', string='SO Matches', auto_join=True)
    total_qty_line = fields.Float(string='Total Qty Line', compute='_compute_total_qty')
    total_qty_so = fields.Float(string='Total Qty SO', compute='_compute_total_qty')

    def _compute_total_qty(self):
        for data in self:
            qty_line = qty_so = 0
            for line in self.purchase_lines:
                qty_line = qty_line + line.qty_purchase
            for line in self.sales_match:
                qty_so = qty_so + line.qty_so
            data.total_qty_line = qty_line
            data.total_qty_so = qty_so

    @api.model
    def create(self, vals):
        vals['number'] = self.env['ir.sequence'].next_by_code('automatic.purchase') or '0'
        result = super(AutomaticPurchase, self).create(vals)
        return result
    
    def validate_so_is_po(self):
        # TODO user can't create po if in so exist matches po
        sale_ids = self.env['automatic.purchase.sales.match'].search([
            ('automatic_purchase_id', '=', self.id),
        ])

        names = []
        for sale in sale_ids:
            names.append(sale.sale_id.name)

        count = len(sale_ids)

        if count > 0:
            raise UserError('Ada sekitar %s SO Yang sudah create PO, berikut SO nya: %s' % (count, ', '.join(names)))

            
    def create_po_from_automatic_purchase(self):
        if not self.purchase_lines:
            raise UserError('Tidak ada Lines, belum bisa create PO')
        if self.is_po:
            raise UserError('Sudah pernah di create PO')

        # self.validate_so_is_po()

        current_time = datetime.now()
        vendor_ids = self.env['automatic.purchase.line'].read_group(
            [('automatic_purchase_id', '=', self.id), ('partner_id', '!=', False)],
            fields=['partner_id'],
            groupby=['partner_id']
        )

        counter = 0
        for vendor in vendor_ids:
            self.create_po_by_vendor(vendor['partner_id'][0])
            
            # param_header = {
            #     'partner_id': vendor['partner_id'][0],
            #     'currency_id': 12,
            #     'user_id': self.env.user.id,
            #     'company_id': 1,  # indoteknik dotcom gemilang
            #     'picking_type_id': 28,  # indoteknik bandengan receipts
            #     'date_order': current_time,
            #     'note_description': 'Automatic PO'
            # }

            # products_vendors = self.env['automatic.purchase.line'].search([
            #     ('automatic_purchase_id', '=', self.id),
            #     ('partner_id', '=', vendor['partner_id'][0]),
            #     ('qty_purchase', '>', 0)
            # ], order='brand_id')
            # counter += 1
            # new_po = self.env['purchase.order'].create([param_header])
            # new_po.name = new_po.name + "/A/" + str(counter)
            # self.env['automatic.purchase.match'].create([{
            #     'automatic_purchase_id': self.id,
            #     'order_id': new_po.id
            # }])
            # self.env.cr.commit()

            # count = 0
            # for product in products_vendors:
            #     if count == 20:
            #         self.create_purchase_order_sales_match(new_po)

            #     if count == 20:
            #         counter += 1
            #         new_po = self.env['purchase.order'].create([param_header])
            #         new_po.name = new_po.name + "/B/" + str(counter)
            #         self.env['automatic.purchase.match'].create([{
            #             'automatic_purchase_id': self.id,
            #             'order_id': new_po.id
            #         }])

            #         self.create_purchase_order_sales_match(new_po)
            #         self.env.cr.commit()

            #     count += 1
            #     qty_available = (
            #         product.product_id.qty_onhand_bandengan +
            #         product.product_id.qty_incoming_bandengan -
            #         product.product_id.outgoing_qty
            #     )
            #     suggest = 'harus beli' if qty_available <= product.qty_purchase else 'masih cukup'
            #     param_line = {
            #         'order_id': new_po.id,
            #         'product_id': product.product_id.id,
            #         'product_qty': product.qty_purchase,
            #         'qty_available_store': qty_available,
            #         'suggest': suggest,
            #         'product_uom_qty': product.qty_purchase,
            #         'price_unit': product.last_price,
            #     }
            #     new_line = self.env['purchase.order.line'].create([param_line])
            #     product.current_po_id = new_po.id
            #     product.current_po_line_id = new_line.id

            # self.create_purchase_order_sales_match(new_po)
    
        self.notification = 'PO Created successfully'
        self.is_po = True
        
    def create_po_by_vendor(self, vendor_id):
        current_time = datetime.now()

        PRODUCT_PER_PO = 20

        auto_purchase_line = self.env['automatic.purchase.line']

        param_header = {
            'partner_id': vendor_id,
            'currency_id': 12,
            'user_id': self.env.user.id,
            'company_id': 1,  # indoteknik dotcom gemilang
            'picking_type_id': 28,  # indoteknik bandengan receipts
            'date_order': current_time,
            'note_description': 'Automatic PO'
        }

        domain = [
            ('automatic_purchase_id', '=', self.id),
            ('partner_id', '=', vendor_id),
            ('qty_purchase', '>', 0)
        ]

        products_len = auto_purchase_line.search_count(domain)
        page = math.ceil(products_len / PRODUCT_PER_PO)
        
        # i start from zero (0)
        for i in range(page):
            new_po = self.env['purchase.order'].create([param_header])
            new_po.name = new_po.name + "/A/" + str(i + 1)

            self.env['automatic.purchase.match'].create([{
                'automatic_purchase_id': self.id,
                'order_id': new_po.id
            }])

            lines = auto_purchase_line.search(
                domain, 
                offset=i * PRODUCT_PER_PO, 
                limit=PRODUCT_PER_PO
            )

            for line in lines:
                product = line.product_id
                param_line = {
                    'order_id': new_po.id,
                    'product_id': product.id,
                    'product_qty': line.qty_purchase,
                    'qty_available_store': product.qty_available_bandengan,
                    'suggest': product._get_po_suggest(line.qty_purchase),
                    'product_uom_qty': line.qty_purchase,
                    'price_unit': line.last_price,
                }
                new_po_line = self.env['purchase.order.line'].create([param_line])
                line.current_po_id = new_po.id
                line.current_po_line_id = new_po_line.id
        
            self.create_purchase_order_sales_match(new_po)


    def create_purchase_order_sales_match(self, purchase_order):
        matches_so_product_ids = [line.product_id.id for line in purchase_order.order_line]

        matches_so = self.env['automatic.purchase.sales.match'].search([
            ('automatic_purchase_id', '=', self.id),
            ('sale_line_id.product_id', 'in', matches_so_product_ids),
        ])

        for sale_order in matches_so:
            matches_so_line = {
                'purchase_order_id': purchase_order.id,
                'sale_id': sale_order.sale_id.id,
                'sale_line_id': sale_order.sale_line_id.id,
                'picking_id': sale_order.picking_id.id,
                'move_id': sale_order.move_id.id,
                'partner_id': sale_order.partner_id.id,
                'partner_invoice_id': sale_order.partner_invoice_id.id,
                'salesperson_id': sale_order.salesperson_id.id,
                'product_id': sale_order.product_id.id,
                'qty_so': sale_order.qty_so,
                'qty_po': sale_order.qty_po,
            }
            po_matches_so_line = self.env['purchase.order.sales.match'].create([matches_so_line])
        
        self.create_sales_order_purchase_match(purchase_order)
    
    def create_sales_order_purchase_match(self, purchase_order):
        #TODO add matches po to sales order by automatic_purchase.sales.match
        matches_po_product_ids = [line.product_id.id for line in purchase_order.order_line]

        sales_match_line = self.env['automatic.purchase.sales.match'].search([
            ('automatic_purchase_id', '=', self.id),
            ('sale_line_id.product_id', 'in', matches_po_product_ids),
        ])

        for sales_match in sales_match_line:
            purchase_line = self.env['automatic.purchase.line'].search([
                ('automatic_purchase_id', '=', self.id),
                ('product_id', 'in', [sales_match.product_id.id]),
            ])

            matches_po_line = {
                'sales_order_id' : sales_match.sale_id.id,
                'purchase_order_id' : purchase_line.current_po_id.id,
                'purchase_line_id' : purchase_line.current_po_line_id.id,
                'product_id' : sales_match.product_id.id,
                'qty_so' : sales_match.qty_so,
                'qty_po' : sales_match.qty_po,
            }

            sales_order_purchase_match = self.env['sales.order.purchase.match'].create([matches_po_line])

    def generate_regular_purchase(self):
        if self.apo_type == 'reordering':
            raise UserError('Tombol ini hanya untuk Regular Fulfill SO')
        if self.vendor_id:
            raise UserError('Vendor tidak dapat diisi jika Regular Fulfill SO')
        if self.purchase_lines:
            raise UserError('Sudah digenerate sebelumnya, hapus line terlebih dahulu')
        #TODO must add order by for fifo mechanism
        #change the view of v.purchasing.job and use order by in query
        query = [
            ('action', '=', 'kurang beli')
        ]
        jobs = self.env['v.purchasing.job'].search(query)
        count = 0
        for job in jobs:
            qty_purchase = job.outgoing - job.onhand + job.incoming
            qty_available = job.onhand + job.incoming - job.outgoing

            domain = [
                ('product_id.id', '=', job.product_id.id),
            ]
            orderby = 'count_trx_po desc, count_trx_po_vendor desc'
            purchase_pricelist = self.env['purchase.pricelist'].search(domain, order=orderby, limit=1)

            vendor_id = purchase_pricelist.vendor_id
            price = self._get_valid_purchase_price(purchase_pricelist)
            last_po_line = self.env['purchase.order.line'].search([('product_id', '=', job.product_id.id), ('order_id.state', '=', 'done')], order='id desc', limit=1)

            self.env['automatic.purchase.line'].create([{
                'automatic_purchase_id': self.id,
                'product_id': job.product_id.id,
                'qty_purchase': qty_purchase,
                'qty_available': qty_available,
                'partner_id': vendor_id.id,
                'last_price': price,
                'subtotal': qty_purchase * price,
                'last_order_id': last_po_line.order_id.id,
                'last_orderline_id': last_po_line.id,
                'brand_id': job.product_id.product_tmpl_id.x_manufacture.id
            }])
            count += 1
            _logger.info('Create Automatic Purchase Line %s' % job.product_id.name)
        self.notification = "Automatic PO Created %s Lines" % count
        self._create_sales_matching()
        print(1)

    def _create_sales_matching(self):
        for line in self.purchase_lines:
            domain = [
                ('product_id', '=', line.product_id.id)
            ]
            sales = self.env['v.sales.outstanding'].search(domain)
            for sale in sales:
                if line.qty_purchase > sale.outgoing:
                    qty_po = sale.outgoing
                else:
                    qty_po = line.qty_purchase
                self.env['automatic.purchase.sales.match'].create([{
                    'automatic_purchase_id': self.id,
                    'sale_id': sale.sale_id.id,
                    'sale_line_id': sale.sale_line_id.id,
                    'picking_id': sale.picking_id.id,
                    'move_id': sale.move_id.id,
                    'partner_id': sale.partner_id.id,
                    'partner_invoice_id': sale.partner_invoice_id.id,
                    'salesperson_id': sale.salesperson_id.id,
                    'product_id': sale.product_id.id,
                    'qty_so': sale.outgoing,
                    'qty_po': qty_po,
                }])
        print(1)

    def generate_automatic_purchase(self):
        # for reordering rule only
        if self.apo_type == 'regular':
            raise UserError('Tombol ini hanya untuk Reordering Rule')
        if self.purchase_lines:
            raise UserError('Sudah digenerate sebelumnya, hapus line terlebih dahulu')
        
        query = [
            ('product_min_qty', '>', 0),
            ('product_id.x_manufacture.user_id.id', '=', self.responsible_id.id)
        ]
        orderpoints = self.env['stock.warehouse.orderpoint'].search(query)
        count = 0
        for point in orderpoints:
            # _logger.info('test %s' % point.product_id.name)
            if point.product_id.virtual_available > point.product_min_qty:
                continue
            qty_purchase = point.product_max_qty - point.product_id.virtual_available
            po_line = self.env['purchase.order.line'].search([('product_id', '=', point.product_id.id), ('order_id.state', '=', 'done')], order='id desc', limit=1)
            
            if self.vendor_id:
                purchase_price = self.env['purchase.pricelist'].search([
                    ('product_id', '=', point.product_id.id),
                    # ('product_id.x_manufacture.user_id.id', '=', self.responsible_id.id),
                    ('vendor_id', '=', self.vendor_id.id)
                ], order='count_trx_po desc, count_trx_po_vendor desc', limit=1)
            else:
                purchase_price = self.env['purchase.pricelist'].search([
                    ('product_id', '=', point.product_id.id),
                    # ('product_id.x_manufacture.user_id.id', '=', self.responsible_id.id),
                ], order='count_trx_po desc, count_trx_po_vendor desc', limit=1)

            vendor_id = purchase_price.vendor_id.id
            price = self._get_valid_purchase_price(purchase_price)

            if self.vendor_id and self.vendor_id.id != vendor_id:
                continue

            self.env['automatic.purchase.line'].create([{
                'automatic_purchase_id': self.id,
                'product_id': point.product_id.id,
                'qty_purchase': qty_purchase,
                'qty_min': point.product_min_qty,
                'qty_max': point.product_max_qty,
                'qty_available': point.product_id.virtual_available,
                # 'partner_id': po_line.order_id.partner_id.id,
                # 'last_price': po_line.price_unit,
                'partner_id': vendor_id,
                'last_price': price,
                'subtotal': qty_purchase * price,
                'last_order_id': po_line.order_id.id,
                'last_orderline_id': po_line.id,
                'brand_id': point.product_id.product_tmpl_id.x_manufacture.id
            }])
            count += 1
            _logger.info('Create Automatic Purchase Line %s' % point.product_id.name)
        self.notification = "Automatic PO Created %s Lines" % count

    def _get_valid_purchase_price(self, purchase_price):
        p_price = 0
        if purchase_price.system_price > 0 and purchase_price.product_price > 0:
            if purchase_price.human_last_update > purchase_price.system_last_update:
                p_price = purchase_price.product_price
            else:
                p_price = purchase_price.system_price
        elif purchase_price.system_price > 0 and purchase_price.product_price == 0:
            p_price = purchase_price.system_price
        elif purchase_price.system_price == 0 and purchase_price.product_price > 0:
            p_price = purchase_price.product_price
        return p_price


class AutomaticPurchaseLine(models.Model):
    _name = 'automatic.purchase.line'
    _description = 'Automatic Purchase Line'
    _order = 'automatic_purchase_id, id'

    automatic_purchase_id = fields.Many2one('automatic.purchase', string='Ref', required=True, ondelete='cascade', index=True, copy=False)
    product_id = fields.Many2one('product.product', string='Product')
    qty_purchase = fields.Float(string='Qty Purchase')
    qty_min = fields.Float(string='Qty Min')
    qty_max = fields.Float(string='Qty Max')
    qty_available = fields.Float(string='Qty Available')
    partner_id = fields.Many2one('res.partner', string='Vendor')
    last_price = fields.Float(string='Last Price')
    subtotal = fields.Float(string='Subtotal')
    last_order_id = fields.Many2one('purchase.order', string='Last Order')
    last_orderline_id = fields.Many2one('purchase.order.line', string='Last Order Line')
    is_po = fields.Boolean(String='Is PO')
    current_po_id = fields.Many2one('purchase.order', string='Current')
    current_po_line_id = fields.Many2one('purchase.order.line', string='Current Line')
    brand_id = fields.Many2one('x_manufactures', string='Brand')

    @api.onchange('last_price', 'qty_purchase')
    def _calculate_subtotal(self):
        for line in self:
            line.subtotal = line.qty_purchase * line.last_price


class AutomaticPurchaseMatch(models.Model):
    _name = 'automatic.purchase.match'
    _order = 'automatic_purchase_id, id'

    automatic_purchase_id = fields.Many2one('automatic.purchase', string='Ref', required=True, ondelete='cascade', index=True, copy=False)
    order_id = fields.Many2one('purchase.order', string='Purchase Order')
    vendor = fields.Char(string='Vendor', compute='_compute_info_po')
    total = fields.Float(string='Total', compute='_compute_info_po')

    def _compute_info_po(self):
        for match in self:
            match.vendor = match.order_id.partner_id.name
            match.total = match.order_id.amount_total


class AutomaticPurchaseSalesMatch(models.Model):
    _name = 'automatic.purchase.sales.match'
    _order = 'automatic_purchase_id, id'

    automatic_purchase_id = fields.Many2one('automatic.purchase', string='Ref', required=True, ondelete='cascade', index=True, copy=False)
    automatic_purchase_line_id = fields.Many2one('automatic.purchase.line', string='Automatic Line')
    sale_id = fields.Many2one('sale.order', string='SO')
    sale_line_id = fields.Many2one('sale.order.line', string='SO Line')
    picking_id = fields.Many2one('stock.picking', string='Picking')
    move_id = fields.Many2one('stock.move', string='Move')
    partner_id = fields.Many2one('res.partner', string='Partner')
    partner_invoice_id = fields.Many2one('res.partner', string='Invoice Partner')
    salesperson_id = fields.Many2one('res.users', string='Sales')
    product_id = fields.Many2one('product.product', string='Product')
    qty_so = fields.Float(string='Qty SO')
    qty_po = fields.Float(string='Qty PO')