Merge lp:~vauxoo/openerp-venezuela-localization/hbto_src_fix_islr into lp:openerp-venezuela-localization

[hbto [Vauxoo] http://www.vauxoo.com]

Se reparo el subtrayendo de el 1% y se cambio la presicion decimal de ISLR a 4 digitos se agrego una validacion
y se coloco un comentario sobre el cambio

[hbto [Vauxoo] http://www.vauxoo.com (humbertoarocha)]

Debido a que el codigo entre version 6 y 7 de la localizacion tuvo muchos cambios,

se hará una revision de los metodos, uno a uno, y se para revisar que partes del
codigo se pueden reutilizar.

review: Needs Fixing

Unmerged revisions

583. By Jose Moreno on 2012-02-15

[FIX] Se reparo el subtrayendo de el 1% y se cambio la presicion decimal de ISLR a 4 digitos se agrego una validacion
y se coloco un comentario sobre el cambio

582. By Jose Moreno on 2012-02-14

[FIX] Se reparo el subtrayendo de el 1% y se cambio la presicion decimal de ISLR a 4 digitos

=== modified file 'l10n_ve_withholding_islr/data/l10n_ve_islr_withholding_data.xml'
--- l10n_ve_withholding_islr/data/l10n_ve_islr_withholding_data.xml	2013-08-13 19:53:40 +0000
+++ l10n_ve_withholding_islr/data/l10n_ve_islr_withholding_data.xml	2013-12-05 22:26:23 +0000
@@ -4,7 +4,7 @@
         <!-- Decimal Precision -->
         <record forcecreate="True" id="decimal_withhold_islr" model="decimal.precision">
             <field name="name">Withhold ISLR</field>
-            <field name="digits">2</field>
+            <field name="digits">4</field>
         </record>
     <!-- Begin of Concepts -->
         <record id="islr_wh_concept_no_apply_withholding" model="islr.wh.concept">

=== modified file 'l10n_ve_withholding_islr/model/invoice.py'
--- l10n_ve_withholding_islr/model/invoice.py	2013-12-04 21:17:57 +0000
+++ l10n_ve_withholding_islr/model/invoice.py	2013-12-05 22:26:23 +0000
@@ -215,6 +215,601 @@
             list.append((x, y, res))
         return list
 
+<<<<<<< TREE
+=======
+    def _get_partners(self, cr, uid, invoice):
+        '''
+        Se obtiene: el id del vendedor, el id del comprador de la factura y el campo booleano que determina si el comprador es agente de retencion.
+        '''
+        if invoice.type == 'in_invoice' or invoice.type == 'in_refund':
+            vendor = invoice.partner_id
+            buyer = invoice.company_id.partner_id
+        else:
+            buyer = invoice.partner_id
+            vendor = invoice.company_id.partner_id
+        return (vendor, buyer, buyer.islr_withholding_agent)
+
+    def _get_concepts(self, cr, uid, invoice):
+        '''
+        Se obtienen una lista de Conceptos(concept_id), de las lineas en la factura
+        '''
+        service_list = []
+        for invoice_line in invoice.invoice_line:
+            if invoice_line.concept_id and invoice_line.concept_id.withholdable:
+                service_list.append(invoice_line.concept_id.id)
+            else:
+                pass
+        return list(set(service_list))
+        
+    def _get_service_wh(self, cr, uid, invoice, concept_list):
+        '''
+        Obtiene todas las lineas de factura del vendedor, filtrando por el periodo de la factura actual y el estado de la factura = done, open.
+        Las lineas son almacenadas en un diccionario, donde la primera clave es la lista de lineas obtenidas, la segunda es el campo que indica si alguna de esas lineas
+        fue retenida y el tercer campo es la suma de la base de todas las lineas que no se les ha aplicado retencion.
+        La busqueda de las lineas, se realiza buscando lineas que tengan conceptos de retencion igual a los de la factura actual.
+        Esto se hace con el fin de verificar:
+            1.-Si existe el mismo concepto en otra linea de factura que no se ha retenido porque no ha superado el monto minimo, se toma para realizar la suma y verificar 
+               si con el nuevo monto si supera, en consecuencia se realiza la retencion en las facturas asociadas.
+            2.-Se verifica si es la primera vez que se realiza retencion sobre ese concepto, de ser la primera vez se debe aplicar el sustraendo. Esto se hace con el 
+               segundo campo del diccionario "wh"
+        '''
+        dict={}
+        for key in concept_list:
+            dict[key]={'lines':[],'wh':False,'base':0.0}
+        inv_obj = self.pool.get('account.invoice')
+        inv_lst = inv_obj.search(cr, uid,[('partner_id', '=', invoice.partner_id.id),('period_id','=',invoice.period_id.id),('state','in',['done','open'])]) # Lista de  facturas asociadas al proveedor actual, al periodo actual y al estado de las facturas: donde, open.
+        
+        inv_line_lst=[]
+        for id in inv_lst:
+            inv_line_brw = inv_obj.browse(cr, uid, id).invoice_line #lista de lineas de facturas
+            for line in inv_line_brw:
+                if line.concept_id and  line.concept_id.id in concept_list: # Se verifica si el concepto de la linea en la que estoy buscando coincide con alguno de los conceptos de la factura actual.
+                    if not line.apply_wh: # Se verifica si a la linea no se le ha aplicado retencion, de ser asi se almacena el id de la linea y la base.
+                        dict[line.concept_id.id]['lines'].append(line.id)
+                        dict[line.concept_id.id]['base']+= line.price_subtotal
+                    else:  # Si ya se le aplico retencion, no se guarda el id porque no hace falta pero se indica que ya se le aplico retencion.
+                        dict[line.concept_id.id]['wh']=True
+        #~ dict[key]={'lines':[],'wh':False,'base':0.0}
+        return dict
+
+    def _get_country_fiscal(self,cr, uid, partner_id):
+        '''
+        Se obtiene el pais de el vendedor o comprador, depende del parametro. A partir de de la direccion fiscal.
+        '''
+        for i in partner_id.address:
+            if i.type == 'invoice':
+                if not i.country_id:
+                    raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the partner '%s' country has not defined direction in fiscal!") % (partner_id.name))
+                    return False
+                else:
+                    return i.country_id.id
+        raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the partner '%s' has not fiscal direction set!.") % (partner_id.name))
+        return False
+
+    def _get_residence(self, cr, uid, vendor, buyer):
+        '''
+        Se determina si la direccion fiscal del comprador es la misma que la del vendedor, con el fin de luego obtener la tasa asociada.
+        Retorna True si es una persona domiciliada o residente. Retorna False si es, no Residente o No Domicialiado.
+        '''
+        vendor_address = self._get_country_fiscal(cr, uid, vendor)
+        buyer_address = self._get_country_fiscal(cr, uid, buyer)
+        if vendor_address and buyer_address:
+            if vendor_address ==  buyer_address:
+                return True
+            else:
+                return False
+        return False
+
+    def _get_nature(self, cr, uid, partner_id):
+        '''
+        Se obtiene la naturaleza del vendedor a partir del RIF, retorna True si es persona de tipo natural, y False si es juridica.
+        '''
+        if not partner_id.vat:
+            raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the partner '%s' has not vat associated!") % (partner_id.name))
+            return False
+        else:
+            if partner_id.vat[2:3] in 'VvEe':
+                return True
+            else:
+                return False
+
+    def _get_rate(self, cr, uid, concept_id, residence, nature,context):
+        '''
+        Se obtiene la tasa del concepto de retencion, siempre y cuando exista uno asociado a las especificaciones:
+           La naturaleza del vendedor coincida con una tasa.
+           La residencia del vendedor coindica con una tasa.
+        '''
+        ut_obj = self.pool.get('l10n.ut')
+        rate_brw_lst = self.pool.get('islr.wh.concept').browse(cr, uid, concept_id).rate_ids
+        for rate_brw in rate_brw_lst:
+            if rate_brw.nature == nature and rate_brw.residence == residence:
+                #~ (base,min,porc,sust,codigo,id_rate,name_rate)
+                rate_brw_minimum = ut_obj.compute_ut_to_money(cr, uid, rate_brw.minimum, False, context)#metodo que transforma los UVT en pesos
+                rate_brw_subtract = ut_obj.compute_ut_to_money(cr, uid, rate_brw.subtract, False, context)#metodo que transforma los UVT en pesos
+                return (rate_brw.base, rate_brw_minimum, rate_brw.wh_perc, rate_brw_subtract,rate_brw.code,rate_brw.id,rate_brw.name)
+        return ()
+    
+    def _get_rate_dict(self, cr, uid, concept_list, residence, nature,context):
+        '''
+        Devuelve un diccionario con la tasa de cada concepto de retencion.
+        '''
+        dict = {}
+        cont = 0
+        for concept_id in concept_list:
+            dict[concept_id] = self._get_rate(cr, uid, concept_id, residence, nature,context)
+            if dict[concept_id]:
+                cont += 1
+        if not cont:
+            raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the Concept of Withholding associated with type line is not withheld!"))
+        return dict
+
+
+    def _pop_dict(self,cr,uid,concept_list,dict_rate,wh_dict):
+        '''
+        Funcion para eliminar del diccionario de conceptos con tasas y del diccionario de lineas de facturas, todos aquellos elementos donde el concepto de retencion no 
+        posee una tasa asociada.
+        '''
+        for concept in concept_list:
+            if not dict_rate[concept]:
+                dict_rate.pop(concept)
+                wh_dict.pop(concept)
+
+    def _get_wh_calc(self,cr,uid,line,dict_rate_concept):
+        base = self.pool.get('account.invoice.line').browse(cr,uid,line).price_subtotal
+        return (base * (dict_rate_concept[0]/100) * (dict_rate_concept[2]/100), base)
+
+    def _get_number(self,cr,uid,number,long):
+        num1 = number[::-1]
+        result= ''
+        for i in num1:
+            if i.isdigit():
+                if len(result)<long:
+                    result = i + result
+                else:
+                    break
+            else:
+                break
+        return result.strip()
+
+
+    def _get_inv_data(self,cr, uid, line):
+        '''
+        Se obtiene el rif de proveedor, el numero de la factura y el numero de control de la factura. Datos necesarios para el XML, entre otros.
+        '''
+        inv_brw = self.pool.get('account.invoice.line').browse(cr, uid, line).invoice_id
+        vat = inv_brw.partner_id.vat[2:]
+        if inv_brw.type == 'in_invoice' or inv_brw.type == 'in_refund':
+            #~ number = inv_brw.reference.strip() 
+            if not inv_brw.reference:
+                raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income,because the invoice number: '%s' has not number reference free!") % (inv_brw.number))
+                number = 0
+            else:
+                number = self._get_number(cr,uid,inv_brw.reference.strip(),10)
+        else:
+            if not inv_brw.number:
+                number = 0
+            else:
+                number = self._get_number(cr,uid,inv_brw.number.strip(),10)
+        if not inv_brw.nro_ctrl:
+            raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the invoice number: '%s' has not control number associated!") % (inv_brw.number))
+        else:
+            control = self._get_number(cr,uid,inv_brw.nro_ctrl.strip(),8)
+
+        return (vat, number, control)
+
+    def _write_wh_apply(self,cr, uid,line,dict,apply,type):
+        '''
+        Si el campo wh_xml_id en la linea de la factura tiene un id de xml asociado:
+            Se escribe sobre el campo booleano de la linea de la factura True o False, dependiendo si se retiene o no.
+            Se escribe sobre la linea de xmls el valor de la retencion. Esto sucede porque se pudo haber creado la linea xml, pero con retencion 0, porque no aplicaba, si llega a superar en otra factura, se debe sobreescribir el valor al nuevo monto de retencion.
+        De lo contrario:
+            Se crea una nueva linea de xml.
+            Se escribe en la linea de la factura, True o False y se asigna el xml_id que resulta del create.
+        '''
+        il_ids = self.pool.get('account.invoice.line').browse(cr, uid,line)
+
+        if il_ids.wh_xml_id:
+            self.pool.get('account.invoice.line').write(cr, uid, line, {'apply_wh': apply})
+            self.pool.get('islr.xml.wh.line').write(cr,uid,il_ids.wh_xml_id.id,{'wh':dict['wh']})
+        else:
+            if type in ('out_invoice', 'out_refund'):
+                self.pool.get('account.invoice.line').write(cr, uid, line, {'apply_wh': apply})
+            else:
+                self.pool.get('account.invoice.line').write(cr, uid, line, {'apply_wh': apply,'wh_xml_id':self._create_islr_xml_wh_line(cr, uid,line,dict)})
+                message = _("Withholding income xml line generated.")
+                self.log(cr, uid, line, message)
+                
+    def _create_islr_xml_wh_line(self,cr, uid, line, dict):
+        '''
+        Se crea una linea de xml
+        '''
+        inv_id = self.pool.get('account.invoice.line').browse(cr, uid,line).invoice_id
+        return self.pool.get('islr.xml.wh.line').create(cr, uid, {'name': dict['name_rate'],
+        'concept_id': dict['concept'], 
+        'period_id':  inv_id.period_id.id,
+        'partner_vat':dict['vat'],
+        'invoice_number': dict['number'],
+        'control_number': dict['control'],
+        'concept_code':dict['code'],
+        'base': dict['subtotal'],
+        'porcent_rete':dict['perc'],
+        'wh':dict['wh'],
+        'rate_id': dict['rate_id'],
+        'account_invoice_line_id': line,
+        'account_invoice_id': inv_id.id,
+        'partner_id': inv_id.partner_id.id,
+        })
+
+    def _get_wh(self,cr, uid, subtract,concept, wh_dict, dict_rate, apply,context=None):
+        '''
+        Retorna un diccionario, con todos los valores de la retencion de una linea de factura.
+        '''
+        if context is None:
+            context={}
+        res= {}
+        inv_obj= self.pool.get('account.invoice')
+        if apply: # Si se va a aplicar retencion.
+            for line in wh_dict[concept]['lines']:
+                wh_calc, subtotal = self._get_wh_calc(cr,uid,line,dict_rate[concept]) # Obtengo el monto de retencion y el monto base sobre el cual se retiene
+                if subtract >= wh_calc:
+                    wh = 0.0
+                    subtract -= wh_calc
+                else:
+                    wh = wh_calc - subtract
+                    subtract_write= subtract
+                    subtract=0.0
+                inv_id = self.pool.get('account.invoice.line').browse(cr, uid,line).invoice_id.id
+                type = inv_obj.browse(cr,uid,inv_id).type
+                res[line]={ 'vat': self._get_inv_data(cr, uid, line)[0],
+                            'number': self._get_inv_data(cr, uid, line)[1],
+                            'control': self._get_inv_data(cr, uid, line)[2],
+                            'concept': concept, 
+                            'code':dict_rate[concept][4],
+                            'subtotal': subtotal, 
+                            'perc':dict_rate[concept][2],
+                            'wh':wh,
+                            'apply':apply,
+                            'rate_id':dict_rate[concept][5],
+                            'name_rate': dict_rate[concept][6]}
+                if not context.get('test_from_wkf',False):
+                    self._write_wh_apply(cr,uid,line,res[line],apply,type)
+                    inv_obj.write(cr, uid, inv_id, {'status': 'pro'})
+        else: # Si no aplica retencion
+            for line in wh_dict[concept]['lines']:
+                subtotal = self._get_wh_calc(cr,uid,line,dict_rate[concept])[1]
+                inv_id = self.pool.get('account.invoice.line').browse(cr, uid,line).invoice_id.id
+                type = inv_obj.browse(cr,uid,inv_id).type
+                res[line]={ 'vat': self._get_inv_data(cr, uid, line)[0],
+                            'number': self._get_inv_data(cr, uid, line)[1],
+                            'control': self._get_inv_data(cr, uid, line)[2],
+                            'concept': concept, 
+                            'code':dict_rate[concept][4],
+                            'subtotal': subtotal, 
+                            'perc':dict_rate[concept][2],
+                            'wh':0.0,
+                            'apply':apply,
+                            'rate_id':dict_rate[concept][5],
+                            'name_rate': dict_rate[concept][6]}
+                if not context.get('test_from_wkf',False):
+                    self._write_wh_apply(cr,uid,line,res[line],apply,type)
+                    inv_obj.write(cr, uid, inv_id, {'status': 'pro'})
+        return res
+
+
+    def _get_wh_apply(self,cr,uid,dict_rate,wh_dict,nature,context=None):
+        '''
+        Retorna el diccionario completo con todos los datos para realizar la retencion, cada elemento es una linea de la factura.
+        '''
+        if context is None:
+            context={}
+        res = {}
+        for concept in wh_dict:
+            if not wh_dict[concept]['wh']:  #Si nunca se ha aplicado retencion con este concepto.
+                if wh_dict[concept]['base'] >= dict_rate[concept][1]: # Si el monto base que suman todas las lineas de la factura es mayor o igual al monto minimo de la tasa.
+                    subtract = dict_rate[concept][3]  # Obtengo el sustraendo a aplicar. Existe sustraendo porque es la primera vez.
+                    res.update(self._get_wh(cr, uid, subtract,concept, wh_dict, dict_rate, True,context=context))# El True sirve para asignar al campo booleano de la linea de la factura True, para asi marcar de una vez que ya fue retenida, para una posterior busqueda.
+                else: # Si el monto base no supera el monto minimo de la tasa(de igual forma se deb declarar asi no supere.)
+                    subtract = 0.0
+                    res.update(self._get_wh(cr, uid, subtract,concept, wh_dict, dict_rate, False,context=context))
+            else: #Si ya se aplico alguna vez la retencion, se aplica rete de una vez, sobre la base sin chequear monto minimo.(Dentro de este periodo)
+                if nature:
+                    subtract = dict_rate[concept][3]
+                    res.update(self._get_wh(cr, uid, subtract,concept, wh_dict, dict_rate, True,context=context))
+                else:
+                    subtract = 0.0
+                    res.update(self._get_wh(cr, uid, subtract,concept, wh_dict, dict_rate, True,context=context))# El True sirve para indicar que la linea si se va a retener.
+        return res
+
+
+    def _get_amount(self,cr,uid,dict):
+        '''
+        Funcion para obtener, la suma del monto retenido por concepto.
+        '''
+        dict_concept = {}
+        for key in dict:
+            x = dict[key]['concept']
+            y = dict[key]['wh']
+            if not dict_concept.get(x,False):
+                dict_concept[x] = y
+            else:
+                dict_concept[x]+= y
+        return dict_concept
+
+
+    def _get_dict_concepts(self,cr,uid,dict):
+        '''
+        Funcion para obtener, el dicccionario agrupado por concepto:  
+        {1:[{64: {'control': '', 'perc': 0.050000000000000003, 'concept': 1, 'number': False, 'wh': 0.0, 'code': u'A', 'rate_id': 1, 'apply': True, 'subtotal': 500.0, 'vat': u'J123456789'}}, 
+            {65: {'control': '', 'perc': 0.050000000000000003, 'concept': 1, 'number': False, 'wh': 0.0, 'code': u'A', 'rate_id': 1, 'apply': True, 'subtotal': 300.0, 'vat': u'J123456789'}}
+           ], 
+         2:[{63: {'control': '', 'perc': 0.029999999999999999, 'concept': 2, 'number': False, 'wh': 0.0, 'code': u'002', 'rate_id': 2, 'apply': True, 'subtotal': 1000.0, 'vat': u'J123456789'}}
+            ]}
+        '''
+        dict_concepts = {}
+        for key in dict:
+            x = dict[key]['concept']
+            y = dict[key]
+            if not dict_concepts.get(x,False):
+                if dict[key]['apply']:
+                    dict_concepts[x]=[]
+                    dict_concepts[x].append({key:y})
+            else:
+                if dict[key]['apply']:
+                    dict_concepts[x].append({key:y})
+        return dict_concepts
+
+
+    def get_journal(self,cr,uid,inv_brw):
+        '''
+        Funcion para asignar el diario correspondiente de acuerdo a cada tipo de retencion(compra, venta)
+        los tipos de diario son creados en retencion_iva
+        '''
+        tipo='Sale'
+        tipo2='islr_sale'
+        journal_id = None
+        journal_obj = self.pool.get('account.journal')
+        if inv_brw.type == 'out_invoice' or inv_brw.type =='out_refund':
+            journal_id = journal_obj.search(cr, uid, [('type', '=', 'islr_sale')], limit=1)
+        else:
+            journal_id = journal_obj.search(cr, uid, [('type', '=', 'islr_purchase')], limit=1)
+            tipo = 'Purchase'
+            tipo2 = 'islr_purchase'
+        if not journal_id:
+            raise osv.except_osv(_('Invalid action !'),_("Impossible withholding income, because the journal of withholding income for the '%s' has not been created with the type '%s'") % (tipo,tipo2))
+        
+        return journal_id[0] or None
+
+    def button_confirm(self, cr, uid, ids, context=None):
+        return self.write(cr, uid, ids, {'state': 'confirmed'})
+
+    def _create_islr_wh_doc(self,cr,uid,inv_brw,dict):
+        '''
+        Funcion para crear en el modelo islr_wh_doc
+        '''
+        islr_wh_doc_id=0 
+        wh_doc_obj = self.pool.get('islr.wh.doc')
+        inv_obj =self.pool.get('account.invoice.line')
+        inv_brw = inv_brw.invoice_id
+    
+        islr_wh_doc_id = wh_doc_obj.create(cr,uid,
+        {'name': wh_doc_obj.retencion_seq_get(cr, uid),
+        'partner_id': inv_brw.partner_id.id,
+        'invoice_id': inv_brw.id,
+        'period_id': inv_brw.period_id.id,
+        'account_id': inv_brw.account_id.id,
+        'type': inv_brw.type,
+        'journal_id': self.get_journal(cr,uid,inv_brw),})
+        
+        wf_service = netsvc.LocalService("workflow")
+        wf_service.trg_validate(uid, 'islr.wh.doc', islr_wh_doc_id, 'button_confirm', cr)
+#        wf_service.trg_write(uid, 'islr.wh.doc', islr_wh_doc_id, cr)
+
+        return islr_wh_doc_id
+
+
+    def _create_doc_line(self,cr,uid, inv_brw,key2,islr_wh_doc_id,dictt,dictc):
+        '''
+        Funcion para crear en el modelo islr_wh_doc_line
+        '''
+        doc_line_obj = self.pool.get('islr.wh.doc.line')
+        rate_obj = self.pool.get('islr.rates')
+        ut_obj = self.pool.get('l10n.ut')
+        dict_concept = self._get_amount(cr,uid,dictt)
+        inv_line_id = dictc[key2][0].keys()[0]
+        rate_id = dictc[key2][0][inv_line_id]['rate_id']
+        
+        ut_ids = ut_obj.search(cr,uid,[])
+        ut_brw = ut_obj.browse(cr,uid,ut_ids)
+        reg = 0.0
+        for ut in ut_brw:
+            if float(ut.name) > reg:
+               ut_amount = ut.amount
+               reg = float(ut.name)
+            
+        percent = rate_obj.browse(cr,uid,rate_id).wh_perc
+        subtract = rate_obj.browse(cr,uid,rate_id).subtract
+        valor = subtract * ut_amount
+        
+        #Se Agrego esta Validación para las cooperativas
+        if percent == 1.0:
+            islr_wh_doc_line_id = doc_line_obj.create(cr,uid,
+            {'islr_wh_doc_id':islr_wh_doc_id,
+            'concept_id':key2,
+            'islr_rates_id':rate_id,
+            'invoice_id': inv_brw.invoice_id.id,
+            'retencion_islr': rate_obj.browse(cr,uid,rate_id).wh_perc,
+            'amount':dict_concept[key2]-valor,})
+        else:
+            islr_wh_doc_line_id = doc_line_obj.create(cr,uid,
+            {'islr_wh_doc_id':islr_wh_doc_id,
+            'concept_id':key2,
+            'islr_rates_id':rate_id,
+            'invoice_id': inv_brw.invoice_id.id,
+            'retencion_islr': rate_obj.browse(cr,uid,rate_id).wh_perc,
+            'amount':dict_concept[key2],})
+            
+        return islr_wh_doc_line_id
+
+    def _create_doc_invoices(self,cr,uid,key,islr_wh_doc_id):
+        '''
+        Funcion para crear en el modelo islr_wh_doc_invoices
+        '''
+        doc_inv_obj = self.pool.get('islr.wh.doc.invoices')
+        inv_id = key
+        islr_wh_doc_invoices_id = doc_inv_obj.create(cr,uid,{'invoice_id':inv_id,'islr_wh_doc_id':islr_wh_doc_id})
+        
+    def _write_wh_xml(self,cr,uid,key,islr_wh_doc_line_id):
+        '''
+        Funcion para escribir en el modelo xml_wh_line
+        '''
+        inv_obj =self.pool.get('account.invoice.line')
+        xml_obj = self.pool.get('islr.xml.wh.line')
+        xml_id = inv_obj.browse(cr,uid,key).wh_xml_id.id
+        xml_obj.write(cr, uid, xml_id, {'islr_wh_doc_line_id':islr_wh_doc_line_id})
+
+
+    def _get_inv_id(self,cr,uid,dict):
+        '''
+        Funcion para obtener el objeto_browse de la factura
+        '''
+        inv_obj =self.pool.get('account.invoice.line')
+        line_ids = [key for key in dict if dict[key]['apply']]
+        line_ids.sort()
+        return line_ids and inv_obj.browse(cr,uid,line_ids[-1]) or False
+
+
+    def _logic_create(self,cr,uid,dict,wh_doc_id):
+        '''
+        Manejo de toda la logica para la generarion de lineas en los modelos.
+        '''
+        dictc = self._get_dict_concepts(cr,uid,dict)
+        inv_brw = self._get_inv_id(cr,uid,dict)
+        inv_obj =self.pool.get('account.invoice.line')
+        islr_wh_doc_id=None
+
+        if inv_brw:
+            if dictc and not wh_doc_id:
+                islr_wh_doc_id = self._create_islr_wh_doc(cr,uid,inv_brw,dict)
+            else:
+                islr_wh_doc_id = wh_doc_id
+            key_lst = []
+            if islr_wh_doc_id:
+                for key2 in dictc:
+                    inv_line_id = dictc[key2][0].keys()[0]
+                    islr_wh_doc_line_id = self._create_doc_line(cr,uid,inv_brw,key2,islr_wh_doc_id,dict,dictc)
+                    for line in dictc[key2]:
+                        inv_line_id2 = dictc[key2][0].keys()[0]
+                        for key in line:
+                            key_lst.append(inv_obj.browse(cr,uid,key).invoice_id.id)
+                            if not wh_doc_id:
+                                self._write_wh_xml(cr,uid,key,islr_wh_doc_line_id)
+                for key in set(key_lst):
+                    self._create_doc_invoices(cr,uid,key,islr_wh_doc_id)
+                        
+                self.pool.get('account.invoice').write(cr,uid,inv_brw.invoice_id.id,{'islr_wh_doc_id':islr_wh_doc_id})
+                
+                message = _("Withholding income voucher '%s' generated.") % self.pool.get('islr.wh.doc').browse(cr,uid,islr_wh_doc_id).name
+                self.log(cr, uid, islr_wh_doc_id, message)
+            else:
+                pass
+        else:
+            pass
+        return islr_wh_doc_id
+
+    def action_ret_islr(self, cr, uid, ids, context={}):
+        return self.pool.get('islr.wh.doc').action_ret_islr(cr,uid,ids,context)
+
+    def _check_wh_islr(self, cr, uid, ids, context=None):
+        if context is None:
+            context={}
+        
+        wh_apply=[]
+        # The two function being called below should undergo overhauling
+        # right now it takes an object as and argument instead of an integer
+        invoice = self.browse(cr, uid, ids[0], context=context)
+        vendor, buyer, wh = self._get_partners(cr, uid, invoice)
+        concept_list = self._get_concepts(cr, uid, invoice)
+        wh_apply.append(wh)
+        wh_apply.append(concept_list)
+        
+        return invoice, vendor, buyer, concept_list, all(wh_apply)
+
+    def _check_do_wh(self, cr, uid, ids, invoice, vendor, buyer, concept_list, context=None):
+        if context is None:
+            context={}
+        wh_dict = self._get_service_wh(cr, uid, invoice, concept_list)
+        residence = self._get_residence(cr, uid, vendor, buyer)
+        nature = self._get_nature(cr, uid, vendor)
+        dict_rate = self._get_rate_dict(cr, uid, concept_list, residence, nature,context=context)
+        self._pop_dict(cr,uid,concept_list,dict_rate,wh_dict)
+        dict_completo = self._get_wh_apply(cr,uid,dict_rate,wh_dict,nature,context=context)
+        inv_brw = self._get_inv_id(cr,uid,dict_completo)
+        
+        return bool(inv_brw)
+        
+    def check_wh_islr_apply(self, cr, uid, ids, context=None):
+        '''
+        This Method test if given certain conditions it is
+        possible to create a new withholding document
+        '''
+        #TODO: Este metodo deberia devolver true ya que es un metodo "check"
+        if context is None:
+            context={}
+        
+        invoice, vendor, buyer, concept_list, wh_apply = self._check_wh_islr(cr, uid, ids, context=context)
+        
+        do_wh = False
+        if wh_apply:
+            context.update({'test_from_wkf':True})
+            do_wh = self._check_do_wh(cr, uid, ids, invoice, vendor, buyer, concept_list, context=context)
+            
+        return all([wh_apply,do_wh])
+
+    def check_wh_islr_xml(self, cr, uid, ids, context=None):
+        '''
+        This Method test if given certain conditions it is
+        __not__ possible to create a new withholding document
+        but the xml elements needed to create a legal report
+        '''
+        if context is None:
+            context={}
+        
+        invoice, vendor, buyer, concept_list, wh_apply = self._check_wh_islr(cr, uid, ids, context=context)
+        
+        do_wh = True
+        if wh_apply:
+            context.update({'test_from_wkf':True})
+            do_wh = self._check_do_wh(cr, uid, ids, invoice, vendor, buyer, concept_list, context=context)
+            
+        return all([wh_apply,not do_wh])
+
+    def action_islr_xml(self, cr, uid, ids, context=None):
+        '''
+        This Method creates the xml elements needed to provide a legal report
+        '''
+        if context is None:
+            context={}
+        
+        invoice, vendor, buyer, concept_list, wh_apply = self._check_wh_islr(cr, uid, ids, context=context)
+        
+        if wh_apply:
+            self._check_do_wh(cr, uid, ids, invoice, vendor, buyer, concept_list, context=context)
+            
+        return True
+
+    def check_invoice_type(self, cr, uid, ids, context=None):
+        '''
+        This method test the invoice types to create a new withholding document
+        '''
+        #TODO: change on workflow
+        if context is None:
+            context={}
+        obj = self.browse(cr, uid, ids[0],context=context)
+        if obj.type in ('in_invoice', 'in_refund'):
+            return True 
+        return False
+
+>>>>>>> MERGE-SOURCE
     def validate_wh_income_done(self, cr, uid, ids, context=None):
         """ Method that check if wh income is validated in invoice refund.
         @params: ids: list of invoices.

=== modified file 'l10n_ve_withholding_islr/model/islr_wh_doc.py'
--- l10n_ve_withholding_islr/model/islr_wh_doc.py	2013-12-05 20:57:09 +0000
+++ l10n_ve_withholding_islr/model/islr_wh_doc.py	2013-12-05 22:26:23 +0000
@@ -93,7 +93,7 @@
         for rete in self.browse(cr, uid, ids, context):
             res[rete.id] = 0.0
             for line in rete.concept_ids:
-                res[rete.id] += line.amount
+                res[rete.id] += line.amount 
         return res
 
     _name = "islr.wh.doc"
@@ -678,8 +678,12 @@
         if default is None:
             default = {}
         default = default.copy()
+<<<<<<< TREE
         default.update({'islr_wh_doc_id': 0})
 
+=======
+        default.update({'islr_wh_doc_id':0 })
+>>>>>>> MERGE-SOURCE
         return super(account_invoice, self).copy(cr, uid, id, default, context)
 
 class islr_wh_doc_invoices(osv.osv):