Пример #1
0
    def pw_create_presupuesto(self, cr, uid, ids, context=None):
        ir_model_data=self.pool.get('ir.model.data')

        sale_order=self.pool.get('sale.order')
        try:
            _logger.info("Inicio conexion")
            transaction=odoo2pw.odoo2pw(self)
            _logger.info("Datos del server obtenidos")
            transaction.connect_pw(cr, uid)
            _logger.info("Conectado a pw")

        except:
            _logger.error("No conecto a pw")

        for order in sale_order.browse(cr, uid, ids, context=context):
            presupuesto={}
            relations = {
                'id':'ID',
                'name':'Numero',
                'note':'Notas',
            }
        
            try :
              _logger.info('Verificando si existe OperacionKey para %d' , order['id'])
              transaction.cursor.execute("select OperacionKey from ODOO_Presupuesto where id= %d " , order['id'])
              _logger.info("select OperacionKey from ODOO_Presupuesto where id= %d" , order['id'])
              row = transaction.cursor.fetchone()
              _logger.info('row %r' , row)
              if row is not None and  row['OperacionKey']:
                      external_link = {
                          'name' : 'pk' + str(row['OperacionKey']),
                          'model' : 'sale.order',
                          'module' : 'pw',
                          'res_id' : order['id'], 
                        }

                      ir_model_data.create(cr,uid,external_link)
                      _logger.info('Ya existia OperacionKey solo lo creo el vinculo')
                      continue 

              presupuesto['ListaPreciosKey']=transaction.get_pwKey(cr,uid, order['pricelist_id']['id'],'LPK','product.pricelist',1)
          
              presupuesto['ClienteKey']=transaction.get_pwKey(cr,uid, order['partner_id']['id'],'','res.partner',False)
              if presupuesto['ClienteKey'] == False :
                _logger.warning("El cliente no es valido intento crearlo en el proximo batch id %r ", order['partner_id']['id'])
                continue
                #self.pool.get('res.partner').pw_create_cliente( cr, uid, [order['partner_id']['id']], context=context)
                #presupuesto['ClienteKey']=transaction.get_pwKey(cr,uid, order['partner_id']['id'],'','res.partner',False)
                #if presupuesto['ClienteKey'] == False :
                  #_logger.error("No se pudo crear el cliente ")
                  #continue 

              #presupuesto['VendedorKey']=1
              presupuesto['VendedorKey']=transaction.get_pwKey(cr,uid, order['user_id']['id'] ,'Uv','res.users',1)
              presupuesto['LocalKey']=transaction.get_pwKey(cr,uid,order['section_id']['pwlocal_id']['id'],'LOCALK','pw.local',2)

              #date_validity es solo date y fechavencimiento es datetime asi que coloco el vencimiento del presupuesto al final del dia
              presupuesto['FechaVencimiento']=parser.parse(order['date_validity'] + " 23:59:58")

              #parceo la fecha y resto la diferencia de gtm 
              #(en pw las fechas se almacenan en GTM -3 sin identificador y en odoo en GTM 0
              
              presupuesto['FechaPresupuesto']=parser.parse(order['create_date']) - timedelta(hours=3)
              presupuesto['FechaHora']=parser.parse(order['date_order']) - timedelta(hours=3)

              presupuesto['PorcentajeDescuento']=0
              presupuesto['CantidadRenglones']=len(order['order_line'])

              
              for key in relations:
                  presupuesto[relations[key]]=order[key] or ''
              _logger.info("presupuesto %r ", presupuesto)

              data = "(%d,'%s',%d,0,'%s','%s','%s',%d,%f,%d,'%s',%d,0,%d)" % (presupuesto['ID'],
                                           presupuesto['Numero'],presupuesto['ClienteKey'],str(presupuesto['FechaPresupuesto'])[0:-3],
                                           str(presupuesto['FechaHora'])[0:-3],str(presupuesto['FechaVencimiento'])[0:-3],presupuesto['VendedorKey'],presupuesto['PorcentajeDescuento'],
                                           presupuesto['CantidadRenglones'],presupuesto['Notas'].encode('ascii',errors='ignore'),
                                           presupuesto['ListaPreciosKey'],presupuesto['LocalKey'])
                  

              transaction.cursor.execute("INSERT INTO ODOO_Presupuesto (ID,Numero,ClienteKey,ODOO_ClienteKey,FechaPresupuesto,FechaHora,"
                                         "FechaVencimiento,VendedorKey,PorcentajeDescuento,CantidadRenglones,Notas,ListaPreciosKey,OperacionKey,LocalKey) "
                                          "VALUES " + data
                                          )
              #transaction.commit()
              
              _logger.info('Ejecute el insert del encabezado')

              lines=[]
              for line in order['order_line'] :
                #amount_line_tax= self.amount_line_product_tax( cr, uid, line, context=context)

                articulokey=transaction.get_pwKey(cr,uid, line['product_id']['product_tmpl_id']['id'],'AK','product.template',1)
                query="INSERT INTO ODOO_PresupuestoItem (ItemID,PresupuestoID,ArticuloKey,Cantidad,PrecioUnitarioFinal,PorcentajeDescuento)  VALUES (%d,%d,%d,%f,%f,%f)" % (line['id'],order['id'],articulokey,line['product_uom_qty'],
                      line['price_unit_with_tax'],line['discount'])
                
                transaction.cursor.execute(query)


              #transaction.commit()
              _logger.info('Ejecute el insert de las lineas')

              transaction.cursor.execute("exec sp_odoo_insert_presupuesto_pw %d" , order['id'])
              #transaction.commit()

              _logger.info('Ejecute el store procedure')

              transaction.cursor.execute("select OperacionKey from ODOO_Presupuesto where id= %d " , order['id'])
              row=transaction.cursor.fetchone()
              #for row in transaction.cursor:
              if row['OperacionKey']:
                  external_link = {   
                      'name' : 'pk' + str(row['OperacionKey']),
                      'model' : 'sale.order',
                      'module' : '',
                      'res_id' : order['id'], 
                    }
                  transaction.commit()

                  ir_model_data=self.pool.get('ir.model.data')
                  ir_model_data.create(cr,uid,external_link)
              else :
                _logger.error('No se pudo realizar en envio. No obtuve la clave externa.')
                transaction.rollback()

            except:
              _logger.error('No se pudo realizar en envio')
              transaction.rollback()
              continue
