def __init__(self, parent=None):
super(ModeloTablaDestino, self).__init__()
self.__querier = querier.Querier(tabla="destinos", prefijo="des_")
self.__scDestino = {
'des_id': {
'type': 'integer',
'nullable': True
},
'des_maquina': {
'type': 'string'
},
'des_descripcion': {
'type': 'string'
}
}
self.__header = ["Codigo", "Destino", "Observaciones"]
self.__destinos = ["", "", ""]
self.destino = {}
try:
resultados = self.__querier.traerElementos(
campos=["des_id", "des_maquina", "des_descripcion"])
# print("Resultados: ", resultados)
for resultado in resultados:
self.__destinos.append(resultado[0])
self.layoutChanged.emit()
except:
# mensaje el observer que hay un error, guardarlo en el log de errores y cerrar
print('ERROR - No se pudieron levantar los destinos')
self.verListaDestinos()
def guardarRelacion(self, fila):
articuloDeProv = {}
if self.tipo == "articulos":
articuloDeProv['proveedor'] = self.idElemento
articuloDeProv['articulo'] = self.elementos[fila][0]
elif self.tipo == "proveedores":
articuloDeProv['articulo'] = self.idElemento
articuloDeProv['proveedor'] = self.elementos[fila][0]
print(articuloDeProv)
q = querier.Querier(tabla="articulos_de_proveedores", prefijo="")
q.insertarElemento(articuloDeProv)
def setTipo(self, tipo):
prefijo = ""
self.tipo = tipo
if tipo == "articulos":
prefijo = "art_"
self.campos = ["art_id", "art_descripcion"]
self.__headers = ["Codigo", "Descripcion"]
elif tipo == "proveedores":
prefijo == "prov_"
self.campos = ["prov_id", "prov_nombre"]
self.__headers = ["Codigo", "Nombre"]
self.__querier = querier.Querier(tabla=tipo, prefijo=prefijo)
def __init__(self, parent=None):
super(ModeloDestino, self).__init__()
self.__querier = querier.Querier(tabla="destinos", prefijo="des_")
self.__destinos = ["Destino"]
self.__desIds = []
orden = ("des_maquina", "ASC")
print("REINICIO EL MODELO")
try:
resultados = self.__querier.traerElementos(campos=["des_maquina"])
resulta2 = self.__querier.traerElementos(campos=["des_id"])
for resultado in resulta2:
self.__desIds.append(resulta2[0])
for resultado in resultados:
self.__destinos.append(resultado[0])
self.layoutChanged.emit()
except:
# mensaje el observer que hay un error, guardarlo en el log de errores y cerrar
print('ERROR - No se pudieron levantar los destinos')
def __init__(self, propiedades=None, parent=None):
super(ModeloProveedor, self).__init__()
self.__querier = querier.Querier(tabla="proveedores", prefijo="prov_")
self.__scProveedor = {
'prov_id': {
'type': 'integer',
'nullable': True
},
'prov_nombre': {
'type': 'string',
'required': True,
'maxlength': 60
},
'prov_razon_social': {
'type': 'string',
'maxlength': 60
},
'prov_cuit': {
'type': 'string',
'maxlength': 20
},
'prov_direccion': {
'type': 'string',
'maxlength': 30
},
'prov_telefono': {
'type': 'string',
'maxlength': 30
},
'prov_telefono_dos': {
'type': 'string',
'maxlength': 30
},
'prov_email': {
'type': 'string',
'maxlength': 40
},
'prov_activo': {
'type': 'integer',
'allowed': [0, 1]
},
'prov_notas': {
'type': 'string'
},
'prov_nombre_contacto': {
'type': 'string',
'maxlength': 30
}
}
self.__propiedades = [
'Codigo', 'Nombre', 'Razon Social', 'Cuit', 'Direccion',
'Teléfono', 'Teléfono secundario', 'Email'
]
if propiedades:
self.__propiedades = propiedades
self.relacion = {
'Codigo': 'prov_id',
'Nombre': 'prov_nombre',
'Razon Social': 'prov_razon_social',
'Cuit': 'prov_cuit',
'Direccion': 'prov_direccion',
'Teléfono': 'prov_telefono',
'Teléfono secundario': 'prov_telefono_dos',
'Email': 'prov_email'
}
self.__busqueda = []
for propiedad in self.__propiedades:
self.__busqueda.append(self.relacion[propiedad])
self.proveedores = self.__querier.traerElementos(self.__busqueda)
self.proveedor = {}
class ModeloComprobante(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier(tabla="comprobantes", prefijo="comp_")
__v = cerberus.Validator()
def __init__(self, propiedades=None, parent=None):
super(ModeloComprobante, self).__init__()
self.__scComprobante = {
'comp_id': {
'type': 'integer',
'max': 9999999999999999
},
'comp_prefijo': {
'type': 'string',
'maxlength': 10
},
'comp_numero': {
'type': 'integer',
'max': 99999999999999999999
},
'comp_fecha': {
'type': 'date'
},
'ing_id': {
'type': 'integer',
'max': 9999999999999999
},
}
self.__busqueda
for componente in self.__scComprobante:
self.__busqueda.append(componente)
self.comprobantes = self.__querier.traerComprobantes(self.__busqueda)
self.comprobante = {}
def crearComprobante(self, comprobanteNuevo):
v = self.__v.validate(comprobanteNuevo, self.__scComprobante)
if v:
self.__querier.insertarComprobante(comprobanteNuevo)
else:
print("ERRORES: ", self.__v.errors)
return v
def verDetallesComprobante(self,
comprobante,
campos=None,
condiciones=None):
comprobante = self.comprobantes[comprobante.row()]
condiciones = [('comp_id', '=', comprobante[0])]
resultado = self.__querier.traerComprobantes(campos, condiciones, 1)
self.comprobante = resultado[0]
return self.comprobante
def modificarComprobante(self, comprobante):
self.__querier.actualizarComprobante(comprobante)
def toggleComprobanteActivo(self, comprobante):
if comprobante['comp_activo']:
comprobante['comp_activo'] = 0
else:
comprobante['comp_activo'] = 1
self.__querier.actualizarComprobante(comprobante)
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.comprobantes)
def columnCount(self, parent):
if self.comprobantes:
return len(self.comprobantes[0])
else:
return 0
def flags(self, index):
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.comprobantes[row][column]
return value
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
value = self.comprobantes[row][column]
return value
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__propiedades[section]
def insertRows(self, position, rows, parent=QtCore.QModelIndex()):
self.beginInsertRows()
self.endInsertRows()
def insertColumns(self, position, columns, parent=QtCore.QModelIndex()):
self.beginInsertColumns()
self.endInsertColumns()
def removeRows():
self.beginRemoveRows()
self.endRemoveRows()
def removeColumns():
self.beginRemoveColumns()
self.endRemoveColumns()
class ModeloEgreso(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier(tabla="egresos", prefijo="egr_")
__querierMove = querier.Querier(tabla="movimientos_egreso",
prefijo="move_")
__querierMovi = querier.Querier(tabla="movimientos_ingreso",
prefijo="movi_")
__querierArt = querier.Querier(tabla="articulos", prefijo="art_")
__querierOpe = querier.Querier(tabla="operarios", prefijo="ope_")
__v = cerberus.Validator()
def __init__(self, propiedades=None, parent=None):
super(ModeloEgreso, self).__init__()
self.__scEgreso = {
'egr_id': {
'type': 'integer',
'max': 9999999999999999
},
'egr_columna1': {
'type': 'string'
},
'egr_columna2': {
'type': 'string'
},
'egr_columna3': {
'type': 'string'
},
'egr_columna4': {
'type': 'string'
},
}
self.__scMovEgreso = {
'movi_': {
'type': 'something'
},
'movi_': {
'type': 'something'
},
'movi_': {
'type': 'something'
},
'egr_id': {
'type': 'integer',
'max': 9999999999999999
},
}
self.__headers = ["Codigo", "Descripcion", "Cantidad"]
# self.__movimientos = self.__querier.traerElementos(self.__busqueda)
self.__movimientos = [["", "", ""]]
self.__maximos = [0]
self.egreso = {}
def crearEgreso(self, operario, detalles):
if len(self.__movimientos) == 1:
return False
hoy = date.today()
egreso = {
'egr_fecha': hoy,
'ope_legajo': operario,
'egr_vale': detalles[2]
}
self.__querier.insertarElemento(egreso)
print("egreso creado")
egrId = self.__querier.traerElementos(campos=["egr_id"],
orden=("egr_id", "DESC"),
limite=1)
egrId = egrId[0][0]
print("id de egreso tomado")
for movimiento in self.__movimientos:
# SI EL MOVIMIENTO ESTÁ EN 0 LO IGNORA
if movimiento[2] == 0 or movimiento[2] == '':
continue
movimiento = {
'art_id': movimiento[0],
'egr_id': egrId,
'move_cantidad': int(movimiento[2]),
'move_destino': detalles[0],
'move_sector': detalles[1],
}
stock = movimiento['move_cantidad']
restantesIn = self.__querierMovi.traerElementos(
campos=["movi_id, movi_restante"],
orden=("movi_id", "ASC"),
condiciones=[("art_id", " = ", movimiento['art_id'])])
restantesOut = []
for restante in restantesIn:
restante = list(restante)
if restante[1] > stock:
restante[1] -= stock
else:
stock -= restante[1]
restante[1] = 0
restantesOut.append({
'movi_id': restante[0],
'movi_restante': restante[1]
})
print(
"DEBUG - Los restantes a actualizar en la base de datos son: ",
restantesOut)
if not movimiento['art_id']:
continue
self.__querierMove.insertarElemento(movimiento)
for elemento in restantesOut:
self.__querierMovi.actualizarElemento(elemento)
# self.reiniciarTablaEgreso()
return True
def verDetallesEgreso(self, egreso, campos=None, condiciones=None):
egreso = self.__movimientos[egreso.row()]
condiciones = [('egr_id', '=', egreso[0])]
resultado = self.__querier.traerElementos(campos, condiciones, 1)
self.egreso = resultado[0]
return self.egreso
def modificarEgreso(self, egreso):
self.__querier.actualizarEgreso(egreso)
def toggleEgresoActivo(self, egreso):
if egreso['egr_activo']:
egreso['egr_activo'] = 0
else:
egreso['egr_activo'] = 1
self.__querier.actualizarEgreso(egreso)
def buscarOperario(self, campos=None, condiciones=None):
self.__operario = {}
resultado = self.__querierOpe.traerElementos(campos, condiciones)
if resultado:
self.__operario = resultado[0]
return self.__operario
def getMovimientos(self):
return self.__movimientos
def reiniciarTablaEgreso(self):
self.__maximos = [0]
self.egreso = {}
self.removeRows()
def getArticulos(self):
articulos = []
for movimiento in self.__movimientos:
if movimiento[0] == '': continue
articulos.append((movimiento[0], movimiento[2]))
return articulos
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.__movimientos)
def columnCount(self, parent):
if self.__movimientos:
return len(self.__movimientos[0])
else:
return 0
def flags(self, index):
columna = index.column()
fila = index.row()
if (columna == 2 or columna == 3) and self.__movimientos[fila][0]:
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled
if columna == 0:
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled
return QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.__movimientos[row][column]
return value
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
if column == 0:
for articulo in self.__movimientos:
if value == str(articulo[0]):
return False
self.__articulo = {}
stockMaximo = 0
if column == 0:
try:
value = int(value)
resultado = self.__querierArt.traerElementos(
campos=("art_id", "art_descripcion",
"art_stock_actual"),
condiciones=[("art_id", " = ", value)])
stockMaximo = resultado[0][2]
self.__articulo = list(resultado[0])
print(self.__articulo)
except:
return False
if not self.__movimientos[row][0]:
self.insertRows(self.rowCount(self), 1)
self.__maximos.insert(self.rowCount(self), stockMaximo)
else:
self.__movimientos[row] = self.__articulo
self.__maximos[row] = stockMaximo
self.dataChanged.emit(index, index)
return True
else:
try:
value = int(value)
print(value, self.__movimientos[row][2])
if value < 0:
return False
elif value > self.__maximos[row]:
return False
except:
return False
self.__movimientos[row][column] = value
self.dataChanged.emit(index, index)
return True
return False
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__headers[section]
def insertRows(self, row, count, parent=QtCore.QModelIndex()):
self.beginInsertRows(parent, row, row)
self.__movimientos.insert(row, self.__articulo)
self.endInsertRows()
def removeRows(self, row=1, parent=QtCore.QModelIndex()):
last = self.rowCount(parent) - 1
self.beginRemoveRows(parent, row, last)
self.__movimientos = [["", "", "", ""]]
# self.dataChanged.emit()
self.endRemoveRows()
class ModeloOperario(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier( tabla = "operarios", prefijo = "ope_")
__v = cerberus.Validator()
def __init__(self, propiedades = None, parent = None):
super(ModeloOperario, self).__init__()
self.__scOperario = {
'ope_legajo' : {'type' : 'integer' },
'ope_nombre' : {'type' : 'string' },
'ope_apellido' : {'type' : 'string' },
'ope_puesto' : {'type' : 'string' },
}
self.__propiedades = [
'Legajo',
'Nombre',
'Apellido',
'Puesto'
]
if propiedades:
self.__propiedades = propiedades
self.relacion = {
'Legajo' : 'ope_legajo',
'Nombre' : 'ope_nombre',
'Apellido' : 'ope_apellido',
'Puesto' : 'ope_puesto'
}
self.__busqueda = []
for propiedad in self.__propiedades:
self.__busqueda.append(self.relacion[propiedad])
self.operarios = self.__querier.traerElementos(self.__busqueda)
self.operario = {}
def crearOperario(self, operarioNuevo):
v = self.__v.validate(operarioNuevo, self.__scOperario)
if v:
self.__querier.insertarElemento(operarioNuevo)
else:
print("ERRORES: ", self.__v.errors)
return v
def verListaOperarios(self, campos = None, condiciones = None, limite = None):
if not campos:
campos = self.__busqueda
self.operarios = self.__querier.traerElementos(campos, condiciones, limite)
self.layoutChanged.emit()
def verDetallesOperario(self, operario, campos = None, condiciones = None):
operario = self.operarios[operario.row()]
condiciones = [('ope_legajo', '=', operario[0])]
resultado = self.__querier.traerElementos(campos, condiciones, 1)
self.operario = resultado[0]
return self.operario
def modificarOperario(self, operario):
v = self.__v.validate(operario, self.__scOperario)
if v:
self.__querier.actualizarElemento(operario, condiciones = [("ope_legajo", "=", operario['ope_legajo'])])
else:
print("ERRORES: ", self.__v.errors)
return v
def toggleOperarioActivo(self, operario):
if operario['ope_activo']:
operario['ope_activo'] = 0
else:
operario['ope_activo'] = 1
self.__querier.actualizarElemento(operario)
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.operarios)
def columnCount(self, parent):
if self.operarios:
return len(self.operarios[0])
else:
return 0
def flags(self, index):
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.operarios[row][column]
return value
def setData(self, index, value, role = QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
value = self.operarios[row][column]
return value
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__propiedades[section]
def insertRows(self, position, rows, parent = QtCore.QModelIndex()):
self.beginInsertRows()
self.endInsertRows()
def insertColumns(self, position, columns, parent = QtCore.QModelIndex()):
self.beginInsertColumns()
self.endInsertColumns()
def removeRows():
self.beginRemoveRows()
self.endRemoveRows()
def removeColumns():
self.beginRemoveColumns()
self.endRemoveColumns()
class ModeloArticulo(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier(tabla="articulos", prefijo="art_")
__querierMovi = querier.Querier(tabla="movimientos_ingreso",
prefijo="movi_")
__v = cerberus.Validator()
def __init__(self, propiedades=None, parent=None):
super(ModeloArticulo, self).__init__()
self.__scArticulo = {
'art_id': {
'type': 'integer',
'nullable': True
},
# 'prov_id' : {'type' : 'integer' },
'art_cod_barras': {
'type': 'string'
},
'art_descripcion': {
'type': 'string'
},
'art_marca': {
'type': 'string'
},
'art_agrupacion': {
'type': 'string'
},
'art_stock_minimo': {
'type': 'integer'
},
'art_destino': {
'type': 'integer'
},
'art_stock_actual': {
'type': 'integer'
}
# 'art_activo' : {'type' : 'integer' }
}
self.__propiedades = [
'Codigo',
# 'Proveedor',
'Codigo de Barras',
'Descripcion',
'Marca',
'Agrupacion',
'Destino'
'Stock mínimo'
'Stock'
]
if propiedades:
self.__propiedades = propiedades
self.relacion = {
'Codigo': 'art_id',
# 'Proveedor' : 'prov_nombre',
'Codigo de Barras': 'art_cod_barras',
'Descripcion': 'art_descripcion',
'Marca': 'art_marca',
'Agrupacion': 'art_agrupacion',
# 'art_stock_min', 'art_stock_actual',
'Destino': 'art_destino',
'Stock': 'art_stock_actual',
'Stock mínimo': 'art_stock_minimo',
# 'Estado' : 'art_activo',
}
self.__costos = {
'primer_costo': '0',
'ultimo_costo': '1',
'costo_promedio': '2'
}
self.__busqueda = []
for propiedad in self.__propiedades:
self.__busqueda.append(self.relacion[propiedad])
# self.articulos = self.__querier.traerElementos(self.__busqueda)
self.articulos = []
self.articulo = {}
def crearArticulo(self, articuloNuevo):
print(articuloNuevo)
v = self.__v.validate(articuloNuevo, self.__scArticulo)
if v:
self.__querier.insertarElemento(articuloNuevo)
else:
print("ERRORES: ", self.__v.errors)
return v
# Implementar ERRORCODE de MySQL y devolver errores
def verListaArticulos(self,
campos=None,
condiciones=None,
limite=None,
uniones=None):
if not campos:
campos = self.__busqueda
self.articulos = self.__querier.traerElementos(campos, condiciones,
limite, uniones)
if self.articulos:
self.layoutChanged.emit()
return True
return False
def verDetallesArticulo(self,
articulo=QtCore.QModelIndex(),
campos=None,
condiciones=None):
print(articulo)
print(articulo.row())
if articulo.row() >= 0:
articulo = self.articulos[articulo.row()]
artId = articulo[0]
if not condiciones:
print("DEBUG MSG: El contenido de articulo[0] es: ", artId)
condiciones = [('art_id', '=', artId)]
resultado = self.__querier.traerElementos(campos, condiciones, 1)
if resultado:
self.articulo = resultado[0]
else:
return None
# print(self.articulo)
return self.articulo
def modificarArticulo(self, articulo, stockIx=None):
v = self.__v.validate(articulo, self.__scArticulo)
print("ARTICULOOO ", self.articulo)
# if stockIx:
# print("ESTO ANDA?", self.stockActual(stockIx))
# if articulo['art_stock_actual'] < self.stockActual(stockIx):
# return False
if v:
self.__querier.actualizarElemento(articulo)
else:
print("ERRORES: ", self.__v.errors)
return v
def asociarProveedor(self, proveedor={'prov_nombre': 'Indeterminado'}):
# El ID de proveedor por defecto no debe ser 0000, sino el que sea creado para el proveedor con nombre "Indeterminado"
prov_id = proveedor.fetchID()
art_id = self.fetchID()
if prov_id:
QUERY = "UPDATE articulos SET prov_ID = " + prov_id
+ " WHERE articulos.art_ID = " + art_id
else:
print("El proveedor no existe")
def deshabilitarArticulo(self, articulo):
articulo['art_activo'] = 0
self.__querier.actualizarElemento(articulo)
def habilitarArticulo(self, articulo):
articulo['art_activo'] = 1
self.__querier.actualizarElemento(articulo)
def verCostosArticulo(self, condiciones=None):
costos = self.__querierMovi.traerElementos(campos=["movi_costo "],
condiciones=condiciones,
orden=("movi_id", "ASC"))
if costos:
self.__costos['primer_costo'] = str(costos[0][0])
self.__costos['ultimo_costo'] = str(costos[len(costos) - 1][1])
costoTotal = 0
for costo in costos:
costoTotal += costo[0]
self.__costos['costo_promedio'] = str(costoTotal / len(costos))
# self.articulo.append(costos)
return costos
def getId(self):
return self.articulo[0]
def reiniciarTabla(self):
self.articulos = []
self.layoutChanged.emit()
def stockActual(self, stockIx):
return self.articulo[stockIx]
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.articulos)
def columnCount(self, parent):
if self.articulos:
return len(self.articulos[0])
else:
return 0
def flags(self, index):
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.articulos[row][column]
return value
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
value = self.articulos[row][column]
return value
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__propiedades[section]
def insertRows(self, position, rows, parent=QtCore.QModelIndex()):
self.beginInsertRows()
self.endInsertRows()
def insertColumns(self, position, columns, parent=QtCore.QModelIndex()):
self.beginInsertColumns()
self.endInsertColumns()
def primerCosto(self):
return self.__costos['primer_costo']
def ultimoCosto(self):
return self.__costos['ultimo_costo']
def CostoPromedio(self):
return self.__costos['costo_promedio']
class ModeloElemento(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier(tabla="elementos", prefijo="elem_")
__v = cerberus.Validator()
def __init__(self, propiedades=None, parent=None):
super(ModeloElemento, self).__init__()
self.__scElemento = {
'elem_id': {
'type': 'integer'
},
'elem_columna1': {
'type': 'string'
},
'elem_columna2': {
'type': 'string'
},
'elem_columna3': {
'type': 'string'
},
'elem_columna4': {
'type': 'string'
},
}
self.__propiedades = [
'Codigo',
'Columna 1',
'Columna 2',
'Columna 3',
'Columna 4',
]
if propiedades:
self.__propiedades = propiedades
self.relacion = {
'Codigo': 'elem_id',
'Columna1': 'elem_columna1',
'Columna2': 'elem_columna2',
'Columna3': 'elem_columna3',
'Columna4': 'elem_columna4',
}
self.__busqueda = []
for propiedad in self.__propiedades:
self.__busqueda.append(self.relacion[propiedad])
self.elementos = self.__querier.traerElementos(self.__busqueda)
self.elemento = {}
def crearElemento(self, elementoNuevo):
print(self.__v.validate(elementoNuevo, self.__scElemento))
print("ERRORES: ", self.__v.errors)
self.__querier.insertarElemento(elementoNuevo)
def verListaElementos(self, campos=None, condiciones=None, limite=None):
if not campos:
campos = self.__busqueda
self.elementos = self.__querier.traerElementos(campos, condiciones,
limite)
self.layoutChanged.emit()
def verDetallesElemento(self, elemento, campos=None, condiciones=None):
elemento = self.elementos[elemento.row()]
condiciones = [('elem_id', '=', elemento[0])]
resultado = self.__querier.traerElementos(campos, condiciones, 1)
self.elemento = resultado[0]
return self.elemento
def modificarElemento(self, elemento):
self.__querier.actualizarElemento(elemento)
def toggleElementoActivo(self, elemento):
if elemento['elem_activo']:
elemento['elem_activo'] = 0
else:
elemento['elem_activo'] = 1
self.__querier.actualizarElemento(elemento)
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.elementos)
def columnCount(self, parent):
if self.elementos:
return len(self.elementos[0])
else:
return 0
def flags(self, index):
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.elementos[row][column]
return value
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
value = self.elementos[row][column]
return value
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__propiedades[section]
def insertRows(self, position, rows, parent=QtCore.QModelIndex()):
self.beginInsertRows()
self.endInsertRows()
def insertColumns(self, position, columns, parent=QtCore.QModelIndex()):
self.beginInsertColumns()
self.endInsertColumns()
def removeRows():
self.beginRemoveRows()
self.endRemoveRows()
def removeColumns():
self.beginRemoveColumns()
self.endRemoveColumns()
class ModeloIngreso(QtCore.QAbstractTableModel):
# db = mysql.connector.connect(user = '******', password = '******', host = '127.0.0.1', database = 'corupel')
__querier = querier.Querier(tabla="ingresos", prefijo="ing_")
__querierMovi = querier.Querier(tabla="movimientos_ingreso",
prefijo="movi_")
__querierArt = querier.Querier(tabla="articulos", prefijo="art_")
__querierProv = querier.Querier(tabla="proveedores", prefijo="prov_")
__querierComp = querier.Querier(tabla="comprobantes", prefijo="comp_")
__v = cerberus.Validator()
def __init__(self, propiedades=None, parent=None):
super(ModeloIngreso, self).__init__()
self.__scIngreso = {
'ing_id': {
'type': 'integer',
'max': 9999999999999999
},
'ing_fecha': {
'type': 'date'
},
'prov_id': {
'type': 'integer',
'max': 9999999999999999
}
}
self.__scMovIngreso = {
'movi_id': {
'type': 'integer',
'max': 9999999999999999
},
'ing_id': {
'type': 'integer',
'max': 9999999999999999
},
'art_id': {
'type': 'integer',
'max': 9999999999999999
},
'movi_canitdad': {
'type': 'integer'
},
'movi_restante': {
'type': 'integer'
},
'movi_costo': {
'type': 'decimal'
}
}
self.__scComprobante = {
'comp_id': {
'type': 'integer',
'max': 9999999999999999
},
'ing_id': {
'type': 'integer',
'max': 9999999999999999
},
'comp_tipo': {
'type': 'string',
'allowed': ['A', 'B', 'C', 'R']
},
'comp_prefijo': {
'type': 'integer',
'max': 9999999999999999
},
'comp_fecha': {
'type': 'integer'
},
'comp_numero': {
'type': 'integer'
}
}
self.__headers = ["Codigo", "Descripcion", "Cantidad", "Costo"]
self.__movimientos = [["", "", "", ""]]
self.ingreso = {}
self.__proveedor = {}
def crearIngreso(self, proveedor, comprobantes):
# print(self.__v.validate(ingresoNuevo, self.__scIngreso))
# print("ERRORES: ",self.__v.errors)
if len(self.__movimientos) == 1:
return False
hoy = date.today()
ingreso = {'ing_fecha': hoy, 'prov_id': proveedor}
for comprobante in comprobantes:
print("ESTO ES EL COMPROBANTE: ", comprobante)
compValidator = self.__querierComp.traerElementos(
condiciones=[("comprobantes.comp_prefijo", " = ",
"'{}'".format(comprobante['comp_prefijo'])),
("comprobantes.comp_numero", " = ",
"'{}'".format(comprobante['comp_numero']))])
print(compValidator)
if compValidator:
return (False)
self.__querier.insertarElemento(ingreso)
ingId = self.__querier.traerElementos(campos=["ing_id"],
orden=("ing_id", "DESC"),
limite=1)
ingId = ingId[0][0]
for comprobante in comprobantes:
comprobante['ing_id'] = ingId
self.__querierComp.insertarElemento(comprobante)
for movimiento in self.__movimientos:
if movimiento[2] == 0:
continue
movimiento = {
'art_id': movimiento[0],
'ing_id': ingId,
'movi_cantidad': movimiento[2],
'movi_restante': movimiento[2],
'movi_costo': movimiento[3]
}
if not movimiento['art_id']:
continue
self.__querierMovi.insertarElemento(movimiento)
return True
def verListaIngresos(self, campos=None, condiciones=None, limite=None):
if not campos:
campos = self.__busqueda
self.__movimientos = self.__querier.traerElementos(
campos, condiciones, limite)
self.layoutChanged.emit()
def verDetallesIngreso(self, ingreso, campos=None, condiciones=None):
ingreso = self.__movimientos[ingreso.row()]
condiciones = [('ing_id', '=', ingreso[0])]
resultado = self.__querier.traerElementos(campos, condiciones, 1)
self.ingreso = resultado[0]
return self.ingreso
def modificarIngreso(self, ingreso):
self.__querier.actualizarIngreso(ingreso)
def toggleIngresoActivo(self, ingreso):
if ingreso['ing_activo']:
ingreso['ing_activo'] = 0
else:
ingreso['ing_activo'] = 1
self.__querier.actualizarIngreso(ingreso)
def buscarProveedor(self, campos=None, condiciones=None):
self.__proveedor = {}
resultado = self.__querierProv.traerElementos(campos, condiciones)
print("BUSCOOOO")
if resultado:
self.reiniciarTablaIngreso()
self.__proveedor = resultado[0]
print("PROVEEEEEEE ", self.__proveedor)
return self.__proveedor
def getMovimientos(self):
return self.__movimientos
def hayMovimientos(self):
if len(self.__movimientos) == 1:
return False
for movimiento in self.__movimientos:
print("LA CANTIDAD DE UNIDADES DEL ARTICULO ES: ", movimiento[2])
if not (movimiento[2] == '0' or movimiento[2] == ''):
return True
return False
def reiniciarTablaIngreso(self):
self.removeRows()
def getArticulos(self):
articulos = []
for movimiento in self.__movimientos:
if movimiento[0] == '': continue
articulos.append((movimiento[0], movimiento[2]))
return articulos
# ===============================================================
# Funciones para Modelo de tabla para PyQt
# ===============================================================
def rowCount(self, parent):
return len(self.__movimientos)
def columnCount(self, parent):
if self.__movimientos:
return len(self.__movimientos[0])
else:
return 0
def flags(self, index):
columna = index.column()
fila = index.row()
if (columna == 2 or columna == 3) and self.__movimientos[fila][0]:
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled
if columna == 0:
return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled
return QtCore.Qt.ItemIsEnabled
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
row = index.row()
column = index.column()
value = self.__movimientos[row][column]
return value
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.EditRole:
row = index.row()
column = index.column()
self.__articulo = {}
if self.__proveedor:
provId = self.__proveedor[0]
if column == 0:
for articulo in self.__movimientos:
if value == str(articulo[0]):
return (False)
try:
value = int(value)
resultado = self.__querierArt.traerElementos(
campos=("art_id", "art_descripcion"),
condiciones=[("art_id", " = ", value),
("articulos_de_proveedores.proveedor",
" = ", provId)],
uniones=[[
'articulos_de_proveedores',
'`articulos`.`art_id` = `articulos_de_proveedores`.`articulo`'
]])
self.__articulo = list(resultado[0])
self.__articulo.append(0)
self.__articulo.append(0)
except:
return False
if not self.__movimientos[row][0]:
self.insertRows(self.rowCount(self), 1)
else:
self.__movimientos[row] = self.__articulo
self.dataChanged.emit(index, index)
return True
elif column == 3:
try:
decvalue = decimal.Decimal(value)
if decvalue <= 0:
return False
except:
return False
else:
try:
value = int(value)
if value < 0:
return False
except:
return False
self.__movimientos[row][column] = value
self.dataChanged.emit(index, index)
return True
return False
def headerData(self, section, orientation, role):
if role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self.__headers[section]
def insertRows(self, row, count, parent=QtCore.QModelIndex()):
self.beginInsertRows(parent, row, row)
self.__movimientos.insert(row, self.__articulo)
self.endInsertRows()
def removeRows(self, row=1, parent=QtCore.QModelIndex()):
last = self.rowCount(parent) - 1
self.beginRemoveRows(parent, row, last)
self.__movimientos = [["", "", "", ""]]
# self.dataChanged.emit()
self.endRemoveRows()