Trabajo Final - Grupo 1

UNIVERSIDAD PERUANA DE CIENCIAS APLICADAS
FACULTAD DE INGENIERÍA
CARRERA DE INGENIERÍA INDUSTRIAL
“AVANCE PARCIAL DEL TRABAJO FINAL”
Proyecto: BookLab
Integrantes:
Abancini Diaz Benjamin (U201724421)
Aiquipa Arce Christian Edgar (U20201B912)
Astucuri Betalleluz Kevin Omar Stéfano (U202011811)
Profesor: Oscar Alberto Granda Gayoso
Curso: Software para Ingenieros
Sección: IX56
RESUMEN
En este trabajo de investigación, aplicará los conocimientos técnicos adquiridos en el
Curso de software para ingenieros para resolver un problema en una situación del mundo real.
En este caso, la intención es permitir que la biblioteca comunitaria ingrese el código y el usuario
del libro al momento de solicitar un préstamo. BookLab es el software de la ciudad de la
Biblioteca de Surquillo que intenta optimizar estos procesos. Esto le permite identificar a los
usuarios que regresan y los libros más solicitados, incluidas las fechas más solicitadas. Por lo
que se puede segmentar según estos tres criterios, facilitando las solicitudes según las
necesidades de cada usuario.
Primero, a través del diagrama de flujo, proponemos un orden lógico para la estructura
de desarrollo del proyecto. El objetivo es establecer el procedimiento desde la solicitud de
préstamo hasta la devolución del libro. Por otra parte, se obtendrá una base de datos actualizada
que contiene el nombre del libro (que establece el código en función del nombre) y el código
de cada usuario. Por ello, entendemos que se debe establecer una matriz óptima para lograr
estos objetivos.
Luego configure la GUI para obtener una imagen clara y verifique la validez de la
secuencia establecida. Finalmente, programaremos la aplicación en Python. El software
permite ingresar códigos de libros establecidos, guardar solicitudes y ordenarlas de acuerdo
con el historial de cada usuario, lo que hace que las solicitudes de libros sean más eficientes.
2
ÍNDICE
RESUMEN ............................................................................................................................ 2
CAPÍTULO 1 ........................................................................................................................ 6
PRESENTACIÓN ............................................................................................................................. 6
CAPÍTULO 2 ........................................................................................................................ 7
MARCO TEÓRICO ......................................................................................................................... 7
CAPÍTULO 3 ........................................................................................................................ 8
DESCRIPCIÓN DE LA EMPRESA ............................................................................................... 8
MISIÓN ............................................................................................................................................. 8
VISIÓN .............................................................................................................................................. 8
VALORES ......................................................................................................................................... 9
PROCESO DE ESTUDIO Y DEFINICIÓN DEL PROBLEMA ................................................. 9
OBJETIVO GENERAL ................................................................................................................. 10
OBJETIVOS ESPECÍFICOS ........................................................................................................ 10
HIPÓTESIS DE SOLUCIÓN ........................................................................................................ 11
CAPÍTULO 4 ...................................................................................................................... 11
PROPUESTA DE MEJORA CUALITATIVA ............................................................................ 11
PROTOTIPO DE INTERFÁZ ...................................................................................................... 15
TABLA DE VARIABLES .............................................................................................................. 23
CAPÍTULO 5 ...................................................................................................................... 27
PROPUESTA DE ALGORITMO Y DE LOS COMPONENTES PYTHON ........................... 27
HERRAMIENTAS, MODULOS, UTILIZADOS PARA EL DESARROLLO......................... 28
CONCLUSIONES Y RECOMENDACIONES ............................................................................ 29
GLOSARIO ........................................................................................................................ 29
BIBLIOGRAFÍA ................................................................................................................. 30
ANEXOS ............................................................................................................................. 31
3
INDICE DE FIGURAS
Figura 1 : Encuesta realizada a 1000 vecinos 8
Figura 2: Encuesta de incidencias realizada a 1000 vecinos 10
Figura 3: Diagrama de casos de uso 12
Figura 4: Diagrama de clases 13
Figura 5: Diagrama de secuencia para el administrador 13
Figura 6: Diagrama de secuencia para el usuario 14
Figura 7: Diagrama de actividades 15
Figura 8: Interfaz inicial de la app BookLab 16
Figura 9: Interfaz para registrarse siendo usuario 17
Figura 10: Interfaz donde se muestra las opciones del usuario 18
Figura 11: Interfaz de categorías disponibles en la plataforma 18
Figura 12: Interfaz donde se ve la categoría de cuentos y los disponibles 19
Figura 13: Interfaz para reservar el libro seleccionado 20
Figura 14: Interfaz donde se ve la actualización del stock de los libros 20
Figura 15: Interfaz del administrador donde da dos opciones 21
Figura 16: Formato de la lista de libros reservados 21
Figura 17: Interfaz desde la vista del administrador para agregar un libro 22
Figura 18: Parte del código en Python 28
4
INDICE DE TABLAS
Tabla 1: Encuesta de incidencias realizada a 1000 vecinos 10
Tabla 2: Variables del programa realizado 23
5
CAPÍTULO 1
PRESENTACIÓN
Este proyecto de investigación y aplicación se enfoca en los antiguos y nuevos usuarios
de la biblioteca BookLab y en optimizar el proceso de registro de solicitud de libros, teniendo
como función principal brindar el soporte técnico necesario para los dispositivos y equipos.
Proporcionar mayor visualización, control y accesibilidad a los responsables de iniciar
procesos a través de la implementación de cuadros de mando automatizados que permitan el
registro y seguimiento. Actualmente, los nuevos clientes que deseen registrar un nuevo libro
son ingresados manualmente en el libro de control por parte del gerente del área, ordenados y
entregados al personal técnico.
Por ello, se puso en plan realizar un análisis creando un diagrama de Pareto asociado a
las métricas del último periodo en el que se identificó el principal problema en el área de
mantenimiento. También se consideran el análisis de la causa raíz, las principales áreas
problemáticas, el tiempo de inactividad del equipo, el costo, la disponibilidad de las piezas de
repuesto y los informes del personal técnico. En pocas palabras, este proyecto brindará
herramientas que permitirán a las áreas de mantenimiento agilizar su trabajo y brindar
información ordenada, específica y oportuna de acuerdo a sus necesidades de producción con
el fin de evitar retrasos en la producción que se pretenda generar, cuyo objetivo es lanzar al
mercado.
6
CAPÍTULO 2
MARCO TEÓRICO
La tecnología de la información y optimización se desarrolla a un ritmo exponencial,
pero las organizaciones crecen a un ritmo de cambio lineal. El impacto de estas tecnologías es
inmenso y hoy en día se utilizan ampliamente y se consideran una ayuda para personas de todo
el mundo. Por otro lado, nuestro proyecto se basa en el proceso de administración y gestión de
bibliotecas de BookLab, por lo que uno de los principales objetivos es poder ayudar con los
servicios de registro de códigos y nuevas solicitudes de clientes en el sitio.
La intención es crear un software para el personal de servicio que es el principal
responsable del acceso a las instalaciones y la gestión de movimientos. BookLab optimiza el
tiempo que dedica a estas tareas. Además, la digitalización de diversos procesos nos permite
asegurar y mejorar su gestión. Esta es una mejora al pasar varias auditorías de sistemas de
gestión. Domina la forma en que vivimos y trabajamos en una era como la Cuarta Revolución
Industrial, impulsada por la automatización y la interconexión de sistemas inteligentes.
Participamos activamente en el apoyo a BookLab en bibliotecas locales populares de todo el
país al mismo tiempo que garantizamos la seguridad que necesitan nuestros clientes.
7
CAPÍTULO 3
DESCRIPCIÓN DE LA EMPRESA
BookLab es la biblioteca municipal de Surquillo con más de 9 años al servicio del
ciudadano. Cuenta con alrededor de 100 libros de diferentes categorías para el disfrute de
nuestros usuarios.
Figura 1 : Encuesta realizada a 1000 vecinos
Nota: BookLab
MISIÓN
Ofrecer una amplia gama de libros de texto, lecturas e innovaciones digitales para
satisfacer plenamente las necesidades de nuestros clientes. Con múltiples editoriales, satisfacer
las necesidades de la comunidad educativa, asegurar el aprendizaje y nutrir el amor por la
lectura del público.
VISIÓN
Ser la biblioteca líder en el distrito de Surquillo, somos reconocidos por la venta y
distribución de libros de texto, lectura general, plataformas digitales y la calidad de las
traducciones de editoriales nacionales e internacionales. Nuestros servicios y aportes a la
comunidad educativa.
8
VALORES
✓ Responsabilidad
✓ Respeto
✓ Honestidad
✓ Innovación
✓ Organización
PROCESO DE ESTUDIO Y DEFINICIÓN DEL PROBLEMA
El presente trabajo intenta darle solución a la problemática que aqueja con mayor
frecuencia a la biblioteca municipal de Surquillo, que se conoció luego de la elaboración de
una encuesta virtual voluntaria a una muestra de 1000 vecinos. Obteniendo como resultado que
el principal inconveniente que ellos reportan es la carencia de una plataforma virtual para
realizar la reserva de algún libro, con el fin de evitar largas colas y papeleo innecesario que
dañan al medio ambiente.
En vista que la biblioteca no cuenta con una plataforma desarrollada, proponemos la
realización de una base de datos con los libros que cuenta la institución para facilitar la reserva
de los títulos y además llevar un reporte inmediato de cada solicitud efectuada. Además,
implementar una interfaz en la plataforma Python con dos botones principales que permitirán
el ingreso a la plataforma como usuario (vecino) o administrador (personal administrativo o
desarrolladores).
9
Tabla 1: Encuesta de incidencias realizada a 1000 vecinos
N INDICE N. DE
RESPUESTAS
1 Falta de una plataforma virtual para la 510
reserva de libros
2 Largas colas en la sede de la biblioteca 260
municipal
3 Pocos títulos en el catálogo de la 120
biblioteca
4 Otros 110
Total 1000
Figura 2: Encuesta de incidencias realizada a 1000 vecinos
Reporte de Incidencias de los vecinos del distrito de

