m UNIVERSIDAD AUTONOMA METROPOLITANA Casa abierta al tiempo
CIENCIAS BASICAS E INGENIERíA
PROGRAMA DE PROYECTOS TERMlNALES EN INSTITUCIONES DEL SECTOR PúBLICO
TRIMESTRES: 98-P Y 98-0
ALUMNOS: CÉSPEDES MURILLO JOHONY
MÉNDEZ TORRES JUAN ENRIQUE
ASESOR
OMAR LUCIO CABRERA JlMENEZ
. ..
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PUBLICO
INDICE
1 .. INTRODUCCI~N ............................................................................................ 3
2.- PRESENTACIóN DEL PROBLEMA ............................................................. 5
3.- PRESENTACIóN DEL SISTEMA ................................................................... 6
4.- ESTRUCTURA DEL SISTEMA ...................................................................... 7
5.- DESCRIPCIóN MODULAR Y DOCUMENTAClbN DE MóDULOS ............. 8
5.1 .- DIAGRAMA DE FLUJO DE DATOS ................................................ 9
5.2.- DESCRIPCIóN MODULAR ............................................................. 10
5.3.- DOCUMENTACIóN DE MóDULOS ............................................... 11
6.- CONSIDERACIONES DE LENGUAJE ......................................................... 18
7.- CONCLUSIONES .......................................................................................... 20
ANEXOS ........................................................................................................ 22
PROYECTO TERMINAL 2
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
I .- INTRODUCCI~N
Diseño de Software Orientado a Objetos
La metodología orientada a objetos esta avanzando rápidamente en el
desarrollo de software. Esto permite implementar sistemas de software con la
calidad, productividad y beneficios de reutilización proporcionados por la
tecnología de objetos.
Esto se logra a través de la modelación de objetos de aplicación,
modelación del comportamiento de objetos utilizando escenarios, diagramas de
rastreo de eventos y diagramas de interacción de objetos, modelar las relaciones
entre objetos y el impacto de la asociación y unión de relaciones, utilizar herencia
y polimorfismo, como una base para implementación en lenguajes como Phyton y
JAVA.
Este proyecto se desarrollo utilizando la Metodología de análisis y diseño
orientada a objetos y la notación dada por el Lenguaje de Modelo Unificado de
Booch, Rumbauch y Jacobson (UML), además de contar con herramientas
recientes tales como Phyton(win32all-ODBC, megawidgets), Rational-rose y
Access como DBMS.
El desarrollo de un sistema requiere de las siguientes etapas:
0 Identificación del problema
0 Especificación de los Requerimientos.
0 Análisis
0 Diseño
0 Construcción
0 Prueba y Mantenimiento.
0 implementación
En la primera etapa del ciclo de desarrollo de los sistemas, el analista se
involucra en la identificación de los problemas, oportunidades y objetivos.
PROYECTO TERMINAL 3
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
En la Especificación de los Requerimientos se realizan entrevistas Con las
personas involucradas con el sistema a implantar o modificar, con el fin de tener
perfectamente claro cuales son los requerimientos del sistema, esta es una etapa
muy importante en el desarrollo del sistema ya que de éI depende el éxito 0
fracaso del sistema. Además de las entrevistas también pueden utilizarse Otros
instrumentos como son: muestreo, estudio de los datos, formas usadas por la
organización, cuestionarios, observación de la conducta de quien toma las
decisiones y además el desarrollo de prototipos.
En la etapa de análisis, se desarrollan los Use Case del sistema, a partir de la
especificación de los requerimientos. Un Use Case es una tarea de un sistema,
donde se especifican cada uno de los pasos a seguir para el desarrollo de ésta,
tomando en cuenta que cada uno de los pasos de un Use Case será una
responsabilidad o método de un objeto del sistema.
La etapa de diseño consiste en establecer cuales serán los distintos objetos
del sistema, sus atributos y responsabilidades de cada uno de ellos, así como
también el desarrollo de diagramas de secuencia y colaboración entre los distintos objetos del sistema, para tener una idea mas clara de la comunicación
que existe dentro del sistema. Los diagramas sirven para ver al sistema como un
todo y tener una idea clara de la función que realiza. Forma parte de esta etapa el
diseño de la interfaz con el usuario.
En la etapa de Construcción se realiza la elección de las herramientas y el
hardware con los cuales se llevará a cabo el desarrollo de la aplicación, la
importancia de esta etapa influye en el desempeño del sistema. Durante esta
fase, el analista también colabora con los usuarios para desarrollar la
documentación indispensable del software, incluyendo el manual de
procedimientos. La documentación proporcionará al usuario la forma de operar el
software y qué hacer en caso de presentarse algún problema.
En la etapa de prueba y mantenimiento, se realizan pruebas antes de liberar la
aplicación al usuario final. El costo es menor si se detectan problemas antes de la
entrega del sistema. El programador realiza unas pruebas por su cuenta, otras se
llevan a cabo en colaboración con el analista de sistemas. Se realiza una serie de
pruebas con datos tipo, para identificar las posibles fallas del sistema. El PROYECTO TERMINAL 3
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLlCQ
mantenimiento y la documentación empiezan justamente en esta etapa, esta
función se realizará de forma rutinaria a lo largo de toda la vida del sistema.
En esta última etapa del desarrollo del sistema, el analista ayuda a implantar el
sistema de información. Esto incluye la capacitación del usuario.
Aunque la evolución del sistema se plantea como parte integrante de la última
etapa del ciclo de desarrollo de los sistemas; realmente, la evolución toma parte
en cada una de las etapas.
2.- PRESENTACldN DEL PROBLEMA
Este proyecto consiste en implantar un sistema para el departamento de la
división de Ciencias Básicas e Ingeniería, el cual nos permitirá automatizar el
control de los datos de tos profesores.
El constante movimiento de los datos concernientes a los profesores dentro
de la división, exige una modernización para la optimización del manejo de estos
datos.
El estado actual de estos datos son hojas Excel, las cuales se encuentran
distribuidas entre las distintas Coordinaciones y la Secretaria Académica de CBI,
las cuales con el paso del tiempo se han ido modificando en su estructura y
tamaño, cada una por su parte sin seguir un patrón o formato establecido.
AI tener cada una de estas instancias su propio formato y actualización, nos
indica duplicidad de datos e incompatibilidad en algunos casos ya que las
actualizaciones no se realizan en todas las instancias referidas, si se solicitaran
datos relacionados con algún profesor en las distintas instancias se podrían tener
datos distintos, lo cual afecta a la veracidad y a el flujo de información entre la
Secretaría Académica y las distintas Coordinaciones.
Las ventajas que se obtienen con la automatización son evidentes, se
tendría una red con un servidor en la Secretaría Acadkmica con todos los datos,
en un formato estandar y terminales en las distintas Coordinaciones con acceso a
este servidor, con esto se elimina la duplicidad de datos y no se diga del flujo de
10s mismos entre las distintas instancias, el sistema desarrollado facilita el manejo
PROYECTO TERMINAL 5
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
de los datos de los profesores concernientes a la contratación, renuncias y
recontratación, así como proporcionar información relacionada con cualquier
profesor.
Los riesgos de esta automatización son esencialmente la seguridad de los
datos, ya que solo se tendría una copia de los datos en el servidor y cualquier falla
o modificación de estos datos afectaría a todas las instancias, para minimizar
riesgos se necesitan hacer copias de seguridad periódicamente y controlar la
entrada de información a la base de datos.
3.- PRESENTACldN DEL SISTEMA
El sistema se desarrolló en Phyton (lenguaje de programación
multiplataforma orientado a objetos de distribución libre), los datos de los profesores se encontraban en hojas Excel y se migró a Access, para el manejo de
base de datos, la manipulación de estos datos se hicieron con sentencias SQL
soportados por Phyton.
El sistema consta de seis módulos, el primero de ellos contiene el menú
principal que contiene las funciones de contratación, renuncias, modificación,
recontratación, consulta y permisos que nos permiten manipular toda la
información referente a los profesores. El segundo módulo contiene todo lo
referente a consulta de historial de los profesores, en el cual se puede ver su
trayectoria laboral, los cuatro módulos restantes son editor tipo de plaza,
categoría, nivel y tiempo de dedicación los cuales nos permiten dar de alta, baja,
modificar y consultar los diferentes tipos de plazas, categorías, niveles y tiempos
de dedicación.
PROYECTO TERMINAL 6
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
4.- ESTRUCTURA DEL SISTEMA
Diagrama de Clases
ACTOR x
L
1'
* I
I 4 '
Figura 1.
El diagrama de clases (figural ) muestra la relación entre los objetos, la
clase EjecutaSQL es la única que tiene acceso directo a transacciones con la base
de datos (la forma en que Phyton maneja estas transacciones con la base se
encuentra en el Anexo I), las demás clases iteractuan con esta para obtener la
información necesarios de la Base de Datos, el actor solo se relaciona con la clase
Pantalla-Principal la cual está relacionada con las demás clases una descripción
mas detallada de cada método se muestra en la siguiente sección.
PROYECTO TERMINAL, 7
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚSLICO
5.- DESCRIPCIóN MODULAR Y DOCUMENTACIbN DE MóDULOS
LOS módulos que se describen a continuación son del programa principal,
se hicieron cuatro programas más como ayuda para el editor principal, los cuales
se describen en el anexo I I.
Para el modulo principal mostraremos la base de datos que se utiliza las
tablas y una descripción detallada de cada una de sus clases.
Nombre : Editor de plazas
Nombre del archivo: EditPza.py
Tablas utilizadas: TArea, TDepto, TDiv ,
TUnidad, TProfesor, THistProfPza,
TPlaza, TNivelPza, TfipPza,
TTDPza, TCafegPza
(todas son de solo lectura excepto THistProfPza en la Clase
Eliminar).
PROYECTO TERMINAL
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
5.1.- DIAGRAMA DE FLUJO DE DATOS
Las operaciones que realizan las clases Agregar, Eliminar y Modificar a la base de datos son de lectura escritura sobre la misma solo la clase consultar
realiza lecturas a la misma como se muestra a continuación.
Figura 2.
Propósitos Generales: Haciendo uso de la filosofía de la programación orientada
a objetos estas clases utilizan los mismos atributos, solo hay un detalle que los
distingue:
Cuando el usuario selecciona la opción de eliminar es modificada la tabla
de historial de la plaza actualizando este campo con la fecha en la que se eliminó
el profesor que tenía asignada esa plaza, la información restante es de solo
lectura por lo que no puede ser modificar por el usuario.
PROYECTO TERMINAL 9
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PUBLICO
Las siguientes clases hacen uso de la clase NoteBookR de PMW que
facilita el manejo grandes cantidades de información y es vital en el desarrollo de
esta aplicación.
5.2.- DESCRIPCIoN MODULAR
Las clases Recontratar, Consultar, Agregar, Modificar y Eliminar son
llamadas desde la clase Main dependiendo de las solicitudes del usuario.
Diagrama de llamadas entre clases
Figura 3.
PROYECTO TERMINAL 10
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PUBLICO
5.3.-DOCUMENTACle)N DE MdDULOS
CLASES PRINCIPALES:
Figura 4.
Clase Main: Esta es la clase principal en la cual se crea la ventana
principal y se hacen las llamadas a las demás clases.
Principales métodos de la clase Main:
CreateWidget(se1f): En este método se crea la ventana principal y se asocian las
pulsaciones a los botones a las demás clases.
Execute(self,opcion): Este método verifica que tipo de plaza se eligió y con la
que se trabajara a partir de este momento.
Deshabilita(se1f): En este método se deshabilitan todos los botones de la ventana
principal al haber elegido alguna acción.
En los métodos: Consultar(self,Ist,value), Eliminar(self,lst,value), Modificar
(self, k t , value), se hace una llamada a la clase carpeta la cual nos muestra los
tabs con los datos a consultar, eliminar o modificar.
PROYECTO TERMINAL 11
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
Altas(se1f): En este método se hace una llamada a la clase Agregar, para dar de
alta a un nuevo maestro en la plaza libre elegida.
Recontrato(se1f): En este método se hace una llamada a la clase
InicRecontrata, en la cual se recontratará a un maestro para que ocupe una nueva
plaza.
Salir(se1f): En este método se muestra un cuadro de dialogo con lo que nos
indica si queremos salir del programa o no.
Clase InicRecontrata(Topleve1): En esta clase se crea la ventana de
recontratación y se realiza la recontratación de profesores con historial en la
universidad.
Figura 5.
Principales metodos de la clase InicRecontrata:
CreaNuevaVent(se1f) Método que se encarga de crear una ventana similar a la
principal en la cual se muestran las plazas disponibles.
Recontratos(self,lista,value) En este método se crean los tabs donde se
muestran la información relacionada con el idprofesor. PROYECTO TERMINAL 12
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
habilita(se1f) Habilita y deshabilita los botones de la pantalla actual
salir(self) Sale de la pantalla actual sin realizar cambios.
Clase VentanaAltas(Topleve1): En esta clase se crean los tabs (folders) en
los cuales se pedirán los datos del nuevo profesor para la plaza elegida.
Figura 6.
Principales mbtodos de la clase VentanaAltas:
carpeta(se1f) Método que se encarga de crear los tabs donde se piden los datos
relacionados con la plaza.
AltaPlaza(self,page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura y los espacios donde se capturarán
los datos de la plaza que tendrá el nuevo profesor.
AltaEntAdm(self,page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura y los espacios donde se capturarán
los datos de la entidad administrativa que tendrá el nuevo profesor.
PROYECTO TERMINA4 13
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
AltaProf(self,page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura y los espacios donde se capturarán
los datos del profesor.
alta(self) Método que se encarga de hacer el trámite con la clase EjecutaSQL
para dar de alta al profesor en su nueva plaza.
error(self,cadenas) Método que controla el flujo de errores en todo el proceso de
dar de alta a un profesor.
Reglas de negocio: Se permiten modificar todos los campos excepto los
indicados en los métodos, no se permiten entradas nulas.
Clase Consultar: Su función es la de presentar al usuario información
asociada con la plaza seleccionada que aparece en la pantalla principal, la cual
enlaza con todas las tablas en la base de datos, esta clase solo tiene opción de
solo lectura en las tablas antes mencionadas de tal manera que no pueden ser
modificadas, esta clase deshabilita los cuadros de entrada impidiendo al usuario
editar información.
Figura 7. PROYECTO TERMINAL 14
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
Clase Eliminar: Su función es la de presentar al usuario información asociada
con la plaza seleccionada para eliminar que aparece en la pantalla principal la cual
enlaza con todas las tablas en la base de datos, esta clase tiene opción de lectura
en las tablas antes mencionadas de tal manera que no puede modificarlas y de
escritura en la tabla de THisfProfPza en el campo de fecha de renuncia asociando
la fecha de eliminación del profesor, esta clase deshabilita los cuadros de entrada
impidiendo al usuario editar información excepto para el campo de fecha de
eliminación (Renuncia). Hace llamada también al método de validación validate de
tal manera que esta fecha sea no nula presentando en pantalla mensajes de error.
Figura 8.
Principales métodos de la clase eliminar:
notebook(self, valor) Método que se encarga de crear los tabs en cuales se
muestra la información asociada a la Clave de plaza que aparece en la pantalla
principal, recibe como parámetro la opción para crear el tab de baja o consulta.
PROYECTO TERMINAL 15
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
Bajaprofesor (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura que esta asociada entre el profesor y
la plaza que se seleccionó en el listbox de la pantalla principal.
BajaPlaza (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura de la plaza que se seleccionó en el
listbox de la pantalla principal, activando solo el campo de edición de la fecha de
eliminación.
ConsPlaza (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura de la plaza que se seleccionó en el
listbox de la pantalla principal.
BajaEntAdm (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de solo lectura que esta asociada entre el la entidad
administrativa y la plaza que se seleccionó en el listbox de la pantalla principal.
Reglas de negocio: Solo es válido modificar la fecha de eliminación no
permitiendo entradas nulas el resto de los campos es de solo lectura para el
usuario.
Clase Modificar: Su función es la de presentar al usuario información asociada
con la plaza seleccionada para modificar, que aparece en la pantalla principal, la
cual enlaza con todas las tablas en la base de datos, esta clase tiene opción de
lectura y escritura en las tablas antes mencionadas. Hace llamada también al
método de validación validate para validar los datos de entrada.
Principales métodos de la clase Modificar:
notebook(self, valor) Método que se encarga de crear los tabs en cuales se
muestra la información asociada a la Clave de plaza que aparece en la pantalla
principal, recibe como parámetro la opción para crear el tab de cambios.
PROYECTO TERMINAL 16
PROGRAM DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
CambioProfesor (self, page) Método que se encarga de presentar en el tab (en
el parámetro page) información de lectura y escritura que está asociada entre el
profesor y la plaza que se seleccionó en el listbox de la pantalla principal, no se
pueden cambiar los campos Número de empleado, Nombre completo, RFC, Fecha
de nacimiento, Sexo.
CambioPlaza (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de lectura y escritura de la plaza que se seleccionó
en el listbox de la pantalla principal, no se pueden cambiar los campos Número de
plaza, Fecha de registro.
Figura 9.
PROYECTO TERMINAL 17
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
CambioEntAdm (self, page) Método que se encarga de presentar en el tab (en el
parámetro page) información de lectura y escritura que esta asociada entre el la
entidad administrativa y la plaza que se seleccionó en el listbox de la pantalla
principal.
Reglas de negocio: Se permiten modificar todos los campos excepto los indicados en los métodos, no se permiten entradas nulas.
6.- Consideraciones de lenguaje
Archivos de instalación necesarios para programar en Python:
Python ver. 1.51 (Interprete)
Tkinter 8.0 (Entorno gráfico)
Win32all (Conexión ODBC, Editor Pythonwin)
Contribución PWM 0.7
Editor para crear el archivo fuente(script) con extensión nomarch.py
Python es un lenguaje de programación multiplataforma orientado a objetos,
de distribución libre disponible en http://www.python.orq para nuestro caso se
implanto el sistema en ambiente Windows, el lenguaje presenta diversas
limitaciones tales como:
Para usar el ambiente gráfico se necesita instalar un archivo llamado
Tkinter ver. 8.0, el cual cuenta con clases y funciones útiles para manipular el
ambiente gráfico para la creación de botones, cuadros de entrada, listbox,
etiquetas, etc.
Para manipulación de otros objetos corno combobox y folders se utilizó una
contribución llamada PMW ver 0.7 obtenida de internet ya que la simple utilización
de Tkinter no cuenta con ellos. Esta contribución se debe instalar en el
subdirectorio de Python ya que de otra forma ocurrirá un error al momento de
PROYECTO TERMINAL 18
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
ejecutar los scripts que utilicen sus funciones y objetos debido a que no encuentra
la ruta para utilizarlos.
Para bases de datos hechas en Access se debe contar con el driver que
soporta transferencia de datos de 32 bits ya que la conexión por medio de ODBC
no soporta la de 16 bits, la contribución utilizada para conexión a las bases de
datos es Win32all.
Por ser un lenguaje vanguardista existe poca literatura disponible, y la que
hay se encuentra dispersa en internet tanto en la dirección web antes citada así
como en http://www.pythonware.com donde hay documentación como: "An
Introduction to Tkinter" que proporcionan una idea de la manipulación del entorno
gráfico de Python. Así como otra documentación que ilustra todos los métodos y
opciones válidas de cada uno de los objetos.
En Python no se declaran variables, solo basta asignar a un valor a una
variable para crearla.
Todos los códigos fuente se deben ejecutar por línea de comando ya que el
interprete funciona solo bajo ambiente DOS, en otro caso se puede ejecutar desde
el explorador de Windows haciendo doble clic en el script que se desea ejecutar.
No se cuenta con una herramienta de depuración para visualizar y
monitorear las variables, el interprete solo muestra mensajes de error en ambiente
DOS.
Es muy importante la indentación para programar en Python ya que el
interprete se basa en ello para detectar donde inicia o termina una función, así
como los ciclos de control e iteración (if, else, while, for), clases, etc.
La conexión a la base de datos para transferencia de datos es lenta para
PC's con menos de 32 megabytes de memoria RAM aunque cabe citar que para PROYECTO TERMINA4 19
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚSLICO
maquinas con menor capacidad la manipulación se realizó de manera efectiva con
pocos registros en la base de datos.
En Python no es posible implantar directamente un DBgrid ya que no se
cuenta con esta clase disponible en la biblioteca Tkinter o Python Mega
Widgets(PMW), debe implantarse por medio de un listbox e introduciendo la
información insertando espacios en las tuplas triadas en los accesos a la base de
datos.
En Python no se encuentran disponibles funciones para obtener los
códigos de error de la Base de datos que son mandados por la conexión de
OOBC, P.e. cuando se insertan dos registros con la misma llave primaria.
La contribución PMW cuenta con una clase llamada Enfryfjeld la cual entre
sus propiedades tiene la de validar información capturada por el usuario
modificando su color de fondo al color que el programador le asigne cuando ocurra
un error de entrada.
7.- Conclusiones
Python es una poderosa herramienta de desarrollo, pero debido a que es un
lenguaje de programación vanguardista se encuentra poca documentación
disponible y la existente se encuentra dispersa por internet, además es una
herramienta freeware aunque las contribuciones si tienen un costo para
adquirirlas, el costo de estas y de la literatura se cotiza en dólares por lo que es
difícil contar con ellos al momento de desarrollar software.
Fue de gran valía para la aplicación de los diversos módulos la utilización de la
contribución PMW ver. 0.7 (Python Mega Widgets) ya que cuenta con clases y
métodos que aportaron gran ayuda para la implantación del sistema.
PROYECTO TERMINAL 20
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
En cuanto al metodo utilizado de la división de trabajo para el análisis, diseño
e implementación del proyecto sirvió mucho ya que se realizo una simulación de
cómo se trabaja en un ambiente real para la implementación de sistemas grandes.
Cabe hacer mencion que la metodología orientada a objetos fue de gran
ayuda para plantear desde otro punto de vista la ingeniería de software ya que
esta metodología se acerca mas a lo que un usuario desea obtener como producto
final ya que en todo momento éI participa en decisiones trascendentes para el
diseño de la aplicación.
Basta solo agradecer a los profesores: Ing. Luis Fernando Castro Careaga y
a M.C. Ornar Lucio Cabrera Jimbnez por los conocimientos, experiencia y
recomendaciones aportados para la realización de este proyecto
PROYECTO TERMINAL 21
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
ANEXO I
La literatura existente de Phyton para el manejo de bases de datos fue casi
nula en el momento del desarrollo, después de buscar y preguntar por Internet se
logra conseguir la forma de cómo Phyton accesa a las bases de datos, en nuestro
caso Access, a continuación se muestra le código para el manejo de base de
datos:
from Tkinter import * import dbi, odbc "" > librerías necesarias para el manejo del ODBC.
importar módulos dbi y ODBC
def consulta (SQL) :
dbc=odbc . odbc ( DCBI cur=dbc.cursor() cur.execute(SQL)
res=cur. fetchall ( ) dbc. commit ( ) cur = None dbc = None return res
--> Este método ejecuta la sentencia SQL recibida como parámetro.
datos fuente de datos/usuario/password' - BD/admin/admin') -> abrir una conexión a una base de
--> crea un cursor --> ejecuta la sentencia SQL que recibe
--> enviar consulta a res. --> ejecuta las operaciones anteriores. --> elimina el cursor. --> elimina la conexión. --> regresa la consulta en res.
como parámetro.
Donde consulta recibe como parámetro la sentencia SQL :
res=consulta("SELECT IdProf FROM TProfesor WHERE(situacion = O ) " )
En la línea cur.execute(SQL) en los paréntesis es donde se coloca la sentencia
SQL por ejemplo:
cur. execute ("UPDATE TProfesor SET Nac=' "+nacionalidad+"' WHERE (TProfesor. IdProf="+claveprof+") " )
Cons="INSERT INTO THistProfPza (IdProf, CvePza, estatus)
cur. execute (Cons) VALUES ( ' "+claveprof+" I , ' "+clavepza+" , ' 1 ' ) I'
PROYECTO TERMINAL 23
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
Anexo II
El editor principal que se describió en todo el documento se auxilia de
cuatro editores secundarios (editor de categoría, tipo de plaza, nivel y tiempo de
dedicación), la estructura de dichos editores es la misma por lo cual solo explicaremos uno de ellos:
#editor (Cateporia) ver 1 .O # Hecho por Johony Céspedes Murillo y Juan Enrique Mindez Torres
from minter import * ## libredas para el modo gráfico fiom Dialog import Dialog from ScrolledText import ScrolledText impolt dbi, odbc ## librerías para el manejo de base de datos an, el ODBC impolt string
class Ventana(Frame): ## clase que nos muestra la ventana principal y llama a las demas clases def -init_(self, parent=None): ## se crea el tiame (la forma) principal
Frame.-init-(self, parent) selfpadc(expand=YES,fill=BOTH) ## se cierra el frame principal con propiedades de expansión y de llenado seIf.createWidgets() ## llamada a createwidgets
def createWidgds(se1f): ## en este objao se crea la ventana principal y se hacen las primeras sentencias dbc = odbc.odbc('DCB1-BDladminIadmin') ## cm SQL las cuales están explicadas detalladamente en el ANEXO I. ax = dbc.cursor() cur.execute("SELECT idCT , desCT FROM TCategPza") scroll = Scrollbar(self) res = cur.fetchall() 1st = Listbox(self,yscrollconnnand=scroll.set) ## se crea un apuntador a Listbox(), la cual es un objeio de'lkl'kinter i = o print ?.a consuha es:' ## se muestra la consulta que se tiene en res en el Listbox() for r in res: print ' ', res[i] Ist.insett(END, res[¡]) i = i+l
Ist.config(relief=SLJNKEN) Label(self,t~te.d='Descripción',font=('",7,
"bold"),width=20).pack(side=TOP,expand=YES,anchox=S W,padx=O,pady==3)
l s t . p a ~ s i d e = L E F T , e x p a n d = Y E S , f i l l = B O T H , = 3 )
scroll.confip(relief=SUNKEN,command=l~.~iew) scroll.pack(side=LEFT,fill=BOTH,padx=l,pady=3)
Botones=Frame(self) ## se asigna un espacio en la pantalla principal para colocar los botones Altas, Bajas, &c. Botones.pa&(side=RIOHT)
Button(Botone~text-"Agregar",underl~~O,widt=15,command=self.agregar).pack(side=TOP,an~o~E,padxllO,pad~3) ## se crea un &on para Botones, el texto que tendrá el b o t h , tiene subrayada la primera letra, su ancho, cuando se presione este ## botón se llamara a el objeto agregar. Button(Botonesfext="M~ificar" ,und~l~~,wi~=15,~~tnmand=self .n1odi~~r) .pa~(side=TOP,anch~E,padx~1O.pady=3) But ton(Botonesfext="El imin~" ,und~l~~O,wi~=15 ,command=self .e l i~ar ) .pack(s ide ;TOP,~~~E,pad~=1~,p~~yl3) Button(Botones,text="Consu~r",~d~l~~O,w~~=l5,command=selfconsultar).padc(sideTOP,anch~E,padx=1O,pady= 3) B~on(Boton~text="Salir",underl~e~O,wi~=15,command=self.salu).pack(sideTOP,ancho~E,padx=1O,pady= 3) B~on(Boton~text="Ayu~' ,underl~e=l ,widt=l5 ,command=sel f .a~~da) .padc(s ide~TOP,an~o~E,padx~lO,pad~~)
1st.foCuS~Sey)
&f ayuda(self): help= Ayuda() help.t¡tle(";\yuda")
PROYECTO TERMINAL 24
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
def agregar(se1f): ## se hace una llamada a la clase ventanal para utilizar un objeto de esta cdialogo= Ventanal() cdialogo.title("Agregar") cdialogo.trae-texto("AgFegar")
def modificar(se1f): ## se hace una llamada a la clase ventanal para utilizar un objdo de esta dialogo= Ventana 1() cdialogo.titl~"Modificar") dialogo.trae_te;uto("M~ilicar")
def consultarfself): ## se hace una llamada a la clase ventana2 para utilizar un objdo de esta cdialogo= Ventana20 cdialogo.title("Consultar") cdialogo.objetos("Consulta")
def eliminar(se1f): ## se hace una llamada a la clase ventana2 para utilizar un objeto de esta cdialogo= Ventana20 cdialogo.title("Etiminar") cdialogo.objetos("Elimina")
def salir(se1f): Ventana.qu~self) ## el objeto salir elimina la ventana principal
class Ventanal(Topleve1): ## en esta clase se agregan y se modifican datos de latabla
def -init.-(se\f, parent=None): T o p l e v e l . ~ i n i t ~ ( s e l ~ parent)
deftrae-texto(self,opcion): ## &e objeto nos muestra el paso de paremetros el cual trae en la variable opcion self.objetos(opcion)
def objetos(self,opcion): Etiq=Frame(self) ## se crea una etiqueta Etiq.pack(side=LEFT,expand=YES) ## propiedades de la etiqueta Iabel(Etiq,text='Clave : ',underline=O).pack(sid~~TOP, anchor=E,pady= 5) Label(Etiqfext='Descripción : ',underlinecO).pack(side=TOP. anchor=E, p a d y 10) =dl= StringVa<) ## se captura lo que se esaibe en cada una de las etiquetas cad2= StringVar() Ent=Frame(self,bd=2) Ent.pack(side=LEFf) Entry(Entfextvariablr=cadl,~idth=25).pack(sid~TOP,elgand=YES,pady= 10) Entry(Errtfextvariable=od2,width=2~).pa~(s~d~TOP,e~~d=YES,pady= 10) opciones=('Agregar': selEinserta, 'Modificar': selfactualiza) variable = opcim
frm= FramNself) fim.config(bd=2) fim.pack(side=LEFT) Button(fimtextxt="Aoeptar",width=lO,command=lambda x=cadl,y==cad2,s=opciones,
B ~ o n ( f i m t e l b = ' S a l i r ' , w i d t h = l 0 , ~ ~ ~ d = s e l ~ s a l i r ) . p a c k ( s i d ~ T O P , a n ~ o ~ E , p a d ~ l 0 , pady=3) var-variable:s[var](x.get(),y.get())).pack(side=TOP, an&or=E,padx=lO,pady=5)
def actualiza(self,cadl,cad2): ## en esle objeto se actualiza en la base de datos print "Clave: ",cad1 print "Description: ",cad2 dbc=odbc.odbc('DCBI-BD/adminiadmin') cur=dbc.cursor() cur.executz("UPDATE TCategPza SET idCT="' + cad1 + "'.desCT="' + cad2 +"I WHERE idCT="' + cad1 + "' ")
dbc.conunit() cur.execute("SELECT * FROM TCategPza") res=cur.fetchall() ¡=O for r in res:
print' ',res[i] i= i t 1
cur = None dbc = None
PROYECTO TERMINAL 25
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
def inserta(self,cadl,cad2): ## en este objeto se insertan datos a la base de datos print "Clave: ",cad1 print "Desmipcion: ",cad2 dbc=odbc.odbc('DCBI_BD/admin/admin') cur=dbc.cursor() Cons = "INSERT I N T O TCategPza (idCT,dssCT) VALUES ("'+cadl+"',"'+cad2+"')" cur.execute(Cons) dbc.commit() cur.execute("SEL,ECT * FROM TCategPza") res=cur.f&chall() i=O for r in res: ## se actualiza la ventana con el dato insertado
print' ',res[i] i = i+l
cur = None dbc = None
def salir(se1í): Ventanal .destroy(self)
class VentanaZ(Topleve1): ## en esta clase se consulta y se eliminan los datos solicitados
def -init-(self, parent=None): Toplevel.-init-(self, parent)
def objetos(self,opcion): Etiq=Frame(self) Etiq.pack(sideLEFT,expand=YES) Label(Etiq.text='Clave : ',underlineO).pack(side=TOP, anchor=E.pady= 5) =dl= StringVarO Ent=Frame(self,bd=2) Ent.pack(side=LEFT) Entry(Ent,te~variable=odl,width=25).pa~(sid~TOP,expand=~S,pad~ 10) opciones=('Elimina': self.elimina, 'Consulta': self.consulta) variable = opcion Botones=Frame(self) Botones.pack(side=LEFT) Butlon(Botones, text = "Aceptar",width= 10, command = lambda x=cadl,s=opciones,var =
Button(Botones, text = "Salir",width= 10, command = self.salir).pack(side=TOP, anchor=E,padx=lO, pady3) variable:s~var](x.get())).pack(side==TOP, an&or=E,padx-lO.pady=5)
def elimina(self,cadl): ## objeto para eliminar el dato de la tabla print "Clave: ",cad1 dbc=odbc.odbc('DCBI_BD/adminiadmin') cur=dbc.cursor() cur.execute("DELETE FROM TCategPza WHERE (idCT = "'+cadi+"')") dbc.commit() cur.execute("SELECT * FROM TCategPza") res=cur.fetchall() i=o for r in res:
print' '.res[i] i= i+l
w r = None dbc = None
def amsulta(sclf,cadl): ## objeio que hace una consulta print "Clave: ",cad1 dbc=odbc.odbc('DCBl-BD/adminladmin') cur=dbc.cursor() cur.execute("SELECT * FROM TCategPza WHERE (idCT = "'+cadi+"')") res=cur.fet&all() dbc.commit() i=O VentanaZ.res=res for r in res:
print' ',res[i] I= i+l
Lwr = None dhc = None
PROYECTO TERMINAL 26
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚSLICO
def salir(self): Ventana2.&roy(self)
dass Mufftra(Topleve1):
def -init-(self,parent=None): Toplevel.-init-(self,parent) selECuadro() selfBoton()
def Cuadro(se1t): datos=ScrolledTe~sel~~hei~t':l5,'width':4O~Pack:{~~)
X verificar la nrta del archivo de ayuda
datos.insert('O.O',V~tanaZ.r~s) ###topen('a:\Ayuda.txt','r').r~ad() )
def Boton(se1f): B u t t o n ( s e l f , t e ~ = ' S a l u ' . u n d e r l i n e ; - 0 , c o l O , pady3)
def salir(seif): Ayuda.destroy(selt)
class Ayuda(Topleve1):
def -init-(self,parent=None): Toplevel.-hit-(selfparent) selEAuxilio() self.Boton()
def Auxilio(se1f): datos=ScrolledText(self,(height': 1 5,'width':4O,Pack: { 1)
# verificar la ruta del archivo de ayuda
d a t o s . m ~ O . O ' , o p e n ( ' a : \ A y u ~ . t ~ ' , ' r ' ) . r ~ ~ ) )
dcf Bdon(se1f): Buttan(self,te~~'Salir',und~lm~O,command=self.salir,width=l5).pack@adx=lO, pady=3)
def saliflself): .4yu&.destroy(self)
test=Ventana() X# termination del programa test.rnaster.title("Categoria") ## el titulo es Categoria test.rnainloop()
PROYECTO TERMINAL 27
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚSLICO
Anexo 111
Requisitos del sistema
Para usar el Editor de plazas para Windows se necesita:
El disco que contenga el archivo EditPza.py y BDPlazal .mdb.
Una computadora PSI2 o compatible (se puede usar una Mac).
Por lo menos 16 megabytes memoria de acceso aleatorio (RAM) se
recomiendan 32 Mb.
Mouse.
Windows 95 o 98.
Python 1 S .
TCL 8.0.
Win32.com.
PMW 0.7 (Python megawidgets).
Manejador de ODBC instalado.
Instalación
Para poder instalar Python 1.5 solo necesitamos bajar el programa
autoextraible python1 5.exe de Internet de http:/ /w.pvthon.oq lo mismo pasa
con el TCL (tcl80.exe) y el Win32, el PMW se puede encontrar en
http://www.pvthonware.com todos son shareware, se debe procurar instalar todos
los componentes en un mismo directorio para evitar tener que configurar las rutas
de todos los componentes.
PROYECTO TERMINAL 28
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PUBLICO
El TCLJTk nos ayuda en la creación de Labels, Buttons, Listboxes, Entries,
Menus, etc.
El Win32 nos facilita el manejo de ventanas y el accionar con windows.
El PMW {Python Megawidgets) es una gran aportación al manejo de
interfaz gráfica, sin ella no se hubieran podido realizar muchas de las ventanas
utilizadas en este programa.
Para el manejo de bases de datos se necesita el manejador de ODBC el
cual debe de estar instalado, para poder usar nuestra base de datos necesitamos
darnos de alta en el administrador de base de datos (ODBC), el procedimiento que
se debe seguir es el siguiente:
Haga clic en el botón de Inicio, elija Configuración, Panel de control, haga
doble clic en 32bit ODBC, haga clic en el botón Add, seleccione el driver para el
manejador de nuestra base de datos (en nuestro caso Microsoft Excel driver),
haga clic en finalizar, introducir el nombre de la base de datos (el cual se manejara
en el programa para accesar a la base de datos en nuestro caso DCBI-BD) y un
clic en OK, ahora seleccionamos nuestra acceso a la base de datos que
acabamos de crear de la lista, damos un clic a Configure y seleccionamos la base
de datos que vamos a utilizar y su ruta de acceso (en nuestro caso
BDPlazal .mbd), hacemos un clic en el botón Advanced para introducir el Login
Name y el password (en nuestro caso admin, admin), hacemos un clic en OK y un
clic en Aceptar, con lo cual ya estamos listos para usar el programa y la base de
datos.
Como iniciar el editor de plazas
Después de haber instalado Python y todos sus componentes, se puede iniciar la aplicación.
PROYECTO TERMINAL 29
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PúBLICO
Para iniciar el editor solo necesitamos hacer doble clic en el icono del
archivo en el explorador de Windows o en una ventana de DOS y teclear:
python nomarch.py .
Una vez en el programa, lo primero que se muestra es la pantalla principal
en la cual tenemos un Combo Box, un List Box y los botones (Agregar, Eliminar,
etc.), en el Combo Box podemos elegir entre plaza determinada e indeterminada
con lo cual nos muestra la lista de las plazas disponibles (determinada o
indeterminada), una vez que elegimos una de ellas podemos realizar las
operaciones que necesitemos:
Agregar.- AI hacer un clic en Agregar se nos muestra una pantalla con las
plazas disponibles, al elegir una de estas y hacer un clic en Aceptar se muestra la
pantalla de Captura de datos del dictamen, en la cual se piden los datos del
Profesor, la Plaza y de la Entidad Administrativa, al introducir todos los datos
solicitados y hacer un clic en Aceptar se guardan los datos en la base de datos y
se regresa a la ventana anterior, para poder seguir dando de alta a más
profesores si se quiere salir de altas solo haga un clic en Cancelar para regresar a
la ventana principal.
Eliminar.- AI hacer un clic en Eliminar se nos muestra una pantalla con los datos relacionados con la plaza elegida, no se permite capturar datos, si se hace
un clic en Aceptar se muestra un mensaje de confirmación de ta eliminación si se
hace clic en Aceptar se eliminan los datos relacionados con la plaza seleccionada.
Modificar.- AI hacer un clic en el botón Modificar se nos muestran los datos
relacionados con la plaza elegida, la mayoría de estos datos pueden ser
modificados pero no todos, si hacemos clic en Aceptar se modificaran los datos
actualizando la base de datos y se regresa a la pantalla principal.
Consultar.- Al hacer un clic en el botón Consultar se nos muestran los datos
relacionados con la plaza elegida, para salir haga un clic en Cancelar,
PROYECTO TERMINAL 30
PROGRAMA DE PROYECTOS TERMINALES EN INSTITUCIONES DEL SECTOR PÚBLICO
Recontratar.- AI hacer un clic en el botón Recontratar se nos muestra una
pantalla con las plazas disponibles, al elegir una de ellas y hacer un clic en
Aceptar se muestra una lista de identificadores de profesores, al elegir uno de
ellos y hacer un clic en Aceptar se muestran los datos que tenia anteriormente el
profesor con este identificador que nunca cambia, la mayoría de estos datos se
pueden modificar, al hacer clic en Aceptar se modifican y actualizan los datos en la
base de datos.
Salir.- AI hacer un clic en Salir se muestra un mensaje de confirmacih si se
hace un clic en Aceptar se sale del programa.
PROYECTO TERMINAL 31