class Boletas():
def __init__(self):
self.conexion = Conexion()
def listar(self, fecha):
query = 'SELECT * FROM boletas b inner join clientes c on b.idcliente = c.idcliente and fecha between'
resultado = self.conexion.ejecutarQuery(query)
filas = resultado.fetchall()
print(filas)
class detalleProducto():
def __init__(self):
self.conexion = Conexion()
def listar(self,id):
query = 'SELECT * FROM boletas b inner join productos p on b.idcliente = c.idcliente and fecha between'
##FALTA
resultado = self.conexion.ejecutarQuery(query)
filas = resultado.fetchall()
print(filas)
def agregarPeriodo(self, periodo):
try:
sql = f"""INSERT INTO periodos(periodo)
VALUES('{periodo.periodo}')"""
conexion = Conexion()
cliente = conexion.cliente
cursor = cliente.cursor()
cursor.execute(sql)
cliente.commit()
except Exception as e:
print(f"Error: {str(e)}")
cliente.rollback()
else:
cliente.close()
def __init__(self):
self.conexion = Conexion()
class Colegio():
__conexion = Conexion()
__con = __conexion.conn
def agregarPersona(self, objeto, tipo):
try:
nomColeccion = "personas"
if tipo == "alumno":
alumno = objeto
diccionario = {
"codigo": alumno.codigo,
"tipo": tipo,
"nombre": alumno.nombre,
"dni": alumno.dni,
"edad": alumno.edad,
"notas": alumno.notas,
"promedio": alumno.getPromedio(),
"notamax": alumno.getNotaMaxima(),
"notamin": alumno.getNotaMinima()
}
elif tipo == "docente":
docente = objeto
diccionario = {
"codigo": docente.codigo,
"tipo": tipo,
"nombre": docente.nombre,
"dni": docente.dni,
"edad": docente.edad
}
coleccion = self.__conexion.connect()[nomColeccion]
coleccion.insert_one(diccionario)
except Exception as e:
print(f"Error: {str(e)}")
else:
self.__conexion.close()
def listarPersonas(self, tipo):
try:
nomColeccion = "personas"
coleccion = self.__conexion.connect()[nomColeccion]
query = {"tipo": tipo}
personas = coleccion.find(query)
for persona in personas:
print(persona)
except Exception as e:
print(f"Error: {str(e)}")
else:
self.__conexion.close()
def obtenerCodigoPersona(self, codigoBuscar):
try:
nomColeccion = "personas"
coleccion = self.__conexion.connect()[nomColeccion]
query = {"codigo": codigoBuscar}
personas = coleccion.find(query)
for persona in personas:
return persona.codigo
except Exception as e:
print(f"Error: {str(e)}")
else:
self.__conexion.close()
def actualizarPersona(self, codigoActualizar, objeto, tipo):
try:
nomColeccion = "personas"
coleccion = self.__conexion.connect()[nomColeccion]
query = {"codigo": codigoActualizar}
if tipo == "alumno":
queryUpdate = {
"$set": {
"nombre": objeto.nombre,
"dni": objeto.dni,
"edad": objeto.edad,
"notas": objeto.notas,
"promedio": objeto.getPromedio(),
"notamax": objeto.getNotaMaxima(),
"notamin": objeto.getNotaMinima()
}
}
elif tipo == "docente":
queryUpdate = {
"$set": {
"nombre": objeto.nombre,
"dni": objeto.dni,
"edad": objeto.edad
}
}
coleccion.update(query, queryUpdate, upsert=False)
print("Registro Actualizado")
except Exception as e:
print(f"Error: {str(e)}")
else:
self.__conexion.close()
def eliminarPersona(self, codigoEliminar):
try:
nomColeccion = "personas"
coleccion = self.__conexion.connect()[nomColeccion]
query = {"codigo": codigoEliminar}
coleccion.remove(query)
print("Registro eliminado")
except Exception as e:
print(f"Error: {str(e)}")
else:
self.__conexion.close()
class Factura():
conexion = Conexion()
con = conexion.conectar()
def __init__(self):
pass
def guardarFactura(self):
#OBTENER EL ULTIMO ID DE FACTURA
ultimoID = 0
sql = 'SELECT COUNT(*) FROM facturas'
cursor = self.con.cursor()
cursor.execute(sql)
dato = cursor.fetchone()
ultimoID = dato[0]
cursor.close()
idFactura = ultimoID + 1
#INICIO DE FACTURA
print(f'FACTURA N° {idFactura}')
fechaFactura = date.today()
#OBTENER EL SUBTOTAL DE LA FACTURA
subtotalFactura = self.guardarDetalle(idFactura)
igvFactura = subtotalFactura * 0.18
totalFactura = subtotalFactura + igvFactura
sql = 'INSERT INTO facturas(idFactura, fechaFactura, subtotalFactura, igvFactura, totalFactura) VALUES(%s, %s, %s, %s, %s)'
facturas = (0, fechaFactura, subtotalFactura, igvFactura, totalFactura)
cursor = self.con.cursor()
cursor.execute(sql, facturas)
self.con.commit()
cursor.close()
return
def guardarDetalle(self, idFactura):
numeroProductos = int(input('¿Cuántos productos agregará en la factura?: '))
print('***LISTA PRODUCTOS***')
producto = Producto()
producto.mostrarProducto()
subtotal = 0
for i in range(1, numeroProductos + 1):
idProducto = input(f'ID Producto {str(i)}: ')
cantidadProducto = float(input(f'Cantidad producto {str(i)}: '))
productoEncontrado = producto.buscarProductoPorCodigo(idProducto)
precioProducto = float(productoEncontrado[2])
subtotal += cantidadProducto * precioProducto
sql = 'INSERT INTO detalles(idDetalle, idFactura, idProducto, cantidadProducto) VALUES(%s, %s, %s, %s)'
detalles = (0, idFactura, idProducto, cantidadProducto)
cursor = self.con.cursor()
cursor.execute(sql, detalles)
self.con.commit()
cursor.close()
return subtotal
def mostrarFactura(self):
sql = 'SELECT * FROM facturas'
cursor = self.con.cursor()
cursor.execute(sql)
facturas = cursor.fetchall()
print('***REPORTE DE FACTURAS***')
print('N°, FECHA, SUBTOTAL, IGV, TOTAL')
for factura in facturas:
print(f'{factura[0]}, {factura[1]}, {factura[2]}, {factura[3]}, {factura[4]}')
cursor.close()
class Alumno(Persona):
__conn = Conexion()
def __init__(self, dni, nombres, apellidos, edad, notas=[]):
super().__init__(dni, nombres, apellidos, edad)
self.notas = notas
def agregaralumno(self, alumno):
try:
sql = """INSERT INTO alumnos(dni, nombres, apellidos, edad)
VALUES('{}', '{}', '{}', {})""".format(alumno.dni, alumno.nombres,
alumno.apellidos,
alumno.edad)
self.__conn.ejecutarSentencia(sql)
self.__conn.commit()
except Exception as e:
print(f"Error: {str(e)}")
self.__conn.rollback()
else:
self.__conn.cerrarConexion()
def listaralumnos(self):
try:
sql = "SELECT * FROM alumnos"
cursor = self.__conn.ejecutarSentencia(sql)
filas = cursor.fetchall()
for fila in filas:
print("""DNI: {}, Nombres: {}, Apellidos: {}, Edad: {} \n
""".format(fila[1], fila[2], fila[3], fila[4]))
except Exception as e:
print(f"Error: {str(e)}")
self.__conn.rollback()
else:
self.__conn.cerrarConexion()
def obteneralumno(self, idalumno):
try:
sql = """SELECT * FROM alumnos
WHERE idalumno = {}""".format(idalumno)
cursor = self.__conn.ejecutarSentencia(sql)
fila = cursor.fetchone()
alumno = Alumno(fila[1], fila[2], fila[3], fila[4])
return alumno
except Exception as e:
print(f"Error: {str(e)}")
self.__conn.rollback()
else:
self.__conn.cerrarConexion()
def actualizaralumno(self, alumno, idalumno):
try:
sql = """UPDATE alumnos SET dni = {}, nombres = {}, apellidos = {}, edad = {}
WHERE idalumno = {}""".format(alumno.dni, alumno.nombres,
alumno.apellidos, alumno.edad,
idalumno)
self.__conn.ejecutarSentencia(sql)
self.__conn.commit
except Exception as e:
print(f"Error: {str(e)}")
self.__conn.rollback()
else:
self.__conn.cerrarConexion()
def eliminaralumno(self, idalumno):
try:
sql = """DELETE FROM alumnos
WHERE idalumno = {}""".format(idalumno)
self.__conn.ejecutarSentencia(sql)
self.__conn.commit()
except Exception as e:
print(f"Error: {str(e)}")
self.__conn.rollback()
else:
self.__conn.cerrarConexion()
def obtenerNotaMax(self):
return max(self.notas)
def obtenerNotaMin(self):
return min(self.notas)
def obtenerPromedio(self):
for nota in self.notas:
suma += nota
promedio = suma / len(self.notas)
return promedio