Shaumux

class purchase_order(osv.Model):
    _inherit = 'purchase.order'


    def action_invoice_create(self, cr, uid, ids, context=None):
        """Generates invoice for given ids of purchase orders and links that invoice ID to purchase order.
        :param ids: list of ids of purchase orders.
        :return: ID of created invoice.
        :rtype: int
        """
        res = {}
        res = super(purchase_order, self).action_invoice_create(cr, uid, ids, context=context)
        for order in self.browse(cr, uid, ids, context=context):
            import pdb;pdb.set_trace()
            self.pool.get('account.invoice').write(cr, uid, res,
                                                   {'insurance_type':order.insurance_type,
                                                    'insurance':order.insurance,
                                                    'freight_type':order.freight_type,
                                                    'freight':order.freight,
                                                    'other_discount':order.other_discount,
                                                    'discount_percentage':order.discount_percentage,
                                                    'commission':order.commission, 'packing_type':order.packing_type,
                                                    'package_and_forwording':order.package_and_forwording,
                                                    'taxes_ids':[(6, 0, [excies_id.id for excies_id in order.excies_ids] \
                                                                 + [vat_id.id for vat_id in order.vat_ids])],
                                                    })
        return res



class account_invoice_tax(osv.osv):
    _inherit = 'account.invoice.tax'

    def compute(self, cr, uid, invoice_id, context=None):
        res = super(account_invoice_tax, self).compute(cr, uid, invoice_id, context=None)
        account_tax_obj = self.pool.get('account.tax')
        cur_obj = self.pool.get('res.currency')
        inv = self.pool.get('account.invoice').browse(cr, uid, invoice_id, context=context)
        cur = inv.currency_id
        tax_grouped = {}
        company_currency = self.pool['res.company'].browse(cr, uid, inv.company_id.id).currency_id.id
        for tax in account_tax_obj.compute_all(cr, uid, inv.taxes_ids, inv.other_charges, 1, None, inv.partner_id)['taxes']:
            val = {}
            val['invoice_id'] = inv.id
            val['name'] = tax['name']
            val['amount'] = tax['amount']
            val['manual'] = False
            val['sequence'] = tax['sequence']
            val['base'] = cur_obj.round(cr, uid, cur, tax['price_unit'])
#                 import pdb;pdb.set_trace()

            if inv.type in ('out_invoice', 'in_invoice'):
                val['base_code_id'] = tax['base_code_id']
                val['tax_code_id'] = tax['tax_code_id']
                val['base_amount'] = cur_obj.compute(cr, uid, inv.currency_id.id, company_currency, val['base'] * tax['base_sign'], context={'date': inv.date_invoice or time.strftime('%Y-%m-%d')}, round=False)
                val['tax_amount'] = cur_obj.compute(cr, uid, inv.currency_id.id, company_currency, val['amount'] * tax['tax_sign'], context={'date': inv.date_invoice or time.strftime('%Y-%m-%d')}, round=False)
                val['account_id'] = tax['account_collected_id']
                val['account_analytic_id'] = tax['account_analytic_collected_id']
            else:
                val['base_code_id'] = tax['ref_base_code_id']
                val['tax_code_id'] = tax['ref_tax_code_id']
                val['base_amount'] = cur_obj.compute(cr, uid, inv.currency_id.id, company_currency, val['base'] * tax['ref_base_sign'], context={'date': inv.date_invoice or time.strftime('%Y-%m-%d')}, round=False)
                val['tax_amount'] = cur_obj.compute(cr, uid, inv.currency_id.id, company_currency, val['amount'] * tax['ref_tax_sign'], context={'date': inv.date_invoice or time.strftime('%Y-%m-%d')}, round=False)
                val['account_id'] = tax['account_paid_id']
                val['account_analytic_id'] = tax['account_analytic_paid_id']

            key = (val['tax_code_id'], val['base_code_id'], val['account_id'], val['account_analytic_id'])
            import pdb;pdb.set_trace()
            if not key in tax_grouped:
                tax_grouped[key] = val
            else:
                tax_grouped[key]['amount'] += val['amount']
                tax_grouped[key]['base'] += val['base']
                tax_grouped[key]['base_amount'] += val['base_amount']
                tax_grouped[key]['tax_amount'] += val['tax_amount']
        for t in tax_grouped.values():
            t['base'] = cur_obj.round(cr, uid, cur, t['base'])
            t['amount'] = cur_obj.round(cr, uid, cur, t['amount'])
            t['base_amount'] = cur_obj.round(cr, uid, cur, t['base_amount'])
            t['tax_amount'] = cur_obj.round(cr, uid, cur, t['tax_amount'])
#         import pdb;pdb.set_trace()
        for key in res:
            tax_code_id = key[0]
            base_code_id = key[1]
            import pdb;pdb.set_trace()
            tax_id = account_tax_obj.search(cr, uid, [('tax_code_id', '=', tax_code_id), ('base_code_id', '=', base_code_id)], context=context)
            res[key]['amount'] += tax_grouped[key]['amount']
            res[key]['base'] += tax_grouped[key]['base']
            res[key]['base_amount'] += tax_grouped[key]['base_amount']
            res[key]['tax_amount'] += tax_grouped[key]['tax_amount']
            for ids in tax_id:
                tax_categ = account_tax_obj.browse(cr, uid, ids, context=context).tax_categ
                res[key]['tax_categ'] = tax_categ
        return res