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')
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')
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')
def ClonarDocumentoCompras(sender, **kwargs):
''' Funcion para copiar un documento y cambiarle de almacen. '''
documento_a_clonar = kwargs.get('instance')
#Al aplicar una compra
if documento_a_clonar.tipo == 'C' and documento_a_clonar.aplicado == 'S':
concepto_compras = InventariosConcepto.objects.get( pk = 20 )
fecha_actual = datetime.now()
almacen = first_or_none( Almacen.objects.filter(pk= almacen_clon_id) )
moneda = documento_a_clonar.moneda
#Tipo de cambio
if not moneda.id == 1:
tipo_cambio = first_or_none(TipoCambio.objects.filter(moneda = moneda).order_by('-fecha'))
if tipo_cambio:
tipo_cambio = tipo_cambio.tipo_cambio
else:
tipo_cambio = 1
entrada = InventariosDocumento.objects.create(
almacen = almacen,
concepto = concepto_compras,
aplicado = 'N',
naturaleza_concepto = 'E',
fecha = documento_a_clonar.fecha,
sistema_origen = 'IN',
usuario_creador = documento_a_clonar.usuario_creador,
descripcion = 'de %s'%documento_a_clonar.folio,
)
entrada.save()
detalles_a_clonar = ComprasDocumentoDetalle.objects.filter(documento = documento_a_clonar)
for detalle in detalles_a_clonar:
InventariosDocumentoDetalle.objects.create(
doctosIn = entrada,
almacen = almacen,
concepto = entrada.concepto,
claveArticulo = detalle.clave_articulo,
articulo = detalle.articulo,
tipo_movto = 'E',
unidades = detalle.unidades,
costo_unitario = detalle.precio_unitario * tipo_cambio,
costo_total = detalle.precio_total_neto,
metodo_costeo = 'C',
fecha = fecha_actual
)
def get_articulo_byclave( request, **kwargs ):
""" Selecionar un articulo por clave """
#Paramentros
clave = kwargs.get( 'clave', None)
comun_name = kwargs.get( 'comun_name', None)
clave_articulo = first_or_none( ArticuloClave.objects.filter( clave = clave, articulo__estatus = 'A'))
articulo_id = ''
articulo_nombre = ''
#Para excluir claves de ariculos con lotes
if clave_articulo:
if clave_articulo.articulo.seguimiento == 'L':
clave_articulo = None
opciones_clave = {}
if clave_articulo:
articulo = Articulo.objects.get( pk = clave_articulo.articulo.id )
articulo_id = articulo.id
articulo_nombre = articulo.nombre
else:
claves = ArticuloClave.objects.filter( clave__contains=clave, articulo__estatus='A',)
for c in claves:
if c.articulo.seguimiento == 'S' or c.articulo.seguimiento == 'N':
opciones_clave[str(c.clave)] = c.articulo.nombre
datos = {
'articulo_id': articulo_id,
'articulo_nombre': articulo_nombre,
'comun_name' : comun_name,
'opciones_clave': opciones_clave,
}
return HttpResponse( json.dumps( datos ), mimetype = "application/javascript" )
def generar_factura_global( request, **kwargs ):
# Parametros
connection_name = get_conecctionname(request.session)
fecha_inicio = datetime.datetime.strptime( kwargs.get( 'fecha_inicio', None ), '%d/%m/%Y' ).date()
# fecha_fin = datetime.strptime( kwargs.get( 'fecha_inicio', None ), '%d/%m/%Y' ).date()
fecha_fin = datetime.datetime.strptime( kwargs.get( 'fecha_fin', None ), '%d/%m/%Y' ).date()
almacen = first_or_none( Almacen.objects.filter( pk = kwargs.get('almacen_id', None) ) )
cliente = Cliente.objects.get( pk = int( kwargs.get('cliente_id', None) ) )
cliente_direccion = first_or_none( ClienteDireccion.objects.filter(cliente=cliente) )
factura_tipo = kwargs.get('factura_tipo', None)
modalidad_facturacion = kwargs.get('modalidad_facturacion', None)
#SI NO EXITE ARICULO DE PUBLICO EN GENERAL
articulo_ventaspg_id = Registry.objects.get( nombre = 'ARTICULO_VENTAS_FG_PV_ID' )
articulo_ventaspg_id.save(update_fields=['valor',])
if not Articulo.objects.filter(pk=articulo_ventaspg_id.valor).exists() and factura_tipo == 'P':
c = {'message':'por favor primero espesifica un articulo general',}
return HttpResponse( json.dumps(c), mimetype = "application/javascript" )
if cliente_direccion.rfc_curp != "XAXX010101000":
c = {'message':'Una factura global solo puede realizar a clientes con \nRFC: XAXX010101000',}
return HttpResponse( json.dumps(c), mimetype = "application/javascript" )
data = new_factura_global(
fecha_inicio = fecha_inicio,
fecha_fin = fecha_fin,
almacen = almacen,
cliente = cliente,
cliente_direccion = cliente_direccion,
factura_tipo = factura_tipo,
modalidad_facturacion = modalidad_facturacion,
connection_name = connection_name,
username = request.user.username
)
c = {
'detalles': data['detalles'],
'totales': data['totales'],
'ventas_facturadas':data['ventas_facturadas'],
'message': data['message'],
'fecha_inicio': data['fecha_inicio'],
'fecha_fin':data['fecha_fin'],
'impuestos': data['impuestos'],
}
return HttpResponse( json.dumps(c), mimetype = "application/javascript" )
def SincronizarDependencias(**kwargs):
''' Para sincronizar primer plazo de condiciones de pago en todas las empreas registradas. '''
using = kwargs.get('using')
articulo_nombre= kwargs.get('articulo_nombre')
#DATOS FUENTE
fuente_articulo = Articulo.objects.using(default_db).get(nombre=articulo_nombre)
fuente_articulo_clave = first_or_none(ArticuloClave.objects.using(default_db).filter(articulo=fuente_articulo, rol__es_ppal='S'))
fuente_impuesto_articulo = first_or_none(ImpuestosArticulo.objects.using(default_db).filter(articulo=fuente_articulo))
#DATOS ORIGEN
articulo = Articulo.objects.using(using).get(nombre=articulo_nombre)
####################################
# Actualiza la primer clave
####################################
articulo_clave = first_or_none(ArticuloClave.objects.using(using).filter(articulo=articulo, rol__es_ppal='S'))
rol_principal = ArticuloClaveRol.objects.using(using).get(es_ppal='S')
if fuente_articulo_clave:
if articulo_clave:
articulo_clave.clave = fuente_articulo_clave.clave
articulo_clave.articulo = articulo
articulo_clave.rol = rol_principal
articulo_clave.save(using=using)
else:
ArticuloClave.objects.using(using).create(
clave = fuente_articulo_clave.clave,
articulo = articulo,
rol = rol_principal,
)
####################################
# Actualiza el primer impuesto
####################################
impuesto_articulo = first_or_none(ImpuestosArticulo.objects.using(using).filter(articulo=articulo))
impuesto = Impuesto.objects.using(using).get(nombre=fuente_impuesto_articulo.impuesto.nombre)
if impuesto_articulo:
impuesto_articulo.impuesto = impuesto
impuesto_articulo.save(using=using)
else:
ImpuestosArticulo.objects.using(using).create(
articulo = articulo,
impuesto = impuesto,
)
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 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')
def sync_condicion_pago_plazo(**kwargs):
using = kwargs.get("using")
fuente_condicion_pago_nombre = kwargs.get("condicion_pago_nombre")
fuente_primer_plazo = first_or_none(
CondicionPagoPlazo.objects.using(default_db).filter(condicion_de_pago__nombre=fuente_condicion_pago_nombre)
)
condicion_de_pago = CondicionPago.objects.using(using).get(nombre=fuente_condicion_pago_nombre)
primer_plazo = first_or_none(CondicionPagoPlazo.objects.using(using).filter(condicion_de_pago=condicion_de_pago))
if primer_plazo:
primer_plazo.dias = fuente_primer_plazo.dias
primer_plazo.porcentaje_de_venta = fuente_primer_plazo.porcentaje_de_venta
primer_plazo.save(using=using)
else:
CondicionPagoPlazo.objects.using(using).create(
condicion_de_pago=condicion_de_pago,
dias=fuente_primer_plazo.dias,
porcentaje_de_venta=fuente_primer_plazo.porcentaje_de_venta,
)
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')
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')
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")
def ClonarDocumentoCompras(sender, **kwargs):
''' Funcion para copiar un documento y cambiarle de almacen. '''
documento_a_clonar = kwargs.get('instance')
#Al aplicar una compra
if documento_a_clonar.tipo == 'C' and documento_a_clonar.aplicado == 'S':
concepto_compras = ConceptosIn.objects.get( pk = 20 )
fecha_actual = datetime.now()
almacen = first_or_none( Almacenes.objects.filter(pk= almacen_clon_id) )
entrada = DoctosIn.objects.create(
almacen = almacen,
concepto = concepto_compras,
aplicado = 'N',
naturaleza_concepto = 'E',
fecha = documento_a_clonar.fecha,
sistema_origen = 'IN',
usuario_creador = documento_a_clonar.usuario_creador,
descripcion = 'CLON',
)
entrada.save()
detalles_a_clonar = DocumentoComprasDetalle.objects.filter(documento = documento_a_clonar)
for detalle in detalles_a_clonar:
DoctosInDet.objects.create(
doctosIn = entrada,
almacen = almacen,
concepto = entrada.concepto,
claveArticulo = detalle.clave_articulo,
articulo = detalle.articulo,
tipo_movto = 'E',
unidades = detalle.unidades,
costo_unitario = detalle.precio_unitario,
costo_total = detalle.precio_total_neto,
metodo_costeo = 'C',
fecha = fecha_actual
)
def inicializar_tablas( request ):
""" Agrega trigers y campos nuevos en tablas de base de datos. """
#ventas_inicializar_tablas()
if request.user.is_superuser:
basedatos_activa = request.session[ 'selected_database' ]
if basedatos_activa == '':
return HttpResponseRedirect( '/select_db/' )
else:
conexion_activa_id = request.session[ 'conexion_activa' ]
conexion_name = "%02d-%s"%( conexion_activa_id, basedatos_activa )
# Campos nuevos en tablas
sincronizar_tablas( conexion_name = conexion_name )
if 'microsip_web.apps.punto_de_venta' in MICROSIP_MODULES:
if not Registry.objects.filter( nombre = 'ARTICULO_VENTAS_FG_PV_ID' ).exists():
padre = first_or_none(Registry.objects.filter(nombre='PreferenciasEmpresa'))
if padre:
Registry.objects.create(
nombre = 'ARTICULO_VENTAS_FG_PV_ID',
tipo = 'V',
padre = padre
)
if 'microsip_web.apps.inventarios' in MICROSIP_MODULES:
actualizar_triggers_inventarios( conexion_name = conexion_name )
else:
borrar_triggers_inventarios( conexion_name = conexion_name )
#cuentas_por_pagar_inicializar_tablas()
#cuentas_por_cobrar_inicializar_tablas()
management.call_command( 'syncdb', database = conexion_name )
return HttpResponseRedirect('/')
def get_detallesarticulo_byid( request, **kwargs ):
""" Selecionar un articulo por clave """
#Paramentros
articulo_id = kwargs.get( 'articulo_id', None)
comun_name = kwargs.get( 'comun_name', None)
articulo_clave = kwargs.get( 'articulo_clave', None)
articulo = Articulo.objects.get( pk = articulo_id )
if not articulo_clave:
articulo_clave = first_or_none( ArticuloClave.objects.filter( articulo_id = articulo_id, articulo__estatus = 'A'))
if articulo_clave:
articulo_clave = articulo_clave.clave
datos = {
'articulo_id': articulo.id,
'articulo_nombre': articulo.nombre,
'comun_name' : comun_name,
'articulo_clave' : articulo_clave,
'articulo_seguimiento': articulo.seguimiento,
'articulo_costoultimacompra' : format(articulo.costo_ultima_compra, '.2f'),
}
return HttpResponse( json.dumps( datos ), mimetype = "application/javascript" )
def add_seriesinventario_byarticulo( request, **kwargs ):
# Parametros
connection_name = get_conecctionname(request.session)
error = False
articulo_id = request.GET.get('articulo_id', None)
articulo = Articulo.objects.get(pk=articulo_id)
articulo_clave = first_or_none(
ArticuloClave.objects.filter(articulo=articulo))
almacen_id = request.GET.get('almacen_id', None)
almacen = Almacen.objects.get(ALMACEN_ID=almacen_id)
entrada_id = request.GET.get('entrada_id', None)
entrada = InventariosDocumento.objects.get(pk=entrada_id)
salida_id = request.GET.get('salida_id', None)
salida = InventariosDocumento.objects.get(pk=salida_id)
ubicacion = request.GET.get('ubicacion', None)
unidades = request.GET.get('unidades', None)
unidades = int(unidades)
ajusteprimerconteo = almacen.inventario_conajustes
series = request.GET.get('series', None)
series = series.split(',')
msg = ''
existe_en_detalles = InventariosDocumentoDetalle.objects.filter(
Q(doctosIn__concepto=27) | Q(doctosIn__concepto=38), articulo=articulo,
almacen=almacen,
doctosIn__descripcion='ES INVENTARIO',
).count() > 0
#Checar numeros de serie
for serie in series:
if ArticuloDiscretoExistencia.objects.filter(articulo_discreto__articulo=articulo, existencia__gt=0, almacen=almacen, articulo_discreto__clave=serie).exists() and serie != '' and unidades > 0 :
#Si es la primera ves que se cuenta
if not ajusteprimerconteo or (ajusteprimerconteo and existe_en_detalles):
msg = '%s El numero de serie %s ya esta registrado.' % (msg, serie)
elif not ArticuloDiscretoExistencia.objects.filter(articulo_discreto__articulo=articulo, existencia__gt=0, almacen=almacen, articulo_discreto__clave=serie).exists() and serie != '' and unidades < 0:
msg = '%s El numero de serie %s no esta registrado.' % (msg, serie)
if serie == '':
series.remove(serie)
if ajusteprimerconteo and not existe_en_detalles and unidades < 0:
msg= 'No esta permitido ajustar en primer conteo a valores negativos'
if msg == '':
request_username = request.user.username
#AJUSTAR SERIES
if ajusteprimerconteo and not existe_en_detalles:
existdiscretos_aeliminar = ArticuloDiscretoExistencia.objects.filter(articulo_discreto__articulo=articulo, existencia__gt=0, almacen=almacen).exclude(articulo_discreto__clave__in=series)
existdiscretos_aeliminar_count =existdiscretos_aeliminar.count()
series_aeliminar = []
for existdiscreto in existdiscretos_aeliminar:
series_aeliminar.append(existdiscreto.articulo_discreto.clave)
if existdiscretos_aeliminar_count > 0:
msg = ajustar_seriesinventario_byarticulo(
connection_name = connection_name,
unidades = -existdiscretos_aeliminar_count,
articulo = articulo,
articulo_clave = articulo_clave,
entrada = entrada,
almacen = almacen,
salida = salida,
request_username = request_username,
series = series_aeliminar,
ubicacion = ubicacion,
)
msg = ajustar_seriesinventario_byarticulo(
connection_name = connection_name,
unidades = unidades,
articulo = articulo,
articulo_clave = articulo_clave,
entrada = entrada,
almacen = almacen,
salida = salida,
request_username = request_username,
series = series,
ubicacion = ubicacion,
)
else:
msg = ajustar_seriesinventario_byarticulo(
connection_name = connection_name,
unidades = unidades,
articulo = articulo,
articulo_clave = articulo_clave,
entrada = entrada,
almacen = almacen,
salida = salida,
request_username = request_username,
series = series,
ubicacion = ubicacion,
)
c = connections[ connection_name ].cursor()
c.execute( "DELETE FROM SALDOS_IN where saldos_in.articulo_id = %s;"% articulo.id )
c.execute( "EXECUTE PROCEDURE RECALC_SALDOS_ART_IN %s;"% articulo.id )
transaction.commit_unless_managed()
c.close()
management.call_command( 'syncdb', database = connection_name )
if msg == '':
msg = 'Movimiento registrado correctamente'
exitencia = get_existencias_articulo(
articulo_id = articulo.id,
connection_name = connection_name,
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = almacen,
)
else:
error = True
exitencia =''
data = {
'msg' : msg,
'error': error,
'articulo_nombre': articulo.nombre,
'existencia_actual': str(exitencia),
}
return HttpResponse(json.dumps(data), mimetype="application/json")
def ClonarExistencia(sender, **kwargs):
''' para en la aplicacion inventarios fisicos generar entradas y salidas en el almacen clon. '''
almacen_clon = first_or_none( Almacen.objects.filter(pk= almacen_clon_id) )
detalle = kwargs.get('instance')
if almacen_clon and detalle.almacen != almacen_clon:
if not almacen_clon.inventariando:
almacen_clon.inventariando = True
almacen_clon.inventario_conajustes = detalle.almacen.inventario_conajustes
almacen_clon.inventario_modifcostos = detalle.almacen.inventario_modifcostos
almacen_clon.save()
entrada_clon, salida_clon = ajustes_get_or_create(almacen_id = almacen_clon.ALMACEN_ID, username = detalle.usuario_ult_modif)
old_detalle = first_or_none(InventariosDocumentoDetalle.objects.filter(pk=detalle.id))
existe_en_detalles = InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ) | Q( doctosIn__concepto = 38 ),
articulo = detalle.articulo,
almacen = detalle.almacen,
doctosIn__descripcion = 'ES INVENTARIO',
).count() > 0
unidades_diferencia = detalle.unidades
#ajustar en primer conteo
if detalle.almacen.inventario_conajustes and not existe_en_detalles:
existencia_articulo = get_existencias_articulo(
articulo_id = detalle.articulo.id,
connection_name = kwargs.get('using'),
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = almacen_clon,
)
detalle_existencia_articulo = get_existencias_articulo(
articulo_id = detalle.articulo.id,
connection_name = kwargs.get('using'),
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = detalle.almacen,
)
if detalle.tipo_movto == 'E':
detalle_existencia_final = detalle.unidades + detalle_existencia_articulo
elif detalle.tipo_movto == 'S':
detalle_existencia_final = detalle_existencia_articulo - detalle.unidades
unidades_diferencia = -existencia_articulo + detalle_existencia_final
if old_detalle:
if old_detalle.tipo_movto == 'E':
unidades_diferencia = detalle.unidades - old_detalle.unidades
elif old_detalle.tipo_movto == 'S':
unidades_diferencia = (detalle.unidades - old_detalle.unidades)*-1
else:
if detalle.tipo_movto == 'E':
unidades_diferencia = detalle.unidades
elif detalle.tipo_movto == 'S':
unidades_diferencia = detalle.unidades *-1
#Entrada
if unidades_diferencia >= 0:
detalle_clon = first_or_none( InventariosDocumentoDetalle.objects.filter(doctosIn=entrada_clon, articulo=detalle.articulo ))
if detalle_clon:
detalle_clon_unidades =detalle_clon.unidades
detalle_clon.unidades = detalle_clon.unidades + unidades_diferencia
detalle_clon.costo_unitario = detalle.costo_unitario
detalle_clon.costo_total = detalle_clon.unidades * detalle_clon.costo_unitario
detalle_clon.save()
else:
detalle_clon = InventariosDocumentoDetalle.objects.create(
doctosIn = entrada_clon,
almacen = almacen_clon,
concepto = entrada_clon.concepto,
claveArticulo = detalle.claveArticulo,
articulo = detalle.articulo,
tipo_movto = 'E',
unidades = unidades_diferencia,
costo_unitario = detalle.costo_unitario,
costo_total = unidades_diferencia * detalle.costo_unitario,
usuario_ult_modif = detalle.usuario_ult_modif
)
#Salida
elif unidades_diferencia < 0:
detalle_clon = first_or_none( InventariosDocumentoDetalle.objects.filter(doctosIn=salida_clon, articulo=detalle.articulo ))
unidades_diferencia = unidades_diferencia * -1
if detalle_clon:
detalle_clon.unidades = detalle_clon.unidades + unidades_diferencia
detalle_clon.costo_unitario = detalle.costo_unitario
detalle_clon.costo_total = detalle_clon.unidades * detalle_clon.costo_unitario
detalle_clon.save()
else:
detalle_clon = InventariosDocumentoDetalle.objects.create(
doctosIn = salida_clon,
almacen = almacen_clon,
concepto = salida_clon.concepto,
claveArticulo = detalle.claveArticulo,
articulo = detalle.articulo,
tipo_movto = 'S',
unidades = unidades_diferencia,
costo_unitario = detalle.costo_unitario,
costo_total = unidades_diferencia * detalle.costo_unitario,
usuario_ult_modif = detalle.usuario_ult_modif
)
c = connections[ kwargs.get('using') ].cursor()
c.execute( "DELETE FROM SALDOS_IN where saldos_in.articulo_id = %s;"% detalle_clon.articulo.id )
c.execute( "EXECUTE PROCEDURE RECALC_SALDOS_ART_IN %s;"% detalle_clon.articulo.id )
transaction.commit_unless_managed()
c.close()
management.call_command( 'syncdb', database = kwargs.get('using') )
def cliente_manageView(request, id = None, template_name='main/clientes/clientes/cliente.html'):
connection_name = get_conecctionname(request.session)
if connection_name == '':
return HttpResponseRedirect('/select_db/')
PATH = request.path
if '/punto_de_venta/cliente/' in PATH:
modulo = 'punto_de_venta'
elif '/ventas/cliente/' in PATH:
modulo = 'ventas'
message = ''
if id:
cliente = get_object_or_404(Cliente, pk=id)
direccion = first_or_none(ClienteDireccion.objects.filter(cliente=cliente))
if not direccion:
direccion = ClienteDireccion()
else:
cliente = Cliente()
direccion = ClienteDireccion()
direccion_form = DireccionClienteForm(request.POST or None, instance = direccion)
form = ClienteManageForm(request.POST or None, instance= cliente)
if form.is_valid() and direccion_form.is_valid():
clienteform = form.save( commit = False )
clienteform.usuario_ult_modif = request.user.username
clienteform.save()
direccion = direccion_form.save(commit=False)
direccion.cliente = clienteform
estado = direccion.ciudad.estado
pais = estado.pais
direccion.nombre_consignatario = u'Dirección principal'
#direccion.calle = '''%s %s %s,
#%s%s,
#%s
#'''%(direccion.calle_nombre, direccion.numero_exterior, direccion.numero_interior, direccion.colonia, direccion.poblacion, direccion.referencia)
direccion.calle = '''%s %s %s,
%s,
%s
'''%(direccion.calle_nombre, direccion.numero_exterior, direccion.numero_interior, direccion.colonia, direccion.referencia or '')
direccion.estado = estado
direccion.pais= pais
direccion.es_ppal = 'S'
direccion.save()
return HttpResponseRedirect('/%s/clientes/'%modulo)
# cliente_articulos = ClienteArticulo.objects.filter(cliente=id)
# except DatabaseError:
cliente_articulos= None
c = {
'cliente_articulos':cliente_articulos,
'form':form,
'direccion_form':direccion_form,
'extend':'%s/base.html'%modulo,
'modulo':modulo,
}
return render_to_response(template_name, c, context_instance=RequestContext(request))
def get_existenciasarticulo_byclave( request, **kwargs ):
""" Para obterner existencia de un articulo segun clave del articulo """
#Paramentros
almacen_nombre = kwargs.get( 'almacen', None)
almacen = Almacen.objects.get(nombre = almacen_nombre)
entrada_id = kwargs.get( 'entrada_id', None )
articulo_clave = kwargs.get( 'articulo_clave', None)
connection_name = get_conecctionname( request.session )
#variables de salida
error = ""
inv_fin = 0
articulo_linea = ''
articulo_id = ''
articulo_nombre = ''
articulo_seguimiento = ''
costo_ultima_compra= ''
clave_articulo = first_or_none( ArticuloClave.objects.filter( clave = articulo_clave, articulo__estatus = 'A'))
if clave_articulo:
if clave_articulo.articulo.seguimiento == 'L':
clave_articulo = None
opciones_clave = {}
detalle_modificacionestime = ''
detalle_modificacionestime_salidas = ''
ya_ajustado = False
if clave_articulo:
articulo = Articulo.objects.get( pk = clave_articulo.articulo.id )
detalles_all = InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ) | Q( doctosIn__concepto = 38 ),
articulo = articulo,
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO').order_by('fechahora_ult_modif')
if detalles_all:
ya_ajustado = True
else:
c = connections[ connection_name ].cursor()
c.execute( "DELETE FROM SALDOS_IN where saldos_in.articulo_id = %s;"% articulo.id )
c.execute( "EXECUTE PROCEDURE RECALC_SALDOS_ART_IN %s;"% articulo.id )
transaction.commit_unless_managed()
c.close()
management.call_command( 'syncdb', database = connection_name )
inv_fin = get_existencias_articulo(
articulo_id = articulo.id,
connection_name = connection_name,
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = almacen_nombre, )
articulo_id = articulo.id
articulo_nombre = articulo.nombre
try:
articulo_linea = articulo.linea.nombre
except ObjectDoesNotExist:
articulo_linea = 'No indicada aun'
articulo_seguimiento = articulo.seguimiento
detalles_entradas = InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ),
articulo = articulo,
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO'
).order_by('fechahora_ult_modif')
detalles_salidas = InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 38 ),
articulo = articulo,
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO').order_by('fechahora_ult_modif')
for detalle_entradas in detalles_entradas:
if not detalle_entradas.detalle_modificacionestime:
detalle_entradas.detalle_modificacionestime =''
detalle_modificacionestime = detalle_modificacionestime + detalle_entradas.detalle_modificacionestime
for detalle_salidas in detalles_salidas:
if not detalle_salidas.detalle_modificacionestime:
detalle_salidas.detalle_modificacionestime = ''
detalle_modificacionestime_salidas = detalle_modificacionestime_salidas + detalle_salidas.detalle_modificacionestime
#si el articulo no tiene costo de ultima compra se le manda en 0
costo_ultima_compra = articulo.costo_ultima_compra
if not costo_ultima_compra:
costo_ultima_compra = 0
else:
error = "no_existe_clave"
claves = ArticuloClave.objects.filter( clave__contains = articulo_clave, articulo__estatus='A',)
for c in claves:
if c.articulo.seguimiento == 'S' or c.articulo.seguimiento == 'N':
opciones_clave[ str( c.clave ) ] = c.articulo.nombre
if not detalle_modificacionestime:
detalle_modificacionestime = ''
datos = {
'error_msg' : error,
'ya_ajustado': ya_ajustado,
'articulo_id' : articulo_id,
'articulo_seguimiento': articulo_seguimiento,
'articulo_nombre' : articulo_nombre,
'existencias' : str(inv_fin),
'costo_ultima_compra' : str(costo_ultima_compra),
'opciones_clave': opciones_clave,
'detalle_modificacionestime': detalle_modificacionestime,
'detalle_modificacionestime_salidas': detalle_modificacionestime_salidas,
'articulo_linea' : articulo_linea,
}
return HttpResponse( json.dumps( datos ), mimetype = "application/javascript" )
def add_articulos_sincontar( **kwargs ):
""" Agrega articulos almacenables de la linea indicada faltantes en los documentos de ajustes indicados. """
#Paramentros
request_username = kwargs.get( 'request_username', None )
connection_name = kwargs.get( 'connection_name', None )
ubicacion = kwargs.get( 'ubicacion', None )
linea = kwargs.get( 'linea', None )
almacen = kwargs.get( 'almacen', None )
message= ''
articulos_endocumentos = list( set( InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ) | Q( doctosIn__concepto = 38 ),
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO'
).order_by( '-articulo' ).values_list( 'articulo__id', flat = True ) ) )
inventario_descripcion = ''
#Para agregar los articulos de los documentos de inventarios como ya contados
if linea:
#VALIDACIONES
if InventariosDocumentoIF.objects.filter(descripcion= 'ARTICULOS SIN CONTAR', aplicado= 'N', almacen= almacen).exists():
message = 'Ya se genero anteriormente un documento con articulos sin contar de todos los articulos, OPERACION RECHAZADA!!'
return json.dumps( { 'articulos_agregados' : 0, 'articulo_pendientes' : 0, 'message': message, } )
inventario_descripcion = 'ARTICULOS SIN CONTAR LINEA(%s)'% linea.nombre
articulos_all = list( set( Articulo.objects.exclude(estatus = 'B').filter( es_almacenable = 'S', linea = linea ).order_by( '-id' ).values_list( 'id', flat = True ) ))
else:
inventario_descripcion = 'ARTICULOS SIN CONTAR'
articulos_all = list( set( Articulo.objects.exclude( estatus = 'B').filter( es_almacenable = 'S').order_by( '-id' ).values_list( 'id', flat = True )))
inventarios_fisicos = InventariosDocumentoIF.objects.filter(descripcion__contains= inventario_descripcion, aplicado= 'N', almacen= almacen)
for inventario_fisico in inventarios_fisicos:
articulos_endocumentosinv = (
list( set( InventariosDocumentoIFDetalle.objects.filter( docto_invfis = inventario_fisico, ).order_by( '-articulo' ).values_list( 'articulo__id', flat = True ) )
)
)
articulos_endocumentos = articulos_endocumentos + articulos_endocumentosinv
articulos_sincontar = [n for n in articulos_all if n not in articulos_endocumentos]
total_articulos_sincontar = len(articulos_sincontar)
articulos_sincontar = articulos_sincontar[0:9000]
articulos_sincontar_list = split_seq( articulos_sincontar, 2000 )
articulos_agregados = 0
ultimofolio = Registry.objects.filter( nombre = 'SIG_FOLIO_INVFIS' )
if total_articulos_sincontar <= 0:
message = 'No hay articulos por agregar!!'
return json.dumps( { 'articulos_agregados' : 0, 'articulo_pendientes' : 0, 'message': message, } )
if not ultimofolio.exists():
message = 'Para poder crear un inventario es nesesario Asignarles folios automaticos a los inventarios fisicos, OPERACION RECHAZADA!!'
return json.dumps( { 'articulos_agregados' : 0, 'articulo_pendientes' : 0, 'message': message, } )
inventario = InventariosDocumentoIF.objects.create(
id = next_id('ID_DOCTOS', connection_name),
folio = inventario_getnew_folio(),
fecha = datetime.now(),
almacen = almacen,
descripcion = inventario_descripcion,
usuario_creador = request_username,
usuario_aut_creacion = 'SYSDBA',
usuario_ult_modif = request_username,
usuario_aut_modif = 'SYSDBA',
)
for articulos_sincontar_sublist in articulos_sincontar_list:
detalles_en_ceros = 0
for articulo_id in articulos_sincontar_sublist:
articulo = Articulo.objects.get(pk=articulo_id)
InventariosDocumentoIFDetalle.objects.create(
id = -1,
docto_invfis = inventario,
clave = first_or_none( ArticuloClave.objects.filter( articulo = articulo ) ),
articulo = articulo,
unidades = 0,
)
detalles_en_ceros = detalles_en_ceros + 1
articulos_agregados = articulos_agregados + detalles_en_ceros
articulos_pendientes = total_articulos_sincontar - articulos_agregados
return json.dumps( { 'articulos_agregados' : articulos_agregados, 'articulo_pendientes' : articulos_pendientes, 'message': message, } )
def add_existenciasarticulo_byajustes( **kwargs ):
""" Para agregar existencia a un articulo por ajuste
En caso de que el articulo no tenga costo indicado [se le aplica el de la ultima compra]
"""
#Paramentros
ajustar_primerconteo = kwargs.get( 'ajustar_primerconteo', None )
ubicacion = kwargs.get( 'ubicacion', None )
articulo_id = kwargs.get( 'articulo_id', None )
articulo = Articulo.objects.get( pk = articulo_id )
entrada_id = kwargs.get( 'entrada_id', None )
entrada = InventariosDocumento.objects.get( pk = entrada_id )
salida_id = kwargs.get( 'salida_id', None )
salida = InventariosDocumento.objects.get( pk = salida_id )
almacen_id = kwargs.get( 'almacen_id', None )
almacen = Almacen.objects.get( pk = almacen_id)
request_session = kwargs.get( 'request_session', 0 )
request_user = kwargs.get( 'request_user', 0 )
connection_name = get_conecctionname( request_session )
detalle_unidades = kwargs.get( 'detalle_unidades', 0 )
detalle_costo_unitario = kwargs.get( 'detalle_costo_unitario', articulo.costo_ultima_compra )
puede_modificar_costos = allow_microsipuser( username = request_user.username, clave_objeto = 469) and almacen.inventario_modifcostos
detalles_entradas_ultimocosto = first_or_none( InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ),
articulo = articulo,
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO'
).order_by('-fechahora_ult_modif').values_list( 'costo_unitario', flat = True ) )
if not detalles_entradas_ultimocosto:
detalles_entradas_ultimocosto = articulo.costo_ultima_compra
existe_en_detalles = InventariosDocumentoDetalle.objects.filter(
Q( doctosIn__concepto = 27 ) | Q( doctosIn__concepto = 38 ),
articulo = articulo,
almacen = almacen,
doctosIn__descripcion = 'ES INVENTARIO',
).count() > 0
detalle_entradas = first_or_none( InventariosDocumentoDetalle.objects.filter( articulo = articulo, doctosIn = entrada ) )
detalle_salidas = first_or_none( InventariosDocumentoDetalle.objects.filter( articulo = articulo, doctosIn = salida ) )
articulo_clave = first_or_none( ArticuloClave.objects.filter( articulo = articulo ) )
detalle = InventariosDocumentoDetalle(
articulo = articulo,
claveArticulo = articulo_clave,
almacen = almacen,
unidades = detalle_unidades,
)
#Logica
existencia_inicial = ''
#Si no se existe arituclo en documentos se ajustan unidades
if not existe_en_detalles:
existencia_inicial = get_existencias_articulo(
articulo_id = articulo.id,
connection_name = connection_name,
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = almacen,
)
detalle.detalle_modificacionestime ='EXISTIN=%s / COSTOIN=%s,'%(existencia_inicial, articulo.costo_ultima_compra)
if ajustar_primerconteo:
detalle.unidades = ajustar_existencias( articulo_id = articulo.id, ajustar_a = detalle.unidades ,almacen = almacen , connection_name = connection_name )
es_nuevo = False
#SALIDA
if detalle.unidades <= 0:
#si no existe detalle salidas
if not detalle_salidas:
es_nuevo = True
detalle_salidas = detalle
detalle_salidas.id = next_id( 'ID_DOCTOS', connection_name )
detalle_salidas.doctosIn = salida
detalle_salidas.concepto = salida.concepto
detalle_salidas.tipo_movto ='S'
detalle_salidas.unidades = -detalle_salidas.unidades
#Si exitse detalle salidas
elif detalle_salidas:
detalle_salidas.unidades = detalle_salidas.unidades + ( -detalle.unidades )
#Desde salida no se permite cambiar costo unitario
detalle_salidas.costo_unitario = detalles_entradas_ultimocosto
detalle = detalle_salidas
#ENTRADA
elif detalle.unidades > 0:
if not detalle_entradas:
es_nuevo = True
detalle_entradas = detalle
detalle_entradas.id = next_id( 'ID_DOCTOS', connection_name )
detalle_entradas.doctosIn = entrada
detalle_entradas.concepto = entrada.concepto
detalle_entradas.tipo_movto ='E'
elif detalle_entradas:
detalle_entradas.unidades = detalle_entradas.unidades + detalle.unidades
detalle = detalle_entradas
costo_modificaciones = ''
#MODIFICA COSTOS
if puede_modificar_costos:
if detalle.tipo_movto == 'E':
detalle.costo_unitario = detalle_costo_unitario
#Afecta costo en articulo
if articulo.costo_ultima_compra != detalle.costo_unitario:
articulo.costo_ultima_compra = detalle.costo_unitario
articulo.save(update_fields=['costo_ultima_compra',])
costo_modificaciones = 'COSTO(%s)'%detalle.costo_unitario
#si se ajusto el conteo pero en realidad se metieron unidades positivas cambia costo de compra
if detalle.tipo_movto == 'S' and detalle_unidades >= 0:
detalle.costo_unitario = detalle_costo_unitario
#Afecta costo en articulo
if articulo.costo_ultima_compra != detalle.costo_unitario:
articulo.costo_ultima_compra = detalle.costo_unitario
articulo.save(update_fields=['costo_ultima_compra',])
costo_modificaciones = 'COSTO(%s)'%detalle.costo_unitario
else:
#si el articulo no tiene costo de ultima compra se le manda en 0
detalle.costo_unitario = articulo.costo_ultima_compra
if not detalle.costo_unitario:
detalle.costo_unitario = 0
detalle.costo_total = detalle.unidades * detalle.costo_unitario
detalle.fechahora_ult_modif = datetime.now()
# HISTORIAL DE MODIFICACIONES
if detalle.detalle_modificacionestime == None:
detalle.detalle_modificacionestime = ''
detalle_ajuste = ''
if not existe_en_detalles:
if ajustar_primerconteo:
if detalle.tipo_movto == 'S':
detalle_ajuste = '(AJ=-%s)'% detalle.unidades
elif detalle.tipo_movto == 'E':
detalle_ajuste = '(AJ=%s)'% detalle.unidades
detalle.detalle_modificacionestime += '%s %s/%s=%s%s%s,'%( datetime.now().strftime("%d-%b-%Y %I:%M %p"), request_user.username, ubicacion, detalle_unidades, detalle_ajuste, costo_modificaciones)
if es_nuevo:
detalle.save()
else:
detalle.save( update_fields = [ 'unidades', 'costo_unitario', 'costo_total', 'fechahora_ult_modif','detalle_modificacionestime', ] );
c = connections[ connection_name ].cursor()
c.execute( "DELETE FROM SALDOS_IN where saldos_in.articulo_id = %s;"% articulo.id )
c.execute( "EXECUTE PROCEDURE RECALC_SALDOS_ART_IN %s;"% articulo.id )
transaction.commit_unless_managed()
c.close()
management.call_command( 'syncdb', database = connection_name )
exitencia = get_existencias_articulo(
articulo_id = articulo.id,
connection_name = connection_name,
fecha_inicio = datetime.now().strftime( "01/01/%Y" ),
almacen = almacen,
)
datos = {'error_message': '', 'alamcen_id': almacen.ALMACEN_ID, 'articulo_nombre': articulo.nombre, 'existencia_actual': str(exitencia) }
return datos
def SincronizarClienteDireccion(**kwargs):
''' Para sincronizar primer plazo de condiciones de pago en todas las empreas registradas. '''
using = kwargs.get('using')
#DATOS ORIGEN
fuente_cliente_nombre = kwargs.get('fuente_cliente_nombre')
fuente_cliente = Cliente.objects.using(default_db).get(nombre=fuente_cliente_nombre)
fuente_direccion = first_or_none(ClienteDireccion.objects.using(default_db).filter(cliente= fuente_cliente))
#DATOS DESTINO
cliente = Cliente.objects.using(using).get(nombre=fuente_cliente.nombre)
direccion = first_or_none(ClienteDireccion.objects.using(using).filter(cliente= cliente))
if direccion:
direccion.rfc_curp = fuente_direccion.rfc_curp
ciudad = Ciudad.objects.using(using).get(nombre=fuente_direccion.ciudad.nombre)
direccion.ciudad = ciudad
direccion.colonia = fuente_direccion.colonia
direccion.nombre_consignatario = fuente_direccion.nombre_consignatario
direccion.calle = fuente_direccion.calle
direccion.es_ppal = fuente_direccion.es_ppal
if settings.MICROSIP_VERSION >= 2013:
direccion.poblacion = fuente_direccion.poblacion
direccion.referencia = fuente_direccion.referencia
direccion.codigo_postal = fuente_direccion.codigo_postal
direccion.calle_nombre = fuente_direccion.calle_nombre
direccion.numero_exterior = fuente_direccion.numero_exterior
direccion.numero_interior = fuente_direccion.numero_interior
direccion.email = fuente_direccion.email
direccion.save(using=using)
else:
ciudad_original_nombre = fuente_direccion.ciudad.nombre
estado_original_nombre = fuente_direccion.estado.nombre
pais_original_nombre = fuente_direccion.pais.nombre
ciudad = Ciudad.objects.using(using).filter(nombre=ciudad_original_nombre).values_list( 'id', flat = True )[0]
estado = Estado.objects.using(using).filter(nombre=estado_original_nombre).values_list( 'id', flat = True )[0]
pais = Pais.objects.using(using).filter(nombre=pais_original_nombre).values_list( 'id', flat = True )[0]
kwargs = {
'cliente': cliente.id,
'rfc_curp': fuente_direccion.rfc_curp,
'ciudad': ciudad,
'estado': estado,
'pais': pais,
'colonia': fuente_direccion.colonia,
'nombre_consignatario': fuente_direccion.nombre_consignatario,
'calle': fuente_direccion.calle,
'es_ppal': fuente_direccion.es_ppal,
'referencia': fuente_direccion.referencia,
'codigo_postal': fuente_direccion.codigo_postal,
'calle_nombre': fuente_direccion.calle_nombre,
'numero_exterior': fuente_direccion.numero_exterior,
'numero_interior': fuente_direccion.numero_interior,
'email': fuente_direccion.email,
'using':using,
}
if settings.MICROSIP_VERSION >= 2013:
kwargs['poblacion']= fuente_direccion.poblacion
ClienteDireccion.objects.create_simple(**kwargs)
def factura_manageView( request, id = None, template_name='punto_de_venta/documentos/facturas/factura.html' ):
message = ''
connection_name = get_conecctionname(request.session)
factura_nueva = False
if id:
factura = get_object_or_404( PuntoVentaDocumento, pk = id )
else:
factura = PuntoVentaDocumento()
#Cargar formularios
if id:
factura_form = FacturaManageForm( request.POST or None, instance = factura,)
factura_items = DocumentoPV_items_formset(DocumentoPVDet_ManageForm, extra=0, can_delete=False)
else:
initial_factura = { 'fecha': datetime.now(),}
factura_form = FacturaManageForm( request.POST or None, instance = factura, initial= initial_factura)
factura_items = DocumentoPV_items_formset(DocumentoPVDet_ManageForm, extra=1, can_delete=False)
formset = factura_items(request.POST or None, instance=factura)
factura_global_fm = factura_global_form(request.POST or None)
if formset.is_valid() and factura_form.is_valid() and factura_global_fm.is_valid():
factura = factura_form.save(commit=False)
cliente = factura.cliente
cliente_clave = first_or_none( ClienteClave.objects.filter( cliente= cliente ) )
cliente_direccion = first_or_none( ClienteDireccion.objects.filter( cliente= cliente ) )
factura_global_tipo = factura_global_fm.cleaned_data['tipo']
#Si es una factura nueva
if not factura.id:
factura_nueva= True
factura.id= -1
factura.caja= first_or_none( Caja.objects.all() )
factura.tipo= 'F'
factura.aplicado = 'S'
factura.folio= ''#Se deja vacio para que se calcule el folio al guardar
factura.fecha= datetime.now()
factura.hora= datetime.now().strftime('%H:%M:%S')
factura.clave_cliente= cliente_clave
factura.cliente= cliente
factura.clave_cliente_fac= cliente_clave
factura.cliente_fac= cliente
factura.direccion_cliente= cliente_direccion
factura.moneda= Moneda.objects.get(pk= 1)
factura.impuesto_incluido= 'N'
factura.tipo_cambio= 1
factura.unidad_comprom= 'S'
factura.tipo_descuento= 'I'
#datos de factura global
# factura.tipo_gen_fac='R'
# factura.es_fac_global='S'
# factura.fecha_ini_fac_global = fecha_ini_fac_global
# factura.fecha_fin_fac_global = fecha_fin_fac_global
factura.porcentaje_descuento=0
factura.sistema_origen='PV'
factura.persona='FACTURA GLOBAL DIARIA'
factura.usuario_creador= request.user.username
factura.save()
ventas_en_factura = factura_form.cleaned_data['ventas_en_factura']
impuestos_venta_neta = factura_form.cleaned_data['impuestos_venta_neta'].split(',')
impuestos_otros_impuestos = factura_form.cleaned_data['impuestos_otros_impuestos'].split(',')
impuestos_importe_impuesto = factura_form.cleaned_data['impuestos_importe_impuesto'].split(',')
impuestos_porcentaje_impuestos = factura_form.cleaned_data['impuestos_porcentaje_impuestos'].split(',')
impuestos_ids = factura_form.cleaned_data['impuestos_ids'].split(',')
#Guardar impuestos
for impuesto_id, venta_neta, otros_impuestos, importe_impuesto, porcentaje_impuesto in zip(impuestos_ids, impuestos_venta_neta, impuestos_otros_impuestos, impuestos_importe_impuesto, impuestos_porcentaje_impuestos ):
if impuesto_id != "":
c = connections[connection_name].cursor()
query = '''INSERT INTO "IMPUESTOS_DOCTOS_PV" ("DOCTO_PV_ID", "IMPUESTO_ID", "VENTA_NETA", "OTROS_IMPUESTOS", "PCTJE_IMPUESTO", "IMPORTE_IMPUESTO") \
VALUES (%s, %s, %s, %s, %s, %s)'''%(factura.id, impuesto_id, venta_neta, otros_impuestos, porcentaje_impuesto, importe_impuesto)
c.execute(query)
c.close()
ventas_en_factura_sting = ventas_en_factura
ventas_faturadas = ventas_en_factura.split(',')
if ventas_faturadas!= [u'']:
for venta_facturada in ventas_faturadas:
venta = PuntoVentaDocumento.objects.get(pk=venta_facturada)
PuntoVentaDocumentoLiga.objects.create(
id = -1,
docto_pv_fuente = venta,
docto_pv_destino = factura,
)
ventas_ligas = PuntoVentaDocumentoLiga.objects.filter(docto_pv_destino= factura)
#Se guardan detalles de factura
for detalle_form in formset:
detalle = detalle_form.save(commit = False)
if not detalle.id:
detalle.id = -1
detalle.documento_pv = factura
detalle.unidades_dev = 0
detalle.precio_unitario_impto = detalle.precio_unitario
detalle.fpgc_unitario = 0
detalle.precio_modificado = 'N'
detalle.porcentaje_comis = 0
detalle.rol = 'N'
detalle.notas = 'FOLIOS:'
detalle.posicion = -1
detalle.save()
#Se generan todos los detalles de ligas
if factura_global_tipo == 'C' and factura_nueva:
detalle_ligas = detalle_form.cleaned_data['detalles_liga'].split(',')
if detalle_ligas!= [u'']:
for detalle_liga in detalle_ligas:
detalle_doc = PuntoVentaDocumentoDetalle.objects.get(pk=detalle_liga)
documento_liga = PuntoVentaDocumentoLiga.objects.get(docto_pv_fuente= detalle_doc.documento_pv)
c = connections[connection_name].cursor()
query = '''INSERT INTO "DOCTOS_PV_LIGAS_DET" ("DOCTO_PV_LIGA_ID", "DOCTO_PV_DET_FTE_ID", "DOCTO_PV_DET_DEST_ID") \
VALUES (%s, %s, %s)'''%(documento_liga.id, detalle_doc.id , detalle.id)
c.execute(query)
c.close()
#Si es una factura global nueva y si es por partida
if factura_global_tipo == 'P' and factura_nueva:
#Se generan todos los detalles de ligas
for docto_pv_liga in ventas_ligas:
for detalle_venta in PuntoVentaDocumentoDetalle.objects.filter(documento_pv=docto_pv_liga.docto_pv_fuente):
c = connections[connection_name].cursor()
query = '''INSERT INTO "DOCTOS_PV_LIGAS_DET" ("DOCTO_PV_LIGA_ID", "DOCTO_PV_DET_FTE_ID", "DOCTO_PV_DET_DEST_ID") \
VALUES (%s, %s, %s)'''%(docto_pv_liga.id, detalle_venta.id, detalle.id)
c.execute(query)
c.close()
#Para aplicar la factura
c = connections[connection_name].cursor()
query = "EXECUTE PROCEDURE APLICA_FAC_PV(%s,'N');"%factura.id
c.execute(query)
c.close()
transaction.commit_unless_managed()
management.call_command( 'syncdb', database = connection_name )
message= 'Factura guardada'
ventas_factura = PuntoVentaDocumentoLiga.objects.filter(docto_pv_destino= factura)
c = {
'factura_global_fm':factura_global_fm,
'factura_form': factura_form,
'formset':formset,
'message':message,
'ventas_factura':ventas_factura,
'message':message,
}
return render_to_response(template_name, c, context_instance=RequestContext(request))