Surquillo
Falta de una plataforma

virtual para la reserva de
110 libros
120 Largas colas en la sede de
510 la biblioteca municipal
260
Pocos títulos en el catálogo
de la biblioteca
Otros
OBJETIVO GENERAL
Desarrollar un software que permita a los usuarios realizar pedidos anticipados de
libros, teniendo en cuenta su disponibilidad en las bibliotecas.
OBJETIVOS ESPECÍFICOS
➢ Crear informes generales de las reservas realizadas
10
➢ Mostrar usuarios frecuentes
➢ Obtenga información sobre títulos y géneros populares
➢ Identificar el promedio de días para reservar un libro, hasta de 1 a 8 días, según
política municipal.
➢ Promoción de la Lectura Familiar en el Distrito de Surquillo
➢ Eliminar las largas colas en el recinto principal
➢ Crear una lista de espera e informe a las personas cuántos días estará disponible el
libro
➢ Generar nuevos ingresos a través de su programa
HIPÓTESIS DE SOLUCIÓN
Ante el gran avance de la tecnología es indispensable contar con una plataforma virtual
que permita a los usuarios contar con los medios técnicos para que su día a día no cambie
abruptamente. Con esto en mente, recomendamos crear una app que permita a los usuarios
reservar de manera ordenada y muy fácil, evitando traslados a la sede y colas obvias en el sitio.
Como resultado, todos tienen acceso instantáneo a información precisa sobre qué libros están
disponibles y cuáles no. Todo esto garantiza una gestión precisa de los libros y genera
automáticamente informes sobre los títulos solicitados.
CAPÍTULO 4
PROPUESTA DE MEJORA CUALITATIVA
Una encuesta a 1000 usuarios habituales de la Biblioteca Municipal de Surquillo
concluyó que su principal queja estaba relacionada con la falta de una plataforma virtual para
solicitar reservas. Actualmente, es necesario acudir a la sede, y puede haber casos en los que el
título deseado no esté disponible. Por lo tanto, para optimizar y darle solución a este problema
se propone crear una interfaz utilizando el lenguaje de programación Python conectada a una
base de datos que brinde información relevante y oportuna a los usuarios que deseen reservar
títulos del catálogo. Este programa permite averiguar fácilmente si hay copias disponibles y si
11
las copias están reservadas simplemente ingresando datos como la cantidad de días reservados,
la fecha de salida y la fecha de regreso. Se crearon varios diagramas para ser presentados con
la tarea de mostrar cómo funciona la interfaz.
Figura 3: Diagrama de casos de uso
12
Figura 4: Diagrama de clases
Figura 5: Diagrama de secuencia para el administrador
13
Figura 6: Diagrama de secuencia para el usuario
14
Figura 7: Diagrama de actividades
PROTOTIPO DE INTERFÁZ
Para poder visualizar nuestra propuesta de mejora se creó una ventana a manera de
simular la interfaz. Esta será presentada desde la perspectiva del usuario.
En esta ventana se presentará la pantalla en la que se encontrarán los casilleros para que
pueda ingresar los datos correspondientes como el DNI y la contraseña. Tal como se muestra
en la figura 8.
15
Figura 8: Interfaz inicial de la app BookLab
En la figura 9 se muestra la interfaz del usuario para que este se pueda registrar, de
manera que pueda ingresar todos sus datos como su nombre, DNI y contraseña que servirá para
poder acceder la próxima vez que lo intente.
16
Figura 9: Interfaz para registrarse siendo usuario
Luego de validar que todos los datos ingresados hayan sido correctos, se le redirecciona
a otra ventana donde se le mostrará las opciones que tiene como usuario.
17
Figura 10: Interfaz donde se muestra las opciones del usuario
Dándole clic a la pestaña de reservar el libro, se mostrará la siguiente ventana mostrada
en la figura 11
Figura 11: Interfaz de categorías disponibles en la plataforma
18
Si le damos a la pestaña que dice ver, nos mostrará automáticamente todos los libros de
todas las categorías disponibles, si le picamos en alguna categoría en específica nos mostrará
solo lo de la categoría seleccionada. Como se muestra en la figura 12.
Figura 12: Interfaz donde se ve la categoría de cuentos y los disponibles
Una vez seleccionado el título del libro solicitado el usuario deberá indicar la fecha en
el que se va a retirar el libro y los días de reserva. Cabe resaltar que los días de reserva, es decir
los días que el usuario pueda quedarse con los libros, es máximo 7 días por norma
administrativa.
19
Figura 13: Interfaz para reservar el libro seleccionado
Seguidamente de esto, en la base de datos se actualizará automáticamente el stock del
libro.
Figura 14: Interfaz donde se ve la actualización del stock de los libros
Por otro lado, teniendo en cuenta la perspectiva del encargado o administrador, este
ingresará independientemente al sistema con las credenciales ya proporcionadas por el área
encargada, esta ventana será la misma que la del usuario.
Una vez comprobado que los datos ingresados son correctos, el sistema procede a
mostrar las acciones que puede realizar.
20
Figura 15: Interfaz del administrador donde da dos opciones
La lista de reportes de registro de reservas se verá en la figura 16, de ser posible
lanzaremos un reporte de manera gráfica de las categorías reservadas de los libros más
solicitados y los usuarios más frecuentes.
Figura 16: Formato de la lista de libros reservados
21
Finalmente, si en caso de que se quiera agregar un libro por el administrador tendrá que
completar un formulario indicando la categoría, título y la cantidad de stock, seguidamente se
le asignará un código de manera automática. La imagen es importante para el reconocimiento
del mismo.
Figura 17: Interfaz desde la vista del administrador para agregar un libro
22
TABLA DE VARIABLES
Tabla 2: Variables del programa realizado
23
24
25
26
CAPÍTULO 5
PROPUESTA DE ALGORITMO Y DE LOS COMPONENTES PYTHON
Para el desarrollo del programa se utilizó el lenguaje de programación Python con las
respectivas librerías tales como matplotlib, numpy, openpyxl, pandas, datetime, collections,
etc. El principal es el tkinter, que con sus métodos nos permite crear formularios e interfaces
gráficas que hacen más amigable y entendible el programa. Es por este medio que ingresaremos
los diversos datos previamente explicados donde se almacenarán apoyado con una base de
datos que, en este caso es Excel, Con esto, administraremos la data y de igual manera para el
cálculo de las estadísticas.
27
Figura 18: Parte del código en Python
HERRAMIENTAS, MODULOS, UTILIZADOS PARA EL DESARROLLO
• Lenguaje de programación: Python

• Base de datos: Excel
• Módulos: os, numpy, matplotlib. pyplot, tkinter, pandas, datetime
• Entorno de desarrollo: Visual Studio Code
• Para el diseño UML: StarUML
• Los reportes y consultas se pueden exportar en archivos CSV la cual se puede abrir
con la aplicación Excel, estos reportes se crean en carpetas “Préstamos” y “Usuarios”
28
CONCLUSIONES Y RECOMENDACIONES
El proyecto desarrolla un código que permite a la biblioteca municipal de Surquillo a
gestionar su sistema de préstamo de libros dentro de la organización, estandarizando así el
proceso de solicitud de préstamos, devolución de préstamos, registro de datos y generación de
informes estadísticos para el análisis de decisiones.
Podemos decir que actualmente debido al avance tecnológico es necesario tener un
sistema automatizado que pueda agilizar diversos procesos, de manera que este satisfaga la
necesidad de un consumidor o cliente.
Recomendamos a la biblioteca Municipal de Surquillo implementar el programa
propuesto ya que este ayudaría a la gestión y optimización de la misma. Asimismo, seguir con
la labor que están haciendo de alguna manera impulsar a la lectura tanto para niños como para
adultos.
GLOSARIO
• Dataframe: Es una estructura de datos con dos dimensiones en la cual se puede

