ciencias basicas e ingeniería - 148.206.53.84148.206.53.84/tesiuami/uam0952.pdf · un use case es...

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


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


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


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


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


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.



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


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


los datos de la entidad administrativa que tendrá el nuevo profesor.

PROYECTO TERMINA4 13


AltaProf(self,page) Método que se encarga de presentar en el tab (en el


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


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.



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.


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.



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



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


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.



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



ANEXOS



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'



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")



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



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



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()



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.



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.



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,



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.


ciencias basicas e ingeniería - 148.206.53.84148.206.53.84/tesiuami/uam0952.pdf · un use case es...

Documents