Пример #2
0
    def pw_update_cliente(self, cr, uid, partner_id,vals,data_ids, context=None):
        _logger.info("partner_id %r", partner_id)

        res_partner=self.pool.get('res.partner')
        partner=res_partner.browse(cr, uid, partner_id)
        _logger.info("partner %r", partner)

        if partner['customer']==1 :
            string_fields = {
                'name':'razonSocial',
                'firstname':'nombre',
                'lastname':'apellido',
                'email':'email',
                'phone':'telefono',
                'mobile':'telefonoMovil',
                'street':'domicilio',
                'comment':'notas',
                'zip' : 'codigoPostal' ,
                'document_number':'numeroDocumento',
                #'active':'Activo',

            }
            _logger.info("vals %r", vals)
            up_data=[]
            try :

                transaction=odoo2pw.odoo2pw(self)
                transaction.connect_pw(cr, uid)

                for key in vals:
                    if key in string_fields :
                        up_data.append("%s = '%s'" % (string_fields[key],vals[key]))

                if 'city_id' in vals :
                    up_data.append("localidadKey = %d " % (transaction.get_pwKey(cr,uid, vals['city_id'],'LOK','res.country.state.city',73)))
                if 'user_id' in vals :
                    up_data.append("vendedorKey = %d " % (transaction.get_pwKey(cr,uid, vals['user_id'] ,'Uv','res.user',1)))

                if 'name' not in vals :

                   nombre = vals.get('firstname',partner['firstname'])
                   apellido = vals.get('lastname',partner['lastname'])
                   razonSocial = str(nombre) + " " + str(apellido)
                   up_data.append("razonsocial = '%s'" % razonSocial)
                   _logger.info("razon social %s" % razonSocial)

                if(up_data):
                    _logger.info("update cliente set %s where ClienteKey=%d", ','.join(up_data),data_ids)
                    transaction.cursor.execute("update cliente set " + ','.join(up_data) + " where ClienteKey=%d",(data_ids))
                    transaction.commit()
            except ValueError as e:
                _logger.info('no se actualizo el cliente %r' , e)

            except :
                _logger.info("ERROR update cliente set %s where ClienteKey=%d", ','.join(up_data),data_ids)
                result ={}
                warning = {
                    'title': 'Error en el envio',
                    'message': 'El cliente no pudo ser actualizado en pw'
                    }
                result['warning'] = warning
                return result         #else :
Пример #3
0
    def pw_create_venta_temporal(self, cr, uid, ids, context=None):

        sale_order=self.pool.get('sale.order')
        stock_picking=self.pool.get('stock.picking')


        for order in self.browse(cr, uid, ids, context=context):
          _logger.info('Venta temporal disparada' )
          try: 
            transaction=odoo2pw.odoo2pw(self)
            transaction.connect_pw(cr, uid)

          except: 
            _logger.info('No pudo conectar con pw')
            return 

          try:
            transaction.cursor.execute("select OperacionKey from ODOO_VentaTemporal where id= %d " , order['id'])
            row = transaction.cursor.fetchone()
            if row['OperacionKey']:
              for picking_id in order['picking_ids']:
                  stock_picking.unlink(cr, uid, [picking_id['id']])          
              self.write(cr, uid, order['id'], {'state':'done'})
 
              return 
          except: 
            _logger.info('error en la verificacion')

          try: 

            venta_temporal={}
            relations = {
                'id':'ID',
                'name':'Numero',
                'note':'Notas',
            }
         


            
            venta_temporal['ListaPreciosKey']=transaction.get_pwKey(cr,uid, order['pricelist_id']['id'],'LPK','product.pricelist',1)
            #venta_temporal['ListaPreciosKey']=1
     
            venta_temporal['ClienteKey']=transaction.get_pwKey(cr,uid, order['partner_id']['id'],'','res.partner',1)
            #venta_temporal['VendedorKey']=1
            venta_temporal['VendedorKey']=transaction.get_pwKey(cr,uid, order['user_id']['id'] ,'Uv','res.users',1)
            if venta_temporal['ClienteKey'] == False :
              _logger.info("El cliente no es valido")
              self.pool.get('res.partner').pw_create_cliente( cr, uid, [order['partner_id']['id']], context=context)
              venta_temporal['ClienteKey']=transaction.get_pwKey(cr,uid, order['partner_id']['id'],'','res.partner',False)
              if venta_temporal['ClienteKey'] == False :
                raise Warning('No se pudo crear el cliente en PW No crear la venta temporal ')

                return 
   


            #Relacionar el Equipo de venta con el local
            venta_temporal['LocalKey']=transaction.get_pwKey(cr,uid,order['section_id']['pwlocal_id']['id'],'LOCALK','pw.local',2)


            #date_validity es solo date y fechavencimiento es datetime asi que coloco el vencimiento del venta_temporal al final del dia
            venta_temporal['FechaVencimiento']=parser.parse(order['date_validity'] + " 23:59:58")

            #parceo la fecha y resto la diferencia de gtm 
            #(en pw las fechas se almacenan en GTM -3 sin identificador y en odoo en GTM 0
            
            venta_temporal['FechaPresupuesto']=parser.parse(order['create_date']) - timedelta(hours=3)
            venta_temporal['FechaHora']=parser.parse(order['date_order']) - timedelta(hours=3)

            venta_temporal['PorcentajeDescuento']=0
            venta_temporal['CantidadRenglones']=len(order['order_line'])

            
            for key in relations:
                venta_temporal[relations[key]]=order[key] or ''

            data = "(%d,'%s',%d,0,'%s','%s','%s',%d,%f,%d,'%s',%d,0,%d)" % (venta_temporal['ID'],
                                         venta_temporal['Numero'],venta_temporal['ClienteKey'],str(venta_temporal['FechaPresupuesto'])[0:-3],
                                         str(venta_temporal['FechaHora'])[0:-3],str(venta_temporal['FechaVencimiento'])[0:-3],venta_temporal['VendedorKey'],venta_temporal['PorcentajeDescuento'],
                                         venta_temporal['CantidadRenglones'],venta_temporal['Notas'].encode('ascii',errors='ignore'),
                                         venta_temporal['ListaPreciosKey'],venta_temporal['LocalKey'])
                


            transaction.cursor.execute("INSERT INTO ODOO_VentaTemporal (ID,Numero,ClienteKey,ODOO_ClienteKey,FechaPresupuesto,FechaHora,"
                                       "FechaVencimiento,VendedorKey,PorcentajeDescuento,CantidadRenglones,Notas,ListaPreciosKey,OperacionKey,LocalKey) "
                                        "VALUES " + data
                                        )
            

            lines=[]
            for line in order['order_line'] :
              #amount_line_tax= self.amount_line_product_tax( cr, uid, line, context=context)

              articulokey=transaction.get_pwKey(cr,uid, line['product_id']['product_tmpl_id']['id'],'AK','product.template',1)
              query="INSERT INTO ODOO_VentaTemporalItem (ItemID,ventatemporalID,ArticuloKey,Cantidad,PrecioUnitarioFinal,PorcentajeDescuento)  VALUES (%d,%d,%d,%f,%f,%f)" % (line['id'],order['id'],articulokey,line['product_uom_qty'],
                    line['price_unit_with_tax'],line['discount'])
              
              transaction.cursor.execute(query)


            transaction.commit()

            transaction.cursor.execute("exec sp_odoo_insert_temporal_pw %d" , order['id'])
            transaction.commit()

            _logger.info('Venta temporal insertada' )

            #elimino las ordenes de entrega generadas
            for picking_id in order['picking_ids']:
              stock_picking.unlink(cr, uid, [picking_id['id']])          

            self.write(cr, uid, order['id'], {'state':'done'})

          except: 
            _logger.info('La venta temporal no fue enviada')
            raise Warning('No se pudo crear la venta temporal (Motivo desconocido) ')


          try :

            transaction.cursor.execute("select OperacionKey from ODOO_VentaTemporal where id= %d " , order['id'])


            # inserto relacion entre esto y  el presupuesto
            presupuestokey=transaction.get_pwKey(cr,uid, order['id'] ,'pk','order_sale',0)


            if presupuestokey :
              for row in transaction.cursor:
                if row['OperacionKey']:
                    data_str="(%d,%d,'%s',1,1)"%(presupuestokey,row['OperacionKey'],str(venta_temporal['FechaHora'])[0:-3])
                    transaction.cursor.execute("insert into operaciongenera "
                                               "(OperacionKey, OperacionGeneradaKey, Fecha, Activo, Vinculada) "
                                               "values " + data_str
                                               )
                    transaction.commit()

          except: 
            _logger.info('La venta temporal no fue enviada')
            raise Warning('No se pudo crear la relacion pero la venta temporal  fue enviada')


        return 