guardar datos de distintos tipos (como caracteres, enteros, valores de punto flotante,
factores y más) en columnas. Es similar a una hoja de cálculo o una tabla de SQL.
• Label: Son widget o componentes de Python que permite agregar texto.
• Python: Es un lenguaje de programación de alto nivel versátil y amigable para leer
con un efectivo sistema de programación orientada a objetos.
• Visual studio Code: Visual Studio Code (VS Code) es un editor de código fuente
desarrollado por Microsoft. Es un software libre y multiplataforma que básicamente
permite escribir y ejecutar código en cualquier lenguaje de programación.
29
BIBLIOGRAFÍA
Muñoz, M. A. & Córcoles, C. S. (2018). Python avanzado en un fin de semana. Autoedición.
Romano, F. (2018). Learn Python Programming: The no-nonsense, beginner’s guide to
programming, data science, and web development with Python 3.7, 2nd Edition (2a
ed.). Packt Publishing. https://books.google.at/books?id=NsNiDwAAQBAJ
Carlos, J., Castellanos, P., Dougnac, J., Merino Echeverría, D., & Bermeo Ramírez, J. (2020).
Python para todos Explorando la información con Python 3.
https://do1.dr-chuck.com/pythonlearn/ES_es/pythonlearn.pdf
Guzmán Pérez, D. F. (2020). Desarrollo de un sistema de soporte en el proceso de
experimentación con patrones de diseño de privacidad [Tesis de licenciatura, Escuela
Politécnica Nacional]. Repositorio Escuela Politécnica Nacional.
https://bibdigital.epn.edu.ec/bitstream/15000/21099/1/CD%2010612.pdf
Downey, A.B. (2008). How to Think Like a Computer Scientist. Learning
with Python, Green Tea Press.
https://www.math.ru.nl/~bosma/onderwijs/najaar09/thinkpython.pdf
30
ANEXOS
CODIGO COMPLETO
from tkinter import *
import os
from matplotlib import image
import numpy as np
import matplotlib.pyplot as plt
from openpyxl import load_workbook
from tkinter import ttk
import tkinter.font as tkFont
import pandas as pd
import datetime
from PIL import ImageTk, Image
from tkinter import filedialog
from collections import namedtuple
import shutil #PARA ADMINISTRAR FICHEROS O LOS GRUPOS

import os #PARA INTERACTUAR CON EL SISTEMA OPERATIVO
ruta = os.getcwd()
datafile = ruta + "/Data/biblioteca.xlsx"
resourcesfolder = "Recursos/"
bookfolders = "ImagenesLibros"
#Generación de un Pandas a partir de una hoja de excel

def generarPandas(hoja):
columnas = next(hoja.values)[0:]
dataframe = pd.DataFrame(hoja.values, columns = columnas)
return dataframe
#Se retorna la instancia de hoja de excel de un archivo

def generarHoja(nombreHoja):
hoja = archivo[nombreHoja]
return hoja
31
#NOTIFICACIÓN VENTANA
def mostrarNotificacion(titulo, mensaje):
def fun_cerrar():
notificacion.destroy()
notificacion = Tk()
notificacion.geometry("330x150")
notificacion.title(titulo)
notificacion.resizable(False,False)# NO REDIMENCIONABLE
notificacion.config(background = "#94D0CC")
label_mensaje = Label(notificacion, text = mensaje, bg = "#94D0CC", fg="#435560",font =

"Cambria")
label_mensaje.place( x = 20, y = 30)
button_aceptar = Button(notificacion, text = "ACEPTAR", width=30, bg = "#EDFFEC", command

= fun_cerrar)
button_aceptar.place( x = 20, y = 80)
notificacion.mainloop()
def mostrarNotificacion2(titulo, mensaje1, mensaje2):

def fun_cerrar():
notificacion.destroy()
notificacion = Tk()
notificacion.geometry("300x160")
notificacion.title(titulo)
notificacion.resizable(False,False)
notificacion.config(background = "#94D0CC")
label_mensaje = Label(notificacion, text = mensaje1, bg = "#94D0CC", fg="#435560",font =

"Cambria")
label_mensaje = Label(notificacion, text = mensaje2, bg = "#94D0CC", fg="#435560",font =
"Cambria")
32
button_aceptar = Button(notificacion, text = "ACEPTAR", width=25, bg = "#EDFFEC", command
= fun_cerrar)
button_aceptar.place( x = 40, y = 90)
notificacion.mainloop()
## CREACIÓN DE PANTALLA INICIAL

def crearPantallaInicial():
app = Tk()
app.geometry(TAM_BIBLIOTECA_APP)
app.title("BOOKLAB -- GRUPO 1")
app.resizable(False,False)
app.config(background = COLOR_FONDO_PANTALLA_1)
return app
## CREACIÓN DE FRAME DE LOGIN

def ventanaRegistroUsuario(ventanaContenedor):
def cancelarRegistro():
frame_createUser.pack_forget()
frame_login.pack()
def registrarUsuario():
global usuarios
nombre_error.set("")
dni_error.set("")
password_error.set("")
if entry_NOMBRE.get() == "":
nombre_error.set("El campo nombre no puede estar vacío")
return
if len(entry_NOMBRE.get()) > 15:
nombre_error.set("El campo nombre no puede tener más de 15 caracteres")
return
33
if entry_DNI.get() == "":
dni_error.set("El campo DNI no puede estar vacío")
return
userTest = usuarios[(usuarios["DNI"] == str(entry_DNI.get()))].index.values

if len(userTest != 0):
dni_error.set("El DNI ingresado ya existe")
return
try:
var = int(entry_DNI.get())
except:
dni_error.set("El DNI solo debe contener números")
return
if len(entry_DNI.get()) != 8:
dni_error.set("El campo DNI consta de 8 digitos")
return
if entry_PASSWORD.get() == "":
password_error.set("El campo contraseña no puede estar vacío")
return
if entry_PASSWORD.get() != entry_PASSWORD_2.get():
password_error.set("Las contraseñas no coinciden")
return
col_DNI = 1
col_NOMBRE = 2
col_PASSWORD = 3
col_ROL = 4
data = {"DNI":str(entry_DNI.get()), "NOMBRE

COMPLETO":entry_NOMBRE.get(),"CONTRASEÑA":str(entry_PASSWORD.get()),"rol":"user"}
usuarios = usuarios.append(data, ignore_index = True)
34
celdaDNI = hoja_usuarios.cell(row = len(usuarios.index) , column = col_DNI)
celdaDNI.value = entry_DNI.get()
celdaNOMBRE = hoja_usuarios.cell(row = len(usuarios.index) , column = col_NOMBRE)

celdaNOMBRE.value = entry_NOMBRE.get()
celdaPASSWORD = hoja_usuarios.cell(row = len(usuarios.index) , column = col_PASSWORD)

celdaPASSWORD.value = entry_PASSWORD.get()
celdaROL = hoja_usuarios.cell(row = len(usuarios.index), column = col_ROL)

celdaROL.value = "user"
archivo.save(datafile)
frame_createUser.pack_forget()
frame_login.pack()
mostrarNotificacion("Creación de cuenta correcta","Se ha creado correctamente su cuenta")
ancho_entry = 30
pos_x = 80
pos_y = 30
aumento_y = 25
ventanaRegistro = Frame(ventanaContenedor)
ventanaRegistro.config(width = TAM_BIBLIOTECA_APP_Y, height=
TAM_BIBLIOTECA_APP_X, bg = COLOR_FONDO_PANTALLA_1)
label_Nombre = Label(ventanaRegistro, text = "Ingrese su primer nombre:", bg =

COLOR_FONDO_PANTALLA_1, font = FUENTE)
label_Nombre.place( x = pos_x, y = pos_y + aumento_y * 0)
entry_NOMBRE = Entry(ventanaRegistro, bg = "white" , width = ancho_entry)

entry_NOMBRE.place(x = pos_x, y = pos_y + aumento_y * 1)
nombre_error = StringVar()
label_NOMBRE_Error = Label(ventanaRegistro, textvariable = nombre_error, bg =
COLOR_FONDO_PANTALLA_1, fg = "red")
35
label_NOMBRE_Error.place( x = pos_x, y = pos_y + aumento_y *2)
label_DNI = Label(ventanaRegistro, text = "Ingrese su DNI:", bg =

label_DNI.place( x = pos_x, y = pos_y + aumento_y * 4)
entry_DNI = Entry(ventanaRegistro, bg = "white" , width = ancho_entry)

entry_DNI.place(x = pos_x, y = pos_y + aumento_y * 5)
dni_error = StringVar()
label_DNI_Error = Label(ventanaRegistro, textvariable = dni_error, bg =
COLOR_FONDO_PANTALLA_1, fg = "red")
label_DNI_Error.place( x = pos_x, y = pos_y + aumento_y *6)
label_PASSWORD = Label (ventanaRegistro,text = "Ingrese su contraseña:", bg =

label_PASSWORD.place(x = pos_x, y = pos_y + aumento_y * 8)
entry_PASSWORD = Entry(ventanaRegistro, bg = "white", width = ancho_entry,show="*")

entry_PASSWORD.place( x = pos_x , y = pos_y + aumento_y * 9)
password_error = StringVar()
label_PASSWORD_Error = Label(ventanaRegistro, textvariable = password_error, bg =
COLOR_FONDO_PANTALLA_1, fg = "red" )
label_PASSWORD_Error.place(x = pos_x, y = pos_y + aumento_y * 10)
label_PASSWORD_2 = Label (ventanaRegistro,text = "Ingrese su contraseña:", bg =

label_PASSWORD_2.place(x = pos_x, y = pos_y + aumento_y * 12)
entry_PASSWORD_2 = Entry(ventanaRegistro, bg = "white", width = ancho_entry,show="*")

entry_PASSWORD_2.place( x = pos_x , y = pos_y + aumento_y * 13)
button_cancelar = Button(ventanaRegistro,font = FUENTE, text = "CANCELAR", width = 10, bg

= "red", command = cancelarRegistro)
button_cancelar.place(x = pos_x - 20, y = pos_y + aumento_y * 16)
36
button_ingresar = Button(ventanaRegistro,font = FUENTE, text = "INGRESAR", width = 10, bg =
COLOR_BUTTON_1, command = registrarUsuario)
button_ingresar.place(x = pos_x + 140, y = pos_y + aumento_y * 16)
return ventanaRegistro
#PARA EL INGRESO DE EL USER O EL ADMIN

def crearFrmLogin(ventanaContenedor):
ancho_entry = 30
pos_x = 80
pos_y = 200
aumento_y = 25
def regUser(event):
frame_login.pack_forget()
frame_createUser.pack()
def validarIngreso():
global usuario_autorizado
valido = True
if (DNI.get() == ""):
dni_error.set("El campo DNI no puede estar vacío.")
valido = False
if (PASSWORD.get() == ""):
password_error.set("El campo contraseña no puede estar vacío")
valido = False
usuario_autorizado = usuarios[(usuarios["DNI"] == DNI.get()) & (usuarios["CONTRASEÑA"]

== PASSWORD.get())].index.values
print("index ",usuario_autorizado)
if (len(usuario_autorizado) == 0):
dni_error.set("No se encuentra al usuario")
valido = False
elif (len(usuario_autorizado) == 2):
dni_error.set("Existen DNIs duplicados")
37
valido = False
return valido
def fun_ingresar_login():
#if (True):#validarIngreso()):
if (validarIngreso()):
ventanaContenedor.geometry(TAM_BIBLIOTECA_APP_2)
frame.destroy()
if (usuarios["rol"].iloc[usuario_autorizado[0]] == "user"):
frame_bienvenida.pack()
elif (usuarios["rol"].iloc[usuario_autorizado[0]] == "admin"):
frame_bienvenida_adm.pack()
frame = Frame(ventanaContenedor)
frame.config(width = TAM_BIBLIOTECA_APP_Y, height= TAM_BIBLIOTECA_APP_X, bg =
"white")
label_LOGO = Label(frame, image = click_login, borderwidth = 0)

label_LOGO.place(x = 80, y = 10)
label_DNI = Label(frame, text = "Ingrese su DNI:", bg = "white", font = FUENTE)

label_DNI.place( x = pos_x, y = pos_y)
DNI = StringVar()
entry_DNI = Entry(frame, textvariable = DNI, bg = COLOR_ENTRY_1 , width = ancho_entry)
entry_DNI.place(x = pos_x, y = pos_y + aumento_y * 1)
dni_error = StringVar()
label_DNI_Error = Label(frame, textvariable = dni_error, bg = "white", fg = "red")
label_DNI_Error.place( x = pos_x, y = pos_y + aumento_y *2)
label_PASSWORD = Label (frame,text = "Ingrese su contraseña:", bg = "white", font = FUENTE)

label_PASSWORD.place(x = pos_x, y = pos_y + aumento_y * 4)
38
PASSWORD = StringVar()
entry_PASSWORD = Entry(frame, textvariable = PASSWORD, bg = COLOR_ENTRY_1, width
= ancho_entry,show="*")
entry_PASSWORD.place( x = pos_x , y = pos_y + aumento_y * 5)
password_error = StringVar()
label_PASSWORD_Error = Label(frame, textvariable = password_error, bg = "white", fg = "red" )
label_PASSWORD_Error.place(x = pos_x, y = pos_y + aumento_y * 6)
button_ingresar = Button(frame,font = FUENTE, text = "INGRESAR", width = ancho_entry - 9, bg

= COLOR_BUTTON_1,command = fun_ingresar_login)
button_ingresar.place(x = pos_x + 3, y = pos_y + aumento_y * 7)
label_crearUsuario = Label(frame, text = "Haga click aquí para crear cuenta", bg = "white", fg =
"blue", font = FUENTE)
label_crearUsuario.place(x = pos_x - 22, y = pos_y + aumento_y * 10 - 10)
label_crearUsuario.bind("<Button-1>", regUser)
return frame
## CREACIÓN DE FRAME DE BIENVENIDA

def crearFrameBievenida(ventanaContenedor):
def fun_ir_a_reservar():
frame.pack_forget()
frame_reservar = crearFrameReservar(ventanaContenedor)
frame_reservar.pack()
def fun_ir_a_busqueda():
frame.pack_forget()
frame_busqueda = crearFrameBusquedaReserva(ventanaContenedor)
frame_busqueda.pack()
def fun_ir_a_devolver():
frame.pack_forget()
frame_retornar = crearFrameDevolver(ventanaContenedor)
frame_retornar.pack()
39
frame.config(width = TAM_BIBLIOTECA_APP_X_2, height= TAM_BIBLIOTECA_APP_Y_2,
bg = COLOR_FONDO_PANTALLA_1)
label_bienvenida = Label(frame, text = "BIENVENIDO/A A BOOKLAB", bg =

COLOR_FONDO_PANTALLA_1, font = (FUENTE_LETRA, FUENTE_TAM + 10,
FUENTE_WEIGHT))
label_bienvenida.place( x = 200, y = 70)
label_saludo = Label(frame, text = "¿Cómo podemos ayudarte el dia de hoy?", bg =

COLOR_FONDO_PANTALLA_1, font = (FUENTE_LETRA, FUENTE_TAM ))
label_saludo.place( x = 255, y = 120)
button_reservar = Button(frame, image = click_reservar, borderwidth = 0, command =

fun_ir_a_reservar)
button_reservar.place(x = 60, y = 200)
button_busqueda = Button(frame, image = click_busqueda, borderwidth = 0, command =

fun_ir_a_busqueda)
button_busqueda.place(x = 310, y = 200)
button_devolver = Button(frame, image = click_devolver, borderwidth = 0, command =

fun_ir_a_devolver)
button_devolver.place(x = 560, y = 200)
return frame
## CREACIÓN DE FRAME
def crearFrameReservar(ventanaContenedor):
def fun_ir_a_frameReservar():
frame.pack_forget()
def fun_ir_a_verTodo():
global frame_global
frame.pack_forget()
frame_global = crearFrameReservarContenido(ventanaContenedor,"TODOS")
40
frame_global.pack()
def fun_ir_a_verCuentos():
global frame_global
frame.pack_forget()
frame_global = crearFrameReservarContenido(ventanaContenedor,"CUENTO")
frame_global.pack()
def fun_ir_a_verNovelas():
global frame_global
frame.pack_forget()
frame_global = crearFrameReservarContenido(ventanaContenedor,"NOVELA")
frame_global.pack()
def fun_ir_a_verCienciaFiccion():
global frame_global
frame.pack_forget()
frame_global = crearFrameReservarContenido(ventanaContenedor,"CIENCIA FICCION")
frame_global.pack()
button_retroceder = Button(frame,font = FUENTE, text = "RETROCEDER", bg =

COLOR_BUTTON_1, command = fun_ir_a_frameReservar)
button_retroceder.place( x = 50, y = 30)
label_categoria = Label(frame, text = "Nuestras categorías", bg =

FUENTE_WEIGHT))
label_categoria.place( x = 240, y = 70)
label_indicacion = Label(frame, text = "Listado de categorías", bg =

label_indicacion.place( x = 315, y = 120)
41
button_novelas = Button(frame, image = click_novelas, borderwidth = 0,command =
fun_ir_a_verNovelas)
button_novelas.place(x = 60, y = 200)
button_cuentos = Button(frame, image = click_cuentos, borderwidth = 0,command =

fun_ir_a_verCuentos)
button_cuentos.place(x = 310, y = 200)
button_cienciaficcion = Button(frame, image = click_cienciaficcion, borderwidth = 0,command =

fun_ir_a_verCienciaFiccion)
button_cienciaficcion.place(x = 560, y = 200)
button_verTodo = Button(frame,font = FUENTE, text = "Ver todas las categorías", width = 40, bg
= COLOR_BUTTON_1, command = fun_ir_a_verTodo)
button_verTodo.place( x = 180, y = 450)
return frame
## CREACIÓN DE FRAME VER LIBROS

def crearFrameReservarContenido(ventanaContenedor, categoria):
def fun_ir_a_frameReservar():
frame.destroy()
def fun_ir_a_solicitarPrestamo():
seleccion = tablaContenido.focus()
valores = tablaContenido.item(seleccion,"values")
if(valores[4] == 0):
errorlabel.set("El libro seleccionado no se encuentra disponible. Stock: 0")
else:
errorlabel.set("")
crearVentanaSolicitarPrestamo(valores[1],valores[2])
def fun_borrar():
for item in tablaContenido.get_children():
42
tablaContenido.delete(item)
def fun_llenarTabla():
fun_borrar()
if (categoria == "TODOS"):
for i in libros.index:
if i == 0:
continue
if (texto.get() == "") or (texto.get().capitalize() in str(libros["nombre"][i]).capitalize()):
tablaContenido.insert(parent='',index='end',iid=i,text='',values=(str(i),libros["codigo"][i],libros["nomb
re"][i], libros["tipo"][i], libros["disponibilidad"][i]))
else:
indice = 0
if i == 0:
continue
if(libros["tipo"][i] == categoria) and (texto.get().capitalize() in
str(libros["nombre"][i]).capitalize()):
tablaContenido.insert(parent='',index='end',iid=i,text='',values=(str(indice +
1),libros["codigo"][i],libros["nombre"][i], libros["tipo"][i], libros["disponibilidad"][i]))
indice += 1
s = ttk.Style()
s.theme_use('clam')
s.configure('Treeview.Heading', background=COLOR_BUTTON_1)

COLOR_BUTTON_1, command = fun_ir_a_frameReservar)
43
label_categoria = Label(frame, text = categoria, bg = COLOR_FONDO_PANTALLA_1, font =
(FUENTE_LETRA, FUENTE_TAM + 10, FUENTE_WEIGHT))
label_categoria.place( x = 200, y = 30)
frame_2 = Frame(frame)
frame_2.config(width = TAM_BIBLIOTECA_APP_X_2, height=
TAM_BIBLIOTECA_APP_Y_2, bg = COLOR_FONDO_PANTALLA_1)
frame_2.place ( x = 50, y = 70)
errorlabel = StringVar()
label_error = Label(frame, textvariable = errorlabel, bg = COLOR_FONDO_PANTALLA_1,fg =
"red", font = (FUENTE_LETRA, FUENTE_TAM, FUENTE_WEIGHT))
label_error.place( x = 50, y = 500)
scrollTabla = Scrollbar(frame_2)
scrollTabla.pack(side=RIGHT, fill=Y)
tablaContenido = ttk.Treeview(frame_2,yscrollcommand=scrollTabla.set, height = 20,

selectmode='browse')
tablaContenido.pack()
scrollTabla.config(command=tablaContenido.yview)
tablaContenido['columns'] = ('id', 'Codigo', 'Titulo', 'genero', 'Disponibilidad')
tablaContenido.column("#0", width=0, stretch=NO)

tablaContenido.column("id",anchor=CENTER, width=60)
tablaContenido.column("Codigo",anchor=CENTER,width=110)
tablaContenido.column("Titulo",anchor=W,width=250)
tablaContenido.column("genero",anchor=W,width=170)
tablaContenido.column("Disponibilidad",anchor=CENTER,width=90)
tablaContenido.heading("#0",text="",anchor=CENTER)
tablaContenido.heading("id",text="Id",anchor=CENTER)
tablaContenido.heading("Codigo",text="Codigo",anchor=CENTER)
tablaContenido.heading("Titulo",text="Titulo",anchor=CENTER)
tablaContenido.heading("genero",text="Categoria",anchor=CENTER)
tablaContenido.heading("Disponibilidad",text="Dispon.",anchor=CENTER)
44
texto = StringVar()
entry_busqueda = Entry(frame, textvariable = texto,width = 12, font = (FUENTE_LETRA,
FUENTE_TAM + 2, FUENTE_WEIGHT))
entry_busqueda.place(x = 450 , y = 33)
button_buscar = Button(frame,font = FUENTE, text = "Buscar", bg = COLOR_BUTTON_1, width

= 10, command = fun_llenarTabla)
button_buscar.place(x = 620 , y = 30)
fun_llenarTabla()
button_solicitarprestamo = Button(frame,font = FUENTE, text = "Solicitar Prestamo", bg =

COLOR_BUTTON_1, width = 40, command = fun_ir_a_solicitarPrestamo)
button_solicitarprestamo.place( x = 160, y = 525)
return frame
## CREACIÓN DE VENTANA SOLICITAR PRESTAMO (E. FRAME VER LIBROS)

def crearVentanaSolicitarPrestamo(codigo,titulo):
def fun_ir_a_registrarPrestamo():
global prestamos
global frame_global
user = usuarios["DNI"].iloc[usuario_autorizado[0]]
fecha = datetime.datetime.today().strftime('%d-%m-%Y')
dias = int(combo.get())
data = {"DNI":user,"codigo":codigo,"fechaRegistro":fecha,"dias":dias,"devuelto":0}
prestamos = prestamos.append(data,ignore_index = True)
fecha_aux = datetime.datetime.strptime(fecha,"%d-%m-%Y")
fechafin = fecha_aux + datetime.timedelta(days = dias)
filaPrestamos = len(prestamos.index)
celdaDNI = hoja_prestamos.cell(row = filaPrestamos, column = 1)
celdaDNI.value = str(user)
45
celdaCodigo = hoja_prestamos.cell(row = filaPrestamos, column = 2)
celdaCodigo.value = codigo
celdaFecha = hoja_prestamos.cell(row = filaPrestamos, column = 3)
celdaFecha.value = fecha
celdaDias = hoja_prestamos.cell(row = filaPrestamos, column = 4)
celdaDias.value = dias
celdaDevuelto = hoja_prestamos.cell(row = filaPrestamos, column = 5)
celdaDevuelto.value = 0
libros.loc[libros["codigo"] == codigo,"disponibilidad"] = int(libros.loc[libros["codigo"] ==

codigo,"disponibilidad"]) - 1
libros.loc[libros["codigo"] == codigo,"vecesPrestado"] = int(libros.loc[libros["codigo"] ==
codigo,"vecesPrestado"]) + 1
celdaDisponibilidad = hoja_libros.cell(row = libros.loc[libros["codigo"] ==

codigo,"disponibilidad"].index[0] + 1,
column = libros.columns.get_loc("disponibilidad") + 1)
celdaDisponibilidad.value = int(libros["disponibilidad"].iloc[libros.loc[libros["codigo"] ==
codigo,"disponibilidad"].index[0]])
celdaVecesPrestado = hoja_libros.cell(row = libros.loc[libros["codigo"] ==

codigo,"vecesPrestado"].index[0] + 1,
column = libros.columns.get_loc("vecesPrestado") + 1)
celdaVecesPrestado.value = int(libros["vecesPrestado"].iloc[libros.loc[libros["codigo"] ==
codigo,"vecesPrestado"].index[0]])
ventana.destroy()
frame_global.destroy()
mostrarNotificacion2("Resistro Correcto","Registro correcto."," Fecha devolución

"+fechafin.strftime("%d-%m-%Y"))
ventana = Toplevel()
ventana.geometry(TAM_BIBLIOTECA_APP_2)
46
ventana.title("Solicitud de prestamo")
ventana.resizable(False,False)
ventana.config(background = COLOR_FONDO_PANTALLA_1)
frame = Frame(ventana)
img=Image.open(bookfolders+"/"+codigo)
o_size=img.size
f_size=(250,350)
factor = min(float(f_size[1])/o_size[1], float(f_size[0])/o_size[0])
width = int(o_size[0] * factor)
height = int(o_size[1] * factor)
rImg= img.resize((width, height), Image.ANTIALIAS)
img2 = ImageTk.PhotoImage(rImg)
panel = Label(frame, image=img2)
panel.place(x= 40, y = 150)
pos_x_label = 350
pos_y_label = 150
aumento_y_label = 60
pos_x_label_text = 550
label_titulo = Label(frame, text = "Titulo: ", bg = COLOR_FONDO_PANTALLA_1, font =

label_titulo.place(x = 150, y = 30)
label_titulo_texto = Label(frame, text = titulo, bg = COLOR_FONDO_PANTALLA_1, font =

label_titulo_texto.place(x = 275, y = 30)
label_usuario = Label(frame, text = "Usuario: ", bg = COLOR_FONDO_PANTALLA_1, font =

label_usuario.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 0)
47
usuario = usuarios["NOMBRE COMPLETO"].iloc[usuario_autorizado[0]]
label_usuario_texto = Label(frame, text = usuario, bg = COLOR_FONDO_PANTALLA_1, font =
label_usuario_texto.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 0)
label_codigo = Label(frame, text = "Codigo:", bg = COLOR_FONDO_PANTALLA_1, font =

label_codigo.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 1)
label_codigo_texto = Label(frame, text = codigo, bg = COLOR_FONDO_PANTALLA_1, font =

label_codigo_texto.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 1)
label_fecharetiro = Label(frame, text = "Fecha retiro: ", bg = COLOR_FONDO_PANTALLA_1,

font = (FUENTE_LETRA, FUENTE_TAM + 6, FUENTE_WEIGHT))
label_fecharetiro.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 2)
label_fecharetiro_texto = Label(frame, text = datetime.datetime.today().strftime('%d-%m-%Y'), bg

= COLOR_FONDO_PANTALLA_1, font = (FUENTE_LETRA, FUENTE_TAM + 6,
FUENTE_WEIGHT))
label_fecharetiro_texto.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 2)
label_dia = Label(frame, text = "Dias reserva: ", bg = COLOR_FONDO_PANTALLA_1, font =

label_dia.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 3)
combo = ttk.Combobox(frame, state="readonly", values = [1,2,3,4,5,6,7])

combo.set(1)
combo.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 3)
button_registrarPrestamo = Button(frame,font = FUENTE, text = "Registrar Prestamo", width = 40,

bg = COLOR_BUTTON_1, command = fun_ir_a_registrarPrestamo)
button_registrarPrestamo.place( x = 180, y = 450)
frame.pack()
48
ventana.mainloop()
## CREACIÓN DE FRAME BUSQUEDA DE RESERVA

def crearFrameBusquedaReserva(ventanaContenedor):
def fun_ir_a_frameBienvenida():
frame.pack_forget()
def borrarTabla():
def actualizarTabla(event = ""):

indice = 0
borrarTabla()
if comboTipo.get() == comboTipoValores[0]:
for i in prestamos.index:
if i == 0:
continue
if prestamos["DNI"][i] == usuarios["DNI"].iloc[usuario_autorizado[0]]:
for j in libros.index:
if libros["codigo"][j] == prestamos["codigo"][i]:
fecha = datetime.datetime.strptime(prestamos["fechaRegistro"][i],"%d-%m-%Y")
dias = int(prestamos["dias"][i])
fechafin = fecha + datetime.timedelta(days = dias)
if (prestamos["devuelto"][i] == 1):
1),prestamos["codigo"][i],libros["nombre"][j],
prestamos["fechaRegistro"][i],
fechafin.strftime("%d-%m-%Y"),"Devuelto"))
elif(prestamos["devuelto"][i] == 0):
if fechafin < datetime.datetime.today():
fechafin.strftime("%d-%m-%Y"),"Atrasado"))
49
else:
fechafin.strftime("%d-%m-%Y"),"Por devolver"))
indice += 1
break
elif comboTipo.get() == comboTipoValores[1]:
if i == 0:
continue
if(prestamos["devuelto"][i] == 0):
1),prestamos["codigo"][i],libros["nombre"][j], prestamos["fechaRegistro"][i], fechafin.strftime("%d-
%m-%Y"),"Atrasado"))
indice += 1
break
if i == 0:
continue
50
%m-%Y"),"Devuelto"))
indice += 1
break
if i == 0:
continue
if fechafin >= datetime.datetime.today():
%m-%Y"),"Por devolver"))
indice += 1
break
s = ttk.Style()
s.theme_use('clam')

COLOR_BUTTON_1, command = fun_ir_a_frameBienvenida)
51
label_titulo = Label(frame, text = "LISTA DE LIBROS RESERVADOS", bg =

FUENTE_WEIGHT))
label_titulo.place( x = 200, y = 30)
comboTipoValores = ["TODOS","ATRASADOS","DEVUELTOS","POR DEVOLVER"]

