def SincronizarArticuloGrupo(sender, **kwargs):
    ''' Para sincronizar ciudad en todas las empreas. '''
    
    
    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        articulo_grupo_a_syncronizar =  kwargs.get('instance')
        
        indice, indice_final = get_indices(len(bases_de_datos), 100, 'GRUPO')
        for base_de_datos in bases_de_datos[indice:indice_final]:

            articulo_grupo_old = first_or_none(GrupoLineas.objects.using(default_db).filter(pk=articulo_grupo_a_syncronizar.id))
            if articulo_grupo_old:
                articulo_grupo_nombre = articulo_grupo_old.nombre
            else:
                articulo_grupo_nombre = articulo_grupo_a_syncronizar.nombre

            articulo_grupo = first_or_none(GrupoLineas.objects.using(base_de_datos).filter(nombre=articulo_grupo_nombre))
            if articulo_grupo:
                articulo_grupo.nombre= articulo_grupo_a_syncronizar.nombre
                articulo_grupo.cuenta_ventas= articulo_grupo_a_syncronizar.cuenta_ventas
                articulo_grupo.save(using=base_de_datos)
            else:
                GrupoLineas.objects.using(base_de_datos).create(
                            nombre= articulo_grupo_a_syncronizar.nombre,
                            cuenta_ventas = articulo_grupo_a_syncronizar.cuenta_ventas,
                        )

        set_indices(indice_final, len(bases_de_datos), 'GRUPO')
예제 #2
0
def SincronizarPais(sender, **kwargs):
    ''' Para sincronizar ciudad en todas las empreas. '''
    
    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        pais_a_syncronizar =  kwargs.get('instance')
        indice, indice_final = get_indices(len(bases_de_datos), 100, 'PAIS')
        for base_de_datos in bases_de_datos[indice:indice_final]:

            pais_old = first_or_none(Pais.objects.using(default_db).filter(pk=pais_a_syncronizar.id))

            if pais_old:
                pais_nombre = pais_old.nombre
            else:
                pais_nombre = pais_a_syncronizar.nombre

            pais = first_or_none(Pais.objects.using(base_de_datos).filter(nombre=pais_nombre))
            
            if pais:
                pais.nombre= pais_a_syncronizar.nombre
                pais.es_predet= pais_a_syncronizar.es_predet
                pais.nombre_abreviado= pais_a_syncronizar.nombre_abreviado
                
                pais.save(using=base_de_datos)
            else:
                Pais.objects.using(base_de_datos).create(
                            id=-1,
                            nombre= pais_a_syncronizar.nombre,
                            es_predet = pais_a_syncronizar.es_predet,
                            nombre_abreviado = pais_a_syncronizar.nombre_abreviado
                        )

        set_indices(indice_final, len(bases_de_datos), 'PAIS')
예제 #3
0
def Sincronizarciudad(sender, **kwargs):
    ''' Para sincronizar ciudad en todas las empreas. '''
    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        ciudad_a_syncronizar =  kwargs.get('instance')

        indice, indice_final = get_indices(len(bases_de_datos), 100, 'CIUDAD')
        for base_de_datos in bases_de_datos[indice:indice_final]:
            ciudad_old = first_or_none(Ciudad.objects.using(default_db).filter(pk=ciudad_a_syncronizar.id))
            if ciudad_old:
                ciudad_nombre = ciudad_old.nombre
            else:
                ciudad_nombre = ciudad_a_syncronizar.nombre

            ciudad = first_or_none(Ciudad.objects.using(base_de_datos).filter(nombre=ciudad_nombre))

            old_estado = ciudad_a_syncronizar.estado
            old_pais = old_estado.pais

            pais, pais_creado = Pais.objects.using(base_de_datos).get_or_create(
                    nombre= old_estado.pais.nombre,
                    defaults={
                        'nombre': old_pais.nombre,
                        'es_predet': old_pais.es_predet, 
                        'nombre_abreviado': old_pais.nombre_abreviado,
                    }
                )

            estado, estado_creado = Estado.objects.using(base_de_datos).get_or_create(
                    nombre=ciudad_a_syncronizar.estado.nombre, 
                    defaults={
                        'es_predet': old_estado.es_predet,
                        'nombre_abreviado':old_estado.nombre_abreviado,
                        'pais': pais,
                    }
                )

            if ciudad:
                ciudad.nombre= ciudad_a_syncronizar.nombre
                ciudad.es_predet= ciudad_a_syncronizar.es_predet
                ciudad.estado = estado
                ciudad.save(using=base_de_datos)
            else:
                Ciudad.objects.using(base_de_datos).create(
                            id=-1,
                            nombre= ciudad_a_syncronizar.nombre,
                            es_predet= ciudad_a_syncronizar.es_predet,
                            estado = estado
                        )
        set_indices(indice_final, len(bases_de_datos), 'CIUDAD')
예제 #4
0
def SincronizarArticulo(sender, **kwargs):
    ''' Para sincronizar articulos en todas las empreas registradas. '''
    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        articulo_a_syncronizar =  kwargs.get('instance')

        indice, indice_final = get_indices(len(bases_de_datos), 40, 'ARTICULO')
        for base_de_datos in bases_de_datos[indice:indice_final]:
            try:
                articulo_nombre = Articulo.objects.using(default_db).get(pk=articulo_a_syncronizar.id).nombre
            except ObjectDoesNotExist: 
                articulo_nombre = articulo_a_syncronizar.nombre
                
            articulo = first_or_none(Articulo.objects.using(base_de_datos).filter(nombre=articulo_nombre))
            if articulo:
                articulo.nombre = articulo_a_syncronizar.nombre
                articulo.es_almacenable = articulo_a_syncronizar.es_almacenable
                articulo.estatus = articulo_a_syncronizar.estatus
                articulo.seguimiento = articulo_a_syncronizar.seguimiento
                articulo.cuenta_ventas = articulo_a_syncronizar.cuenta_ventas

                linea = LineaArticulos.objects.using(base_de_datos).get(nombre=articulo_a_syncronizar.linea.nombre)
                articulo.linea = linea

                articulo.nota_ventas = articulo_a_syncronizar.nota_ventas
                articulo.unidad_venta = articulo_a_syncronizar.unidad_venta
                articulo.unidad_compra = articulo_a_syncronizar.unidad_compra
                articulo.costo_ultima_compra = articulo_a_syncronizar.costo_ultima_compra
                articulo.usuario_ult_modif = articulo_a_syncronizar.usuario_ult_modif
                articulo.save(using=base_de_datos)
            else:
                linea = LineaArticulos.objects.using(base_de_datos).get(nombre=articulo_a_syncronizar.linea.nombre)
                
                Articulo.objects.using(base_de_datos).create(
                        nombre = articulo_a_syncronizar.nombre,
                        es_almacenable = articulo_a_syncronizar.es_almacenable,
                        estatus = articulo_a_syncronizar.estatus,
                        seguimiento = articulo_a_syncronizar.seguimiento,
                        cuenta_ventas = articulo_a_syncronizar.cuenta_ventas,
                        linea = linea,
                        nota_ventas = articulo_a_syncronizar.nota_ventas,
                        unidad_venta = articulo_a_syncronizar.unidad_venta,
                        unidad_compra = articulo_a_syncronizar.unidad_compra,
                        costo_ultima_compra = articulo_a_syncronizar.costo_ultima_compra,
                        usuario_ult_modif = articulo_a_syncronizar.usuario_ult_modif,
                    )

            SincronizarDependencias(using=base_de_datos, articulo_nombre=articulo_nombre)

        set_indices(indice_final, len(bases_de_datos), 'ARTICULO')
예제 #5
0
def SincronizarCliente(sender, **kwargs):
    ''' Para sincronizar clientes en todas las empreas registradas. '''

    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        cliente_a_syncronizar =  kwargs.get('instance')

        indice, indice_final = get_indices(len(bases_de_datos), 40, 'CLIENTE')
        for base_de_datos in bases_de_datos[indice:indice_final]:
            try:
                cliente_nombre = Cliente.objects.using(default_db).get(pk=cliente_a_syncronizar.id).nombre
            except ObjectDoesNotExist: 
                cliente_nombre = cliente_a_syncronizar.nombre
                
            cliente = first_or_none(Cliente.objects.using(base_de_datos).filter(nombre=cliente_nombre))
            if cliente:
                cliente.nombre = cliente_a_syncronizar.nombre
                
                condicion_de_pago = CondicionPago.objects.using(base_de_datos).get(nombre=cliente_a_syncronizar.condicion_de_pago.nombre)
                cliente.condicion_de_pago = condicion_de_pago

                cliente.moneda = cliente_a_syncronizar.moneda
                cliente.cobrar_impuestos = cliente_a_syncronizar.cobrar_impuestos
                cliente.generar_interereses = cliente_a_syncronizar.generar_interereses
                cliente.emir_estado_cuenta = cliente_a_syncronizar.emir_estado_cuenta
            
                cliente.save(using=base_de_datos)
            else:
                condicion_de_pago = CondicionPago.objects.using(base_de_datos).get(nombre=cliente_a_syncronizar.condicion_de_pago.nombre)
                
                Cliente.objects.using(base_de_datos).create(
                        nombre = cliente_a_syncronizar.nombre,
                        condicion_de_pago = condicion_de_pago,
                        moneda = cliente_a_syncronizar.moneda,
                        cobrar_impuestos = cliente_a_syncronizar.cobrar_impuestos,
                        generar_interereses = cliente_a_syncronizar.generar_interereses,
                        emir_estado_cuenta = cliente_a_syncronizar.emir_estado_cuenta,
                    )
            
            SincronizarClienteDireccion(using=base_de_datos, fuente_cliente_nombre=cliente_nombre )

        set_indices(indice_final, len(bases_de_datos), 'CLIENTE')
예제 #6
0
def SincronizarEstado(sender, **kwargs):
    ''' Para sincronizar estado en todas las empreas. '''
    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        estado_a_syncronizar =  kwargs.get('instance')

        indice, indice_final = get_indices(len(bases_de_datos), 100, 'ESTADO')
        for base_de_datos in bases_de_datos[indice:indice_final]:
            estado_old = first_or_none(Estado.objects.using(default_db).filter(pk=estado_a_syncronizar.id))
            if estado_old:
                estado_nombre = estado_old.nombre
            else:
                estado_nombre = estado_a_syncronizar.nombre

            estado = first_or_none(Estado.objects.using(base_de_datos).filter(nombre=estado_nombre))

            pais = first_or_none(Pais.objects.using(base_de_datos).filter(nombre=estado_a_syncronizar.pais.nombre))

            if not pais:
                old_pais = estado_a_syncronizar.pais

                pais = Pais.objects.using(base_de_datos).create(
                        nombre = old_pais.nombre,
                        es_predet = old_pais.es_predet,
                        nombre_abreviado = old_pais.nombre_abreviado
                    )

            if estado:
                estado.nombre= estado_a_syncronizar.nombre
                estado.es_predet= estado_a_syncronizar.es_predet
                estado.nombre_abreviado= estado_a_syncronizar.nombre_abreviado
                estado.pais = pais
                estado.save(using=base_de_datos)
            else:
                Estado.objects.using(base_de_datos).create(
                            id=-1,
                            nombre= estado_a_syncronizar.nombre,
                            nombre_abreviado = estado_a_syncronizar.nombre_abreviado,
                            es_predet= estado_a_syncronizar.es_predet,
                            pais = pais
                        )
        set_indices(indice_final, len(bases_de_datos), 'ESTADO')
def SincronizarCondicionPago(sender, **kwargs):
    """ Para sincronizar condiciones de pago en todas las empreas registradas. """

    if kwargs.get("using") == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get("using"))

        condicion_pago_a_syncronizar = kwargs.get("instance")

        indice, indice_final = get_indices(len(bases_de_datos), 70, "CONDICIONPAGO")
        for base_de_datos in bases_de_datos[indice:indice_final]:
            try:
                condicion_pago_nombre = (
                    CondicionPago.objects.using(default_db).get(pk=condicion_pago_a_syncronizar.id).nombre
                )
            except ObjectDoesNotExist:
                condicion_pago_nombre = condicion_pago_a_syncronizar.nombre

            condicion_pago = first_or_none(
                CondicionPago.objects.using(base_de_datos).filter(nombre=condicion_pago_nombre)
            )
            if condicion_pago:
                condicion_pago.nombre = condicion_pago_a_syncronizar.nombre
                condicion_pago.dias_ppag = condicion_pago_a_syncronizar.dias_ppag
                condicion_pago.porcentaje_descuento_ppago = condicion_pago_a_syncronizar.porcentaje_descuento_ppago
                condicion_pago.es_predet = condicion_pago_a_syncronizar.es_predet
                condicion_pago.usuario_creador = condicion_pago_a_syncronizar.usuario_creador
                condicion_pago.usuario_ult_modif = condicion_pago_a_syncronizar.usuario_creador

                condicion_pago.save(using=base_de_datos)
            else:
                CondicionPago.objects.using(base_de_datos).create(
                    nombre=condicion_pago_a_syncronizar.nombre,
                    dias_ppag=condicion_pago_a_syncronizar.dias_ppag,
                    porcentaje_descuento_ppago=condicion_pago_a_syncronizar.porcentaje_descuento_ppago,
                    es_predet=condicion_pago_a_syncronizar.es_predet,
                    usuario_creador=condicion_pago_a_syncronizar.usuario_creador,
                    usuario_ult_modif=condicion_pago_a_syncronizar.usuario_creador,
                )

            sync_condicion_pago_plazo(using=base_de_datos, condicion_pago_nombre=condicion_pago_nombre)

        set_indices(indice_final, len(bases_de_datos), "CONDICIONPAGO")
예제 #8
0
def SincronizarImpuesto(sender, **kwargs):
    ''' Para sincronizar impuestos en todas las empreas. '''

    if kwargs.get('using') == default_db:
        bases_de_datos = MICROSIP_DATABASES.keys()
        bases_de_datos.remove(kwargs.get('using'))
        
        impuesto_a_syncronizar =  kwargs.get('instance')

        indice, indice_final = get_indices(len(bases_de_datos), 100, 'IMPUESTO')
        for base_de_datos in bases_de_datos[indice:indice_final]:
            
            impuesto_old = first_or_none(Impuesto.objects.using(default_db).filter(pk=impuesto_a_syncronizar.id))

            if impuesto_old:
                impuesto_nombre = impuesto_old.nombre
            else:
                impuesto_nombre = impuesto_a_syncronizar.nombre
     
            impuesto = first_or_none(Impuesto.objects.using(base_de_datos).filter(nombre=impuesto_nombre))

            if impuesto:
                tipo_impuesto = first_or_none(ImpuestoTipo.objects.using(base_de_datos).filter(nombre=impuesto_old.tipoImpuesto.nombre))

                if tipo_impuesto:
                    impuesto.porcentaje = impuesto_old.porcentaje
                    impuesto.nombre= impuesto_old.nombre
                    impuesto.tipoImpuesto = tipo_impuesto
                    impuesto.tipo_iva = impuesto_old.tipo_iva
                    impuesto.es_predet= impuesto_old.es_predet
                    impuesto.save(using=base_de_datos)
            else:
                tipo_impuesto = first_or_none(ImpuestoTipo.objects.using(base_de_datos).filter(nombre=impuesto_old.tipoImpuesto.nombre))
                if tipo_impuesto:
                    Impuesto.objects.using(base_de_datos).create(
                            id=-1,
                            nombre= impuesto_old.nombre,
                            tipoImpuesto = tipo_impuesto,
                            tipo_iva = impuesto_old.tipo_iva,
                            porcentaje = impuesto_old.porcentaje
                        )
        set_indices(indice_final, len(bases_de_datos), 'IMPUESTO')