Пример #4
0
    def pw_create_cliente(self, cr, uid, partner_id, context=None):

        res_partner=self.pool.get('res.partner')
        partner=res_partner.browse(cr, uid, partner_id)


        if partner['customer']!=1 :
            return 
        _logger.info("partner %r" ,partner)
        if not partner['name'] or not partner['document_number']:
            _logger.warning('Sin DNI o Nombre No se envia el partner a PW')
            return 

        cliente={}
        relations = {
            'name':'razonSocial',
            'firstname':'nombre',
            'lastname':'apellido',
            'email':'email',
            'phone':'telefono',
            'mobile':'telefonoMovil',
            'street':'domicilio',
            'comment':'notas',
            'zip' : 'codigoPostal' ,
            'document_number':'numeroDocumento',
        }

        try :        
            transaction=odoo2pw.odoo2pw(self)
            transaction.connect_pw(cr, uid)
    
            cliente['localidadKey']=transaction.get_pwKey(cr,uid, partner['city_id']['id'] or 1 ,'LOK','res.country.state.city',73)
            cliente['vendedorKey']=1
            for key in relations:
                cliente[relations[key]]=partner[key] or None
            _logger.info("filoquin ----- cliente  : %r", cliente)


                
            ir_model_data=self.pool.get('ir.model.data')
            ins=transaction.cursor.callproc('sp_InsertCliente', ( cliente['razonSocial'] ,
                                                                 cliente['apellido'] ,
                                                                 cliente['nombre'] ,
                                                                 cliente['domicilio'] ,
                                                                 cliente['email'] ,
                                                                 cliente['telefono'] ,
                                                                 cliente['telefonoMovil'] ,
                                                                 cliente['codigoPostal'] ,
                                                                 cliente['localidadKey'],
                                                                 cliente['notas'] ,
                                                                 cliente['vendedorKey'],
                                                                 str(cliente['numeroDocumento']) ,1))
            for row in transaction.cursor:
                if row['clienteKey']:
                    external_link = {
                        'name' : str(row['clienteKey']),
                        'model' : 'res.partner',
                        'module' : '',
                        'res_id' : partner['id'], 
                      }

                    ir_model_data.create(cr,uid,external_link)

        except :
         
            return  
        transaction.commit()

        return