comboTipo = ttk.Combobox(frame, state="readonly", values = comboTipoValores, font =
comboTipo.set("TODOS")
comboTipo.bind("<<ComboboxSelected>>" ,actualizarTabla)
comboTipo.place(x = 520 , y = 65)
frame_2.place ( x = 20, y = 100)

tablaContenido['columns'] = ('id', 'Codigo', 'Titulo', 'fecha',"fechafin","estado")

tablaContenido.column("fecha",anchor=CENTER,width=130)
tablaContenido.column("fechafin",anchor=CENTER,width=130)
tablaContenido.column("estado",anchor=CENTER,width=120)
52
tablaContenido.heading("fecha",text="Fecha Prestamo",anchor=CENTER)
tablaContenido.heading("fechafin",text="Fecha Fin",anchor=CENTER)
tablaContenido.heading("estado",text="Estado",anchor=CENTER)
actualizarTabla()
return frame
## CREACIÓN DE FRAME DEVOLVER

def crearFrameDevolver(ventanaContenedor):
def fun_devolverLibro():
global prestamos
seleccion = tablaContenido.focus()
valores = tablaContenido.item(seleccion,"values")
celda = hoja_libros.cell(row = libros.loc[libros["codigo"] ==

valores[1],"disponibilidad"].index[0] + 1, column = libros.columns.get_loc("disponibilidad") + 1)
celda.value = int(libros["disponibilidad"].iloc[libros.loc[libros["codigo"] ==
valores[1],"disponibilidad"].index[0]])+1
libros.loc[libros["codigo"] == valores[1],"disponibilidad"] = int(libros.loc[libros["codigo"] ==

valores[1],"disponibilidad"]) + 1
fila = prestamos.loc[(prestamos["codigo"] == valores[1]) & (prestamos["fechaRegistro"] ==

valores[3]) & (prestamos["DNI"] == usuarios["DNI"].iloc[usuario_autorizado[0]]) &
(prestamos["devuelto"] == 0)]
columna = prestamos.columns.get_loc("devuelto") + 1
celda = hoja_prestamos.cell(row = fila.index[0] + 1, column = columna)
celda.value = 1
53
prestamos = generarPandas(hoja_prestamos)
prestamos[["DNI"]] = prestamos[["DNI"]].astype(str)
fun_ir_a_retroceder()
mostrarNotificacion("Devolución correcta","Se ha hecho una correcta devolución")
def fun_ir_a_retroceder():
frame.destroy()
s = ttk.Style()
s.theme_use('clam')

COLOR_BUTTON_1, command = fun_ir_a_retroceder)
label_titulo = Label(frame, text = "LIBROS POR DEVOLVER", bg =

FUENTE_WEIGHT))
frame_2.place ( x = 20, y = 70)
54
tablaContenido['columns'] = ('id', 'Codigo', 'Titulo', 'fecha',"fechafin","estado")

tablaContenido.heading("fecha",text="Fecha Prestamo",anchor=CENTER)
tablaContenido.heading("fechafin",text="Fecha Fin",anchor=CENTER)
indice = 0
%m-%Y"),"Atrasado"))
55
else:
%m-%Y"),"Por devolver"))
indice += 1
break
button_solicitarprestamo = Button(frame,font = FUENTE, text = "Devolver libro", bg =

COLOR_BUTTON_1, width = 40, command = fun_devolverLibro)
button_solicitarprestamo.place( x = 160, y = 525)
return frame
####################################################################
## CREACIÓN DE FRAME DE BIENVENIDA ADMINISTRADOR

def crearFrameBienvenidaAdmin(ventanaContenedor):
def fun_ir_a_reportes():
frame.pack_forget()
frame_reporte.pack()
def fun_ir_a_addlibros():
frame.pack_forget()
frame_addlibro.pack()
56
label_bienvenida = Label(frame, text = "BIENVENID@ a BookLab", bg =
FUENTE_WEIGHT))
label_bienvenida.place( x = 200, y = 70)
label_saludo = Label(frame, text = "¿En qué te podemos ayudar hoy?", bg =

label_saludo.place( x = 255, y = 120)
button_reportes = Button(frame, image = click_reportes, borderwidth = 0, command =

fun_ir_a_reportes)
button_reportes.place(x = 180, y = 200)
button_addlibros = Button(frame, image = click_addlibro, borderwidth = 0, command =

fun_ir_a_addlibros)
button_addlibros.place(x = 440, y = 200)
return frame
## CREACIÓN DE FRAME REPORTE PRESTAMOS

def crearFrameReportes(ventanaContenedor):
frame.pack_forget()
def borrarTabla():
def actualizarTabla(event = ""):

indice = 0
borrarTabla()
if comboTipo.get() == comboTipoValores[0]:
if i == 0:
continue
57
tablaContenido.insert(parent='',index='end',iid=i,text='',
values=(str(indice + 1),prestamos["DNI"][i],prestamos["codigo"][i]
,libros["nombre"][j], prestamos["fechaRegistro"][i],
elif(prestamos["devuelto"][i] == 0):
else:
indice += 1
break
if i == 0:
continue
1),prestamos["DNI"][i],prestamos["codigo"][i],libros["nombre"][j], prestamos["fechaRegistro"][i],
indice += 1
58
break
if i == 0:
continue
indice += 1
break
if i == 0:
continue
if fechafin >= datetime.datetime.today():
indice += 1
break
def mostrarPorcentajeCategoria():
prestamoCategoria = []
vecesPrestados = []
59
for genero in generosLibros:
var = libros.loc[libros["tipo"] == genero, "vecesPrestado"].sum()
if ( var > 0):
prestamoCategoria.append(genero)
vecesPrestados.append(var)
fig1, ax1 = plt.subplots()

ax1.pie(vecesPrestados, labels=prestamoCategoria, autopct='%1.1f%%', shadow=True,
startangle=90)
ax1.axis("equal")
plt.show()
def mostrarLibrosMasSolicitados():
nombre_Libros = []
cant_Prestamos = []
if (i != 0) and (libros["vecesPrestado"][i] != 0):
print(i)
nombre_Libros.append(libros["nombre"][i])
cant_Prestamos.append(libros["vecesPrestado"][i])
plt.barh(nombre_Libros, cant_Prestamos)
plt.title("Número de prestamos por libro")
plt.ylabel("Nombres")
plt.xlabel("Número de prestamos")
plt.show()
def mostrarUsuarioConMasPrestamos():
usuarioPrestamo = []
cantPrestamos = []
for i in usuarios.index:
if (i == 0) or (usuarios["rol"][i] == "admin"):
continue
var = prestamos.loc[prestamos["DNI"] == usuarios["DNI"][i],"DNI"].count()
60
usuarioPrestamo.append(usuarios["NOMBRE COMPLETO"][i])
cantPrestamos.append(var)
plt.barh(usuarioPrestamo, cantPrestamos)
plt.title("Cantidad de prestamos por persona")
plt.ylabel("Nombre")
plt.xlabel("Número de prestamos")
plt.show()
s = ttk.Style()
s.theme_use('clam')

button_porcentaje = Button(frame,font = FUENTE, text = "GRAF. CATEGORIAS", bg =

COLOR_BUTTON_2, command = mostrarPorcentajeCategoria)
button_porcentaje.place( x = 20, y = 550)
button_librosSolicitados = Button(frame,font = FUENTE, text = "LIBROS MÁS SOLICITADOS",

bg = COLOR_BUTTON_2, command = mostrarLibrosMasSolicitados)
button_librosSolicitados.place( x = 235, y = 550)
button_usuarioPrestamos = Button(frame,font = FUENTE, text = "USUARIOS MÁS

PRESTAMOS", bg = COLOR_BUTTON_2, command = mostrarUsuarioConMasPrestamos)
button_usuarioPrestamos.place( x = 515, y = 550)
61
label_titulo = Label(frame, text = "LISTA DE LIBROS RESERVADOS", bg =
FUENTE_WEIGHT))
comboTipoValores = ["TODOS","ATRASADOS","DEVUELTOS","POR DEVOLVER"]

comboTipo = ttk.Combobox(frame, state="readonly", values = comboTipoValores, font =
comboTipo.set("TODOS")
comboTipo.bind("<<ComboboxSelected>>" ,actualizarTabla)
comboTipo.place(x = 520 , y = 65)
frame_2.place ( x = 20, y = 100)
scrollTabla2 = Scrollbar(frame_2,orient='horizontal')
scrollTabla2.pack(side=BOTTOM, fill=X)
tablaContenido =
ttk.Treeview(frame_2,yscrollcommand=scrollTabla.set,xscrollcommand=scrollTabla2.set, height =
20, selectmode='browse')
scrollTabla2.config(command=tablaContenido.xview)
tablaContenido['columns'] = ('id', 'dni','Codigo', 'Titulo', 'fecha',"fechafin","estado")

tablaContenido.column("dni",anchor=CENTER,width=80)
62
tablaContenido.heading("dni",text="DNI",anchor=CENTER)
tablaContenido.heading("fecha",text="F.Prestamo",anchor=CENTER)
tablaContenido.heading("fechafin",text="F. Fin",anchor=CENTER)
actualizarTabla()
return frame
## CREACIÓN DE FRAME ADD LIBRO

def crearFrameAddLibro(ventanaContenedor):
frame.pack_forget()
texto.set("")
panel.configure(image=imagen)
panel.image = imagen
obtenerCodigo()
def obtenerCodigo(event=""):
cadena = comboTipo.get()
if cadena == values[0]:
cadena = "NO-"
elif cadena == values[1]:
cadena = "CU-"
cadena = "CF-"
63
cadena = "TE-"
cadena = "AC-"
cadena = "CO-"
else:
print("ERROR: No se puede crear")
return
indice = 0
if cadena in libros["codigo"][i]:
indice += 1
codigoGenerado.set(cadena+str(indice + 1))
def addLibro():
if(texto.get() != "" and rutaImagen != ""):
global libros
fila = len(libros.index) + 1
col_nombre = 1
col_codigo = 2
col_tipo = 3
col_dispo = 4
col_prestamo = 5
celda = hoja_libros.cell(row = fila, column = col_nombre)

celda.value = texto.get()
celda = hoja_libros.cell(row = fila, column = col_codigo)
celda.value = codigoGenerado.get()
celda = hoja_libros.cell(row = fila, column = col_tipo)
celda.value = comboTipo.get()
celda = hoja_libros.cell(row = fila, column = col_dispo)
celda.value = int(comboCantidad.get())
celda = hoja_libros.cell(row = fila, column = col_prestamo)
64
celda.value = 0
destino = ruta+"/"+bookfolders+"/"+codigoGenerado.get()
shutil.copy(rutaImagen.get(), destino)
var1 = str(texto.get())
var2 = str(codigoGenerado.get())
var3 = str(comboTipo.get())
var4 = str(comboCantidad.get())
data = {"nombre":var1,"codigo":var2,"tipo":var3,"disponibilidad":var4}
libros = libros.append(data, ignore_index = True)
fun_ir_a_frameBienvenida()
mostrarNotificacion("Creación correcta","Se ha creado el libro correctamente.")
else:
errorLabel.set("El nombre y la imagen no pueden estar vacíos")
def callback():
ruta_2=filedialog.askopenfilename()
img=Image.open(ruta_2)
rutaImagen.set(ruta_2)
o_size=img.size
f_size=(200,400)
factor = min(float(f_size[1])/o_size[1], float(f_size[0])/o_size[0])
width = int(o_size[0] * factor)
height = int(o_size[1] * factor)
rImg= img.resize((width, height), Image.ANTIALIAS)
img2 = ImageTk.PhotoImage(rImg)
panel.configure(image=img2)
panel.image = img2
rutaImagen = StringVar()
65
pos_x_label = 50
pos_y_label = 150
aumento_y_label = 60
pos_x_label_text = 240
label_titulo = Label(frame, text = "AGREGAR LIBRO A LA BIBLIOTECA", bg =

FUENTE_WEIGHT))
label_titulo.place(x = 200, y = 30)
imagen = ImageTk.PhotoImage(Image.open(resourcesfolder+"nofile.png"))
panel = Label(frame, image=imagen)
panel.place(x= 530, y = 150)
button_cargarimagen=Button(frame,text="Cargar
Imagen",command=callback,width=15).place(x=560,y=400)
#CATEGORÍA
label_usuario = Label(frame, text = "Categoría:", bg = COLOR_FONDO_PANTALLA_2, font =
label_usuario.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 0)
values = generosLibros
comboTipo = ttk.Combobox(frame, state="readonly", values = values, font = (FUENTE_LETRA,
FUENTE_TAM + 2, FUENTE_WEIGHT))
comboTipo.set(values[0])
comboTipo.bind("<<ComboboxSelected>>" ,obtenerCodigo)
comboTipo.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 0)
#NOMBRE
66
label_nombre = Label(frame, text = "Titulo:", bg = COLOR_FONDO_PANTALLA_2, font =
label_nombre.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 1)
errorLabel = StringVar()
error = Label(frame, textvariable = errorLabel, bg = COLOR_FONDO_PANTALLA_2, fg="red")
error.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 1 + 30)
texto = StringVar()
entry_nombre = Entry(frame, textvariable = texto, font = (FUENTE_LETRA, FUENTE_TAM + 2,
FUENTE_WEIGHT))
entry_nombre.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 1)
#CANTIDAD
label_cantidad = Label(frame, text = "Cantidad: ", bg = COLOR_FONDO_PANTALLA_2, font =
label_cantidad.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 2)
comboCantidad = ttk.Combobox(frame, state="readonly", values = [1,2,3,4], font =

comboCantidad.set(2)
comboCantidad.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 2)
#CÓDIGO
label_codigo = Label(frame, text = "Codigo auto:", bg = COLOR_FONDO_PANTALLA_2, font =
label_codigo.place(x = pos_x_label , y = pos_y_label + aumento_y_label * 3)
codigoGenerado = StringVar()
label_codigo_text = Label(frame, textvariable = codigoGenerado, bg =

FUENTE_WEIGHT))
label_codigo_text.place(x = pos_x_label_text , y = pos_y_label + aumento_y_label * 3)
67
button_registrarPrestamo = Button(frame,font = FUENTE, text = "AÑADIR LIBRO", width = 70,
height = 3, bg = COLOR_BUTTON_2, command = addLibro)
button_registrarPrestamo.place( x = 50, y = 450)
obtenerCodigo()
return frame
####################################################################
archivo = load_workbook(datafile)
hoja_libros = generarHoja("Libros")
libros = generarPandas(hoja_libros)
hoja_usuarios = generarHoja("Usuarios")
usuarios = generarPandas(hoja_usuarios)
usuarios[["DNI","CONTRASEÑA"]] = usuarios[["DNI","CONTRASEÑA"]].astype(str)
hoja_prestamos = generarHoja("Prestamos")
prestamos = generarPandas(hoja_prestamos)
prestamos[["DNI"]] = prestamos[["DNI"]].astype(str)
usuario_autorizado = ""
frame_global = ""
generosLibros = ["NOVELA","CUENTO","CIENCIA
FICCION","TERROR","ACCION","COMEDIA"]
## CONSTANTES DE COLORES
COLOR_FONDO_PANTALLA_1 = "#CDF0EA"
COLOR_FONDO_PANTALLA_2 = "#ecb0ee"
COLOR_ENTRY_1 = "#DEEDF0"
COLOR_ENTRY_2 = "#"
COLOR_BUTTON_1 = "#98DDCA"
COLOR_BUTTON_2 = "#c67dc8"
## CONSTANTE DE LETRA
68
FUENTE_LETRA = "Cambria"
FUENTE_TAM = 11
FUENTE_WEIGHT = "bold"
## CONSTANTES DE TAMAÑO
TAM_BIBLIOTECA_APP_Y = 400
TAM_BIBLIOTECA_APP_X = 500
TAM_BIBLIOTECA_APP = str(TAM_BIBLIOTECA_APP_Y) + "x" +
str(TAM_BIBLIOTECA_APP_X)
TAM_BIBLIOTECA_APP_Y_2 = 600
TAM_BIBLIOTECA_APP_X_2 = 800
TAM_BIBLIOTECA_APP_2 = str(TAM_BIBLIOTECA_APP_X_2) + "x" +
str(TAM_BIBLIOTECA_APP_Y_2)
# PRINCIPAL
bibliotecaApp = crearPantallaInicial()
# FUENTE A UTILIZAR
FUENTE = tkFont.Font(family=FUENTE_LETRA, size=FUENTE_TAM,
weight=FUENTE_WEIGHT)
# IMAGENES LOGIN
click_login = PhotoImage(file = resourcesfolder+"logo.png")
# IMAGENES FRAME BIENVENIDA
click_reservar = PhotoImage(file = resourcesfolder+"reservar.png")
click_busqueda = PhotoImage(file = resourcesfolder+"busqueda.png")
click_devolver = PhotoImage(file = resourcesfolder+"devolver.png")
# IMAGENES FRAME RESERVARS
click_novelas = PhotoImage(file = resourcesfolder+"novelas.png")
click_cuentos = PhotoImage(file = resourcesfolder+"cuentos.png")
click_cienciaficcion = PhotoImage(file = resourcesfolder+"cienciaficcion.png")
# IMAGENES FRAME BIENVENIDA ADMIN
click_addlibro = PhotoImage(file = resourcesfolder+"addLibro.png")
click_reportes = PhotoImage(file = resourcesfolder+"reporteReserva.png")
frame_login = crearFrmLogin(bibliotecaApp)
69
frame_createUser = ventanaRegistroUsuario(bibliotecaApp)
frame_login.pack()
# FRAME USUARIO
frame_bienvenida = crearFrameBievenida(bibliotecaApp)
frame_reservar = crearFrameReservar(bibliotecaApp)
frame_busqueda = ""
frame_retornar = ""
# FRAME ADMIN
frame_bienvenida_adm = crearFrameBienvenidaAdmin(bibliotecaApp)
frame_reporte = crearFrameReportes(bibliotecaApp)
frame_addlibro = crearFrameAddLibro(bibliotecaApp)
bibliotecaApp.mainloop()
70

Trabajo Final - Grupo 1

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo Final - Grupo 1

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD PERUANA DE CIENCIAS APLICADAS

CARRERA DE INGENIERÍA INDUSTRIAL

“AVANCE PARCIAL DEL TRABAJO FINAL”

Abancini Diaz Benjamin (U201724421)

Aiquipa Arce Christian Edgar (U20201B912)

Astucuri Betalleluz Kevin Omar Stéfano (U202011811)

Profesor: Oscar Alberto Granda Gayoso

Curso: Software para Ingenieros

En este trabajo de investigación, aplicará los conocimientos técnicos adquiridos en el

del libro al momento de solicitar un préstamo. BookLab es el software de la ciudad de la

necesidades de cada usuario.

de desarrollo del proyecto. El objetivo es establecer el procedimiento desde la solicitud de

secuencia establecida. Finalmente, programaremos la aplicación en Python. El software

permite ingresar códigos de libros establecidos, guardar solicitudes y ordenarlas de acuerdo

Figura 1 : Encuesta realizada a 1000 vecinos 8

Figura 2: Encuesta de incidencias realizada a 1000 vecinos 10

Figura 3: Diagrama de casos de uso 12

Figura 4: Diagrama de clases 13

Figura 5: Diagrama de secuencia para el administrador 13

Figura 6: Diagrama de secuencia para el usuario 14

Figura 7: Diagrama de actividades 15

Figura 8: Interfaz inicial de la app BookLab 16

Figura 9: Interfaz para registrarse siendo usuario 17

Figura 10: Interfaz donde se muestra las opciones del usuario 18

Figura 11: Interfaz de categorías disponibles en la plataforma 18

Figura 12: Interfaz donde se ve la categoría de cuentos y los disponibles 19

Figura 13: Interfaz para reservar el libro seleccionado 20

Figura 14: Interfaz donde se ve la actualización del stock de los libros 20

Figura 15: Interfaz del administrador donde da dos opciones 21

Figura 16: Formato de la lista de libros reservados 21

Figura 18: Parte del código en Python 28

Tabla 1: Encuesta de incidencias realizada a 1000 vecinos 10

Tabla 2: Variables del programa realizado 23

Tabla 3: Variables del programa realizado 24

Tabla 4: Variables del programa realizado 25

Tabla 5: Variables del programa realizado 26

Este proyecto de investigación y aplicación se enfoca en los antiguos y nuevos usuarios

de la biblioteca BookLab y en optimizar el proceso de registro de solicitud de libros, teniendo

Proporcionar mayor visualización, control y accesibilidad a los responsables de iniciar

procesos a través de la implementación de cuadros de mando automatizados que permitan el

entregados al personal técnico.

mantenimiento. También se consideran el análisis de la causa raíz, las principales áreas

problemáticas, el tiempo de inactividad del equipo, el costo, la disponibilidad de las piezas de

herramientas que permitirán a las áreas de mantenimiento agilizar su trabajo y brindar

información ordenada, específica y oportuna de acuerdo a sus necesidades de producción con

La tecnología de la información y optimización se desarrolla a un ritmo exponencial,

servicios de registro de códigos y nuevas solicitudes de clientes en el sitio.

La intención es crear un software para el personal de servicio que es el principal

responsable del acceso a las instalaciones y la gestión de movimientos. BookLab optimiza el

Industrial, impulsada por la automatización y la interconexión de sistemas inteligentes.

Participamos activamente en el apoyo a BookLab en bibliotecas locales populares de todo el

BookLab es la biblioteca municipal de Surquillo con más de 9 años al servicio del

Figura 1 : Encuesta realizada a 1000 vecinos

las necesidades de la comunidad educativa, asegurar el aprendizaje y nutrir el amor por la

lectura del público.

Ser la biblioteca líder en el distrito de Surquillo, somos reconocidos por la venta y

distribución de libros de texto, lectura general, plataformas digitales y la calidad de las

traducciones de editoriales nacionales e internacionales. Nuestros servicios y aportes a la

PROCESO DE ESTUDIO Y DEFINICIÓN DEL PROBLEMA

frecuencia a la biblioteca municipal de Surquillo, que se conoció luego de la elaboración de

dañan al medio ambiente.

En vista que la biblioteca no cuenta con una plataforma desarrollada, proponemos la