herramienta cake: computer aided...
Post on 21-Sep-2018
218 Views
Preview:
TRANSCRIPT
HERRAMIENTA CAKE: COMPUTER
AIDED KNOWLEDGE ENGINEERING
TRABAJO PROFESIONAL EN INGENIERÍA EN
INFORMÁTICA
Laboratorio de Sistemas Inteligentes
Facultad de Ingeniería
Universidad de Buenos Aires
Alumnos: Pablo Ezequiel BRAGAN
Luciano HAMMOE
Mariano Ezequiel KFURI
Directores: Prof. Dr. Ramón GARCIA MARTINEZ
Prof. M. Ing. Hernán MERLINO
Prof. M. Ing. Enrique FERNANDEZ
Prof. Dra. Paola BRITOS
Noviembre 2009
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 3
Resumen
En el ámbito académico, el desarrollo de sistemas basados en conocimientos, carecía de una herramienta que permitiera integrar las diferentes fases de la metodología IDEAL. CAKE es una herramienta de gestión para la documentación y desarrollo de sistemas basados en conocimientos aplicando la metodología IDEAL. Dentro de la metodología IDEAL, CAKE se centra en las dos primeras fases y, de cada una de estas, brinda herramientas para la documentación de las mismas. Se entiende por primera fase a la identificación de la tarea, abarcando solo el test de viabilidad. Por segunda fase se entiende al desarrollo de los prototipos, dando soporte a la adquisición y conceptualización de los conocimientos. En esta fase CAKE abarca el conocimiento estático y el dinámico. Por conocimiento estático se entiende al conocimiento fáctico representado por el diccionario de conceptos y la tabla concepto atributo valor, al conocimiento estratégico representado por el árbol de descomposición funcional, y al conocimiento táctico representado por la tabla de decisión y las pseudoreglas. Por último, CAKE implementa al árbol Jerárquico y al mapa de conocimiento que representan al conocimiento dinámico.
Abstract
In the academic environment, the development of knowledge-based systems did not have a tool that may allow the integration of different phases of the IDEAL methodology. CAKE is a management tool for the documentation and development of knowledge-based systems applying the IDEAL methodology. Within the IDEAL methodology, CAKE focuses on the first two phases and, from each one of these ones, provides tools for their documentation. First phase means the task identification, only covering the viability test. Second phase means the development of prototypes, providing support for the knowledge acquisition and conceptualization. In this phase, CAKE covers the static and dynamic knowledge. Static knowledge means the factual knowledge represented by the dictionary of concepts and the attribute - value concept table, the strategic knowledge represented by the functional separation tree and the tactical knowledge represented by the decision table and the pseudo-rules. Lastly, CAKE implements the Hierarchical tree and the knowledge map that represent the dynamic knowledge.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 4
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 5
Índice
Resumen............................................................................................................................................................................. 3 Abstract .............................................................................................................................................................................. 3 1. Informe Técnico. ............................................................................................................................................. 8 1.1. Resumen.......................................................................................................................................................... 8 1.2. Introducción.................................................................................................................................................... 8 1.3. Arquitectura CAKE. ....................................................................................................................................... 9 1.4. Python. .......................................................................................................................................................... 11 1.5. Django. .......................................................................................................................................................... 12 1.6. Google AppEngine. ...................................................................................................................................... 13 1.7. JQuery y Dojo. .............................................................................................................................................. 15 1.8. Soluciones y Mejoras. ................................................................................................................................... 16 1.9. Subida de Aplicación y Mantenimiento. ..................................................................................................... 23 1.10. Repositorio CAKE......................................................................................................................................... 30 1.10.1. Subida de Datos. ........................................................................................................................................... 30 1.10.2. Tutorial subida de datos............................................................................................................................... 31 1.10.3. Instalación de Sqlite (Recomendada)........................................................................................................... 31 1.10.4. Creación de Clase Loader............................................................................................................................. 32 1.10.5. Preparación de Datos.................................................................................................................................... 34 1.10.6. Subida de Datos a AppEngine. .................................................................................................................... 35 1.10.7. Subida de Datos al servidor de Desarrollo. ................................................................................................. 35 1.10.8. Argumentos de la Línea de Comandos. ...................................................................................................... 35 2. Manual de Usuario. ...................................................................................................................................... 38 2.1 ¿Qué es CAKE? ............................................................................................................................................. 38 2.2 Requisitos del Sistema. ................................................................................................................................. 38 2.3 ¿Nuevo en el Sistema? ¿Cómo registrarse? ................................................................................................. 39 2.4 ¿Qué Roles existen y qué funcionalidades pueden hacer? ......................................................................... 41 2.5 Gestión de Grupos ........................................................................................................................................ 42 2.5.1 ¿Qué es un Grupo? ....................................................................................................................................... 42 2.5.2 ¿Quién lo administra y quien puede formar parte del mismo?.................................................................. 42 2.5.3 ¿Qué compone a un grupo? ......................................................................................................................... 42 2.5.4 ¿Qué funcionalidades puede hacer? ............................................................................................................ 42 2.5.5 ¿Cómo crear un grupo? ................................................................................................................................ 43 2.5.6 ¿Cómo accedo a un Grupo en el cual soy integrante? ............................................................................... 44 2.5.7 ¿Cómo Modificar un Grupo? ....................................................................................................................... 44 2.5.8 ¿Cómo Eliminar un Grupo? ......................................................................................................................... 45 2.5.9 ¿Cómo asignar a un usuario al Grupo? ....................................................................................................... 46 2.5.10 ¿Cómo me uno a un Grupo? ........................................................................................................................ 47 2.5.11 ¿Cómo abandono un grupo de trabajo?....................................................................................................... 49 2.5.12 ¿Qué es un proyecto?.................................................................................................................................... 51 2.5.13 ¿Quiénes tienen permisos y que tipo de permisos? .................................................................................... 51 2.5.14 ¿Qué compone a un proyecto? ..................................................................................................................... 51 2.5.15 ¿Cómo se crea un proyecto?......................................................................................................................... 51 2.5.16 ¿Cómo accedo a un Proyecto?..................................................................................................................... 52 2.5.17 ¿Cómo se modifica un proyecto? ................................................................................................................. 52 2.5.18 ¿Cómo se elimina a un proyecto? ................................................................................................................ 53 2.6 Gestión de Peticiones de Grupo................................................................................................................... 55 2.6.1 ¿Qué es una petición de grupo?................................................................................................................... 55 2.6.2 ¿Quién puede realizar una petición de grupo y cómo? .............................................................................. 55 2.6.3 ¿Quién la puede eliminar y cómo? .............................................................................................................. 56
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 6
2.6.4 ¿Quién puede aceptarla y cómo? ................................................................................................................. 56 2.6.5 ¿Quién puede rechazarla y cómo? ............................................................................................................... 57 2.7 Gestión de Ayuda Online............................................................................................................................. 59 2.7.1 ¿Qué es la ayuda Online? ............................................................................................................................. 59 2.7.2 ¿Quién puede consultarla y cómo?.............................................................................................................. 59 2.8 Administración. ............................................................................................................................................ 60 2.8.1 Administración de Usuario .......................................................................................................................... 60 2.9 Test de Viabilidad......................................................................................................................................... 61 2.9.1 ¿Cómo registro un Test de Viabilidad? ....................................................................................................... 61 2.9.2 ¿Cómo modifico un Test de Viabilidad? ..................................................................................................... 62 2.9.3 ¿Cómo elimino un Test de Viabilidad?........................................................................................................ 63 2.9.4 ¿Cómo accedo a un Test de Viabilidad? ...................................................................................................... 63 2.9.5 ¿Cómo registrar conclusiones?..................................................................................................................... 65 2.9.6 ¿Cómo cerrar un Test de Viabilidad? .......................................................................................................... 66 2.9.7 ¿Cómo abro un Test de Viabilidad?............................................................................................................. 67 2.9.8 ¿Cómo generar el informe del Test en formato PDF? ................................................................................. 67 2.10 Conocimiento Estático.................................................................................................................................. 69 2.10.1 ¿Qué compone al Conocimiento Estático?................................................................................................... 69 2.10.2 ¿Cómo registro un Conocimiento Estático? ................................................................................................ 69 2.10.3 ¿Cómo accedo al Conocimiento Estático? ................................................................................................... 69 2.10.4 ¿Cómo registro el Diccionario de Conceptos?............................................................................................. 70 2.10.5 ¿Qué compone al Diccionario de Conceptos? ............................................................................................. 71 2.10.6 ¿Cómo accedo al Diccionario de Conceptos? .............................................................................................. 71 2.10.7 ¿Cómo visualizo el diccionario de conceptos en formato PDF?................................................................. 72 2.10.8 ¿Cómo accedo a la TCAV? ........................................................................................................................... 72 2.10.9 ¿Cómo visualizo la TCAV en formato PDF? ............................................................................................... 72 2.10.10 ¿Cómo registro un Concepto? ...................................................................................................................... 73 2.10.11 ¿Cómo modifico un Concepto? .................................................................................................................... 74 2.10.12 ¿Cómo elimino un Concepto? ...................................................................................................................... 75 2.10.13 ¿Cómo registro un Atributo? ....................................................................................................................... 76 2.10.14 ¿Cómo modifico un Atributo? ..................................................................................................................... 78 2.10.15 ¿Cómo elimino un Atributo?........................................................................................................................ 79 2.10.16 ¿Cómo registro un Valor de un Atributo?................................................................................................... 80 2.10.17 ¿Cómo modifico un Valor de un Atributo? ................................................................................................. 81 2.10.18 ¿Cómo elimino un Valor de un Atributo? ................................................................................................... 82 2.10.19 ¿Cómo registro a una Regla?........................................................................................................................ 83 2.10.20 ¿Cómo modifico a una Regla?...................................................................................................................... 85 2.10.21 ¿Cómo elimino a una Regla? ........................................................................................................................ 86 2.10.22 ¿Cómo accedo a la Tabla de Decisión? ........................................................................................................ 86 2.10.23 ¿Cómo visualizo la Tabla de Decisión en formato PDF? ............................................................................ 87 2.10.24 ¿Cómo accedo a las Pseudoreglas? .............................................................................................................. 87 2.10.25 ¿Cómo visualizo las Pseudoreglas en formato PDF? .................................................................................. 88 2.10.26 ¿Cómo registro al Árbol de Descomposición Funcional? ........................................................................... 88 2.10.27 ¿Cómo registro un nodo para el Árbol de Descomposición Funcional? .................................................... 89 2.10.28 ¿Cómo visualizo al Árbol de Descomposición Funcional?......................................................................... 90 2.10.29 ¿Cómo elimino o modifico un nodo para el Árbol de Descomposición Funcional? ................................. 92 2.11 Conocimiento Dinámico............................................................................................................................... 93 2.11.1 ¿Qué compone al Conocimiento Dinámico?................................................................................................ 93 2.11.2 ¿Cómo registro un Conocimiento Dinámico? ............................................................................................. 93 2.11.3 ¿Cómo accedo al Conocimiento Dinámico? ................................................................................................ 93 2.11.4 ¿Cómo registro el Árbol de Estrategias? ..................................................................................................... 94 2.11.5 ¿Cómo visualizo el Árbol Jerárquico? ......................................................................................................... 95 2.11.6 ¿Cómo visualizo al Árbol Jerárquico en formato PDF? .............................................................................. 96 2.11.7 ¿Cómo elimino o modifico una entrada, razonamiento o salida en un nodo del Árbol Jerárquico?........ 97
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 7
2.11.8 ¿Cómo registro nodos para el Mapa de Conocimientos? ........................................................................... 97 2.11.9 ¿Cómo visualizo el Mapa de Conocimientos?............................................................................................. 98 2.11.10 ¿Cómo visualizo Mapa de Conocimientos en formato PDF? ..................................................................... 99 3. Dominio del Problema. Caso de Estudio................................................................................................... 100 4. ANEXO I ..................................................................................................................................................... 113 4.1.1 Propuesta presentada ................................................................................................................................. 113 5. ANEXO II .................................................................................................................................................... 124 5.1 Casos de Usos ............................................................................................................................................. 124 5.1.1 Diagramas de Dominio............................................................................................................................... 130 5.1.2 Implementación de SessionContext ........................................................................................................... 134 6. Referencias .................................................................................................................................................. 139
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 8
1. Informe Técnico.
1.1. Resumen
El presente informe describe las características técnicas de la herramienta Computer Aided
Knowledge Engineering, en adelante CAKE. Instruye sobre el modelo de capas elegido,
patrones de diseño y uso de las herramientas utilizadas como ser el servidor de
aplicaciones de la empresa Google denominado Google App Engine y el Framework
Django.
No pretende ser un tutorial de uso de Google App Engine ni un instructivo de diseño. Se
explican las decisiones tomadas en el diseño, el trabajo realizado para adaptar las diversas
tecnologías y las posibilidades de extenderlo. Para ver la propuesta presentada al
departamento de computación ver ANEXO I . Además de la propuesta puede ver los casos
de usos implementados en el sistema. Ver ANEXO II
Al ser un producto que depende de la disponibilidad de la empresa Google, propone
soluciones para hacerlo independiente de la misma y destaca la arquitectura elegida.
1.2. Introducción.
CAKE es una herramienta Web desarrollada sobre Python. Para que esta aplicación
funcione es necesario un entorno de ejecución para Python. El entorno seleccionado es
Google App Engine.
Google App Engine, en adelante GAE, es un servicio gratuito. Sin embargo el
almacenamiento y el ancho de banda está limitado. Si bien este límite supera las
expectativas de este proyecto, los desarrolladores de CAKE hemos pensado en alternativas
diferentes a GAE y por lo tanto se ha desarrollado el sistema en una arquitectura de capas
muy convenientes para la adaptación de un motor de base de datos y un entorno de
ejecución Python diferente.
Django ha sido el Framework Web seleccionado. Es un Framework Web de alto nivel que
nos agilizó la programación y nos facilitó de varias utilidades convenientes. Django
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 9
además está realizado como Framework de base de datos, sin embargo decidimos utilizar
el Framework que Google App Engine ofrece para una mayor adaptabilidad.
GAE está integrado a una versión antigua de Django, para poder realizar operaciones con
la sesión en GAE fue necesario la adaptación a la versión 1.1 de Django. En este informe
se explicará la integración de Django 1.1 con GAE, integración aplicable a otros
frameworks como Pisa para la generación de PDFs.
La aplicación CAKE tiene una amplia interacción con el usuario. Gracias a AJAX se han
acelerado las reacciones de la aplicación ante los eventos que genera el cliente. Los
desarrolladores de CAKE hemos utilizado las librerias JQuery y Dojo de Javascript que
proveen implementaciones de alto nivel. En este informe mencionaremos el uso de estas
librerías, destacando las funcionalidades principales.
Además se podrá ver en la parte de Anexos información extra, a modo tutorial sobre temas
específicos, entre ellos el uso del repositorio donde podrán realizarse futuros cambios de
los Fuentes de CAKE.
1.3. Arquitectura CAKE.
CAKE está desarrollado bajo una estructura de capas. Cuatro capas básicas componen la
columna vertebral de la aplicación. La capa de Vista, la capa de Servicio, la de Business y
la capa DAO.
La capa de Vista contiene toda la implementación relacionada a la interacción de las
solicitudes del usuario y las respuestas plasmadas en las pantalla, más precisamente en el
navegador. Además contiene implementación de validaciones básicas que no precisan el
acceso a la base de datos. En CAKE esta capa tiene una gran vinculación con el
framework Django. Se compone de varias interfaces que manejan el request, notifican de
errores y redireccionan a las pantallas correspondientes.
La capa de Vista conoce a la capa de Servicio. Esta capa provee los servicios necesarios
para que la capa de vista pueda resolver las solicitudes del usuario y plasme los cambios
en los datos del dominio o negocio.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 10
La capa Business interactúa con la capa DAO. La capa de servicio hace uso de esta capa
para realizar los ABMs correspondientes al dominio. Esta capa tiene lógica de negocio y
sabe como invocar al DAO para impactar en la base de datos.
La capa DAO (Data Access Object) como bien lo indica su nombre, hace acceso a la base.
Utiliza el servicio el framework de Google para realizar la persistencia de datos. Es una
capa útil ya que de querer cambiar de base de datos, se mantiene la interfaz y solo se
cambia la implementación, logrando así, que las demás capas se mantengan invariables.
En el siguiente diagrama de componentes puede verse la interacción entre cada capa:
cmp Componentes
Service
Facade
Business
DAO
Domain
Vista Django
Google App Web
Google App DB
Google App Tx
«use»
«use»«use»
«use»
«use»
«use»
«use»
«use»
«use»
«use»
Fig. 1. Diagrama de componentes principal de CAKE
En el diagrama además aparecen los componentes Domain, Facade, Google App Web,
Google App DB, Google App Tx y Django.
El componente Domain hace referencia al negocio y además implementa cierta lógica de
negocio como ser validaciones de tipos. Esto fue necesario debido a que Python es un
lenguaje no tipado y por otra parte nuestra visión de Dominio no está relacionado a
objetos como estructura de datos sino que tienen lógica del negocio, estados y
validaciones. Para ver el diagrama de dominio Ver ANEXO II
La capa Facade fue utilizado para intercomunicar la capa Business y DAO. Fue necesario
para simplificar y organizar la lógica de transacciones debido a la limitación y
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 11
complejidad que GAE impone en la utilización del componente, denominado en el
diagrama por nosotros como Google App Tx.
Los componentes Google App DB, Django y Google App Tx son componentes utilizados
por nosotros pero no de nuestra autoría. Hacen referencia al framework de base de datos
de google, el framework Web y la librería de transacciones de Google respectivamente.
1.4. Python.
Python fue el lenguaje elegido por nosotros. Es un lenguaje que permite realizar una
programación estructural y/o una programación orientada a objetos. Decidimos realizar la
aplicación bajo el paradigma de objetos, sin embargo nos hemos tomado ciertas licencias,
por ejemplo en la implementación de vistas ya que así se trabaja con el framework
Django.
Python se utiliza como lenguaje de programación interpretado, lo que ahorra un tiempo
considerable en el desarrollo del programa, pues no es necesario compilar ni enlazar. Esta
característica la encontramos muy ventajosa y fue en parte decisiva a la hora de elegir el
lenguaje.
Otro motivo por el cual nos volcamos a este lenguaje, fue el hecho de que Google App
Engine tenía su versión más estable para Python. Existe otra versión que funciona con
Java pero aún está en crecimiento y luego de investigar descubrimos que había muchos
huecos por llenar. Es probable que para el momento en que este informe sea leído, exista
una versión muy estable de Google App Engine Java, compatible con casi todos los
Frameworks más usados del mercado.
La versión utilizada de Python es la 2.5. Fue la escogida ya que es la que recomendaba
Google App Engine. Podía utilizarse la 2.6 pero había ciertas incompatibilidades.
En nuestra opinión, y habituados al uso del lenguaje de programación Java, es que al ser
Python un lenguaje de programación multiparadigma y además que cuenta con resolución
dinámica de nombres, hace que el código sea difícil de mantener y en ciertos casos de
entender. Este es uno de los motivos por los que este informe toma aún más valor.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 12
1.5. Django.
Django es un Framework de desarrollo web de código abierto, escrito en Python, que
cumple en cierta medida el paradigma del Modelo Vista Controlador (MVC) El hecho de
que sea código abierto fue beneficioso para nuestro proyecto debido a que se realizaron
algunos cambios para que su adaptación a Google App Engine fuera exitosa. Algunas de
las modificaciones realizadas, tuvieron como fin adaptar necesidades del proyecto CAKE,
como ser ciertos mensajes de error de formularios.
La versión que utilizamos en nuestro proyecto fue la 1.1 que se encontraba en el
repositorio del proyecto Django. Junto con las modificaciones realizadas la hace única, y
es importante en este informe mencionar cuales fueron los cambios realizados:
Debido a que al momento de realizar CAKE, Google imponía una limitación en la
cantidad de archivos que el proyecto podía contener, el Framework Django fue
comprimido en un zip y su adaptación a Google App Engine se puede ver en las líneas
siguiente del archivo main.py:
# Remove the standard version of Django.
for k in [k for k in sys.modules if k.startswith('django')]:
del sys.modules[k]
# Force sys.path to have our own directory first, in case we want to import
# from it.
django_path = 'django.zip'
sys.path.insert(0, django_path)
Antes mencionamos que necesitamos utilizar una versión diferente de Django a la que
Google App Engine contenía. La razón fue a que en GAE el manejo de sesión mediante
Django no era posible. Para mantener una coherencia al uso que le dábamos al Framework
decidimos que esto no era aceptable. Encontramos un proyecto llamado django-ae-utils,
este proyecto necesitaba la versión del trunk de Django y solucionaba la limitación en el
uso de sesiones mediante Django.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 13
Este párrafo puede no interesarle al lector. La razón por la cual GAE no permitía el uso de
sesiones se debe a que Django utiliza la base de datos en las sesiones. Esto no es posible
con GAE debido a que posee su propio Framework y además la base de datos de GAE no
es una base de datos relacional convencional.
Django-ae-utils brinda además el manejo de usuarios mediante Django, sin embargo, en
este caso, las herramientas que GAE nos brinda son mejores ya que el logueo está
administrado por Google y nos pareció muy conveniente permitir esta validación poderosa
de esta monstruosa empresa.
El Framework ofrece un manejo de plantillas (templates) para administrar las páginas
Web. Cada template tiene una vista asociada. Las vistas son métodos que resuelven las
solicitudes del cliente. Estos métodos son presentados dentro del paradigma estructurado
(antes habíamos mencionado la característica multiparadigma del lenguaje).
1.6. Google AppEngine.
GAE ofrece un entorno de tiempo de ejecución Python dedicado, que incluye un rápido
interprete Python y la biblioteca estándar Python. Todas las aplicaciones que corren sobre
GAE pueden utilizar hasta 500 MB de almacenamiento y suficiente CPU y ancho de banda
como para permitir un servicio eficaz de la aplicación de alrededor de 5 millones de visitas
a la página al mes, totalmente gratuitas.
Entre las herramientas que ofrece GAE, se encuentra el Framework de base de datos. Un
objeto del dominio podría impactar directamente en la base de datos. La librería db define
varios tipos de datos con información necesaria para la base de datos, a la vez que brinda
varios métodos para realizar ABMs en la misma.
En el grupo de desarrolladores CAKE decidimos que no era conveniente que el dominio
tuviera conocimiento directo de esta librería. Esto permite que si el día de mañana se
decide no utilizar más la base de datos propuesta por GAE, puedan realizarse cambios sin
que estos sean profundos en la estructura de clases desarrolladas. Solo habría que
modificar la capa DAO, que actualmente es la que utiliza db y no el dominio del sistema,
posibilitando el traslado del mismo a otro desarrollo futuro sin depender del motor de base
datos.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 14
Además GAE ofrece un manejo de transacciones. Este manejo es necesario sin embargo
no es tan sencillo como aparenta. Los objetos DAO involucrados en transacciones deben
ser parientes, pertenecer a un mismo grupo. En los siguientes diagramas se pueden
observar los objetos que pertenecen a un mismo grupo y que por lo tanto están
involucrados en transacciones:
cd 03- Conocimiento Estático
ConocimientoEstatico
DiccionarioConceptos
Proyecto
Name: 03- Conocimiento EstáticoAuthor: lucVersion: 1.0Created: 01/08/2009 05:05:54 p.m.Updated: 01/08/2009 05:12:15 p.m.
Concepto Atributo ValorAtributo
+parent
+parent
+parent +parent +parent
Fig. 2. Ejemplo de grupo de entidades y relación de parentesco para el conocimiento estático.
GAE ofrece una aplicación para ejecutar en el servidor de desarrollo y probar la
aplicación. Esta aplicación es fácilmente integrable en Eclipse o cualquier otro IDE. Los
desarrolladores CAKE hemos optado por el uso de Eclipse como IDE y en el anexo puede
verse la integración de la aplicación GAE de desarrollo. El entorno de desarrollo GAE
ofrece además una consola Web de administración, similar a la consola productiva. En el
anexo también se encuentra la información de uso.
Como ya se mencionó, GAE ofrece una consola de administración. La consola de
administración permite:
• crear una nueva aplicación y establecer un subdominio appspot.com gratuito o un
nombre de dominio de nivel superior de tu elección,
• invitar a otras personas a ser desarrolladores de tu aplicación de forma que puedan
acceder a la consola y subir nuevas versiones del código,
• ver registros de errores y datos de acceso y analizar el tráfico,
• navegar por el almacén de datos de tu aplicación y administrar los índices,
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 15
• ver el estado de las tareas programadas de tu aplicación,
• probar nuevas versiones de tu aplicación y cambiar la versión que ven los usuarios.
Para subir una aplicación al servidor de aplicaciones de Google, es necesario ejecutar unos
comandos específicos. Esto puede verse en el anexo del corriente informe.
Google App Engine dispone de una aplicación para subir grades cantidades de datos (ver
anexo) al almacén de datos de CAKE. Sin embargo, hemos desarrollado un módulo de
administración que además realiza una validación sobre los datos subidos. Estos tienen un
papel fundamental en el Test de viabilidad que CAKE dispone.
1.7. JQuery y Dojo.
Debido a que buscamos que las pantallas de CAKE sean lo más interactivas y rápidas para
el usuario, decidimos utilizar librerías Javascript de alto nivel como son JQuery y Dojo.
Estas librerías nos permitieron un alto control de los eventos que genera el usuario y el uso
de Ajax. Además la representación gráfica de ciertos elementos, con ciertos efectos,
mejoraron a la aplicación notoriamente.
Básicamente se utilizó JQuery para “acordiones”, AJAX, manipulación de elementos de la
página, manipulación de estilos, tablas, ordenes de tablas, herramientas de autocompletar
texto.
Para más información de la librería puede acceder al siguiente sitio: http://jquery.com/
Dojo fue utilizado para las representaciones gráficas de árboles como el de decisión que se
pueden utilizar en CAKE. Dojo hace uso de las bondades de AJAX y JSON.
Para más información de la librería puede acceder al siguiente sitio:
http://www.dojotoolkit.org/
Ambas librerías facilitaron mucho el trabajo de desarrollo Web. Además permiten que el
código Javascript sea más ordenado y por lo tanto mantenible.
En el proyecto CAKE pueden encontrarse bajo el siguiente directorio del proyecto:
Dirección del repositorio: trunk/aplicación/src/js
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 16
1.8. Soluciones y Mejoras.
Este capítulo está dedicado a explicar las soluciones realizadas a problemas de integración
de ciertas herramientas y de diseño en el desarrollo de la aplicación CAKE. Además se
comentarán las posibles soluciones ante inconvenientes futuros o hipotéticos.
En un primer momento, cuando comenzamos con este proyecto, desde su concepción,
nuestro tutor técnico, Hernán Merlino, nos recomendó que utilizásemos Python como
lenguaje de desarrollo. Uno de los motivos principales de la recomendación era que
Google había lanzado a la comunidad de desarrolladores una herramienta intérprete del
lenguaje Python que además ofrecía un novedoso almacén de datos y un Framework
interesante de desarrollo Web.
Con desconfianza aceptamos la propuesta pero como desarrolladores Java, acostumbrados
a un lenguaje compilable y totalmente orientado a objetos, pensamos que iba a ser más una
complicación que una solución.
Fue una sorpresa, que a la hora de desarrollar la investigación acerca de Google App
Engine, nos encontráramos con la posibilidad de utilizar GAE con Java. Luego nos dimos
cuenta que los Frameworks más utilizados en Java no se adaptaban del todo a GAE y
había que realizar una auto-capacitación acerca del mundo Google. Sobre todo pesó en la
decisión de descartar a Java, que Google App Engine Java aún estaba en vías de
desarrollo, para nada maduro.
Google App Engine Python se transformó así en un recurso muy bueno para nuestro
trabajo. En primer lugar nos independizábamos de los recursos de la facultad (la
habilitación de un servidor, ancho de banda, soporte) En segundo lugar disponíamos de
un almacén de datos y de un Framework hecho a medida. En tercer lugar disponía de un
lenguaje que luego de conocerlo, nos sorprendió lo ágil que era su desarrollo, la capacidad
de utilizar la programación orientada a objetos se adecuaba al paradigma que es natural en
nuestra forma de razonar y su madurez en la comunidad de usuarios con amplio soporte y
tutoriales.
Más allá de que Google App Engine nos da la posibilidad de publicar nuestra aplicación
en una URL pública para cualquier usuario de Internet, es gratuito, nos asegura una alta
disponibilidad, posee una consola interesante de administración, libre de aplicaciones,
todo mediante acceso Web, no nos confiamos y realizamos el diseño de CAKE para que
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 17
no sea dependiente de los caprichos (que hasta el momento de escribir estas palabras no
existen) de la empresa Google.
En CAKE Google App Engine se encuentra en la autorización de usuarios, en la
persistencia de datos, en la interpretación del lenguaje, en el envío de mails y en la
interacción Web con el cliente.
La autorización de usuarios es una gran herramienta que Google nos ofrece. Nos brinda
una pantalla de inicio de sesión y una validación de usuarios. Para ello hay que utilizar la
librería google.appengine.api.users. En caso de que se desee que Google App Engine no se
encargue de las funciones mencionadas, los desarrolladores de CAKE hemos
implementado una clase llamada UserManager contenida en el paquete fiuba.cake.util.
Esta clase encapsula los servicios de users. Se deberían reimplementar los métodos que
esta clase ofrece (sin utilizar users) y en el caso del método get_current_user se debería
devolver un usuario personalizado con la misma interfaz que el User de Google.
La interfaz del objeto User es la siguiente:
nickname()
Devuelve el "apodo" del usuario, un nombre de visualización. El apodo personalizado será
una parte del "nombre" de la dirección de correo electrónico del usuario si la dirección
está en el mismo dominio que la aplicación o la dirección de correo electrónico completa
del usuario en caso contrario.
email()
Devuelve la dirección de correo electrónico del usuario. Las aplicaciones deben utilizar
nickname para los nombres de visualización.
user_id()
Devuelve la ID única y permanente del usuario, str. Esta ID es siempre la misma para el
usuario, independientemente de si este cambia su dirección de correo electrónico.
Esta interfaz debería ser implementada en una nueva clase y en el método
get_current_user, devolver un objeto de la clase reimplementadora. Es importante
mantener esta interfaz para no tener que realizar cambios profundos en CAKE ya que hay
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 18
varias clases que utilizan métodos de User. En este caso se aprecian las ventajas de
lenguaje de Python como lenguaje no tipado.
La persistencia de datos es otra herramienta muy útil de GAE. No solo cuenta con la
consola de administración y la aplicación para realizar subida masiva de datos (ver anexo)
sino que ofrece un Framework muy completo. En caso de que no se desease utilizar a
Google App Engine como interprete de Python, los desarrolladores de CAKE hemos
realizado la capa DAO, la cual tiene concentrado toda la interacción con el Framework de
GAE. Por lo tanto solo habría que reimplementar los servicios de esta capa a la nueva base
o almacén de datos. Se podría en este caso aprovechar del Framework Django que ya se
encuentra integrado a CAKE para el manejo de la persistencia.
Existe una característica del almacén de datos de Google que hizo que nuestra manera de
interrelacionar entidades tuviera que adaptarse a una nueva visión. En GAE un objeto del
modelo de datos no puede tener un Set de referencias. Lo que sí se puede es acceder a
clases asociadas con un método de conjunto. Esta funcionalidad implica que cuando un
modelo tiene una propiedad ReferenceProperty que hace referencia a otro modelo, cada
entidad a la que se hace referencia adopta una propiedad cuyo valor es una consulta que
devuelve todas las entidades del primer modelo que hace referencia a ella.
Para entender el concepto anterior puede pensar en la siguiente situación. Un director de
cine dirige a set de actores. En el modelo relacional tendremos una tabla de director y una
tabla de actor. Imagínese que la tabla actor tiene una foreign key a la tabla director.
Cuando usted piense la interrelación de clases, seguramente piense en que la clase
Director tenga una composición o asociación simple con la clase Actor, representada como
un sets de referencias a instancias de la clase Actor. Si quisiera obtener todos los actores
dirigidos por el director ejecutaría una consulta a la tabla Actor con el identificador del
Director. Por ejemplo en SQL:
SELECT * FROM ACTOR WHERE id_director = #idDirector.
Luego en memoria podría tener los actores dirigidos por el director si fuera factible.
En Google App Engine podría aprovechar la funcionalidad antes explicada y debería
pensar de manera opuesta a la antes planteada. Ya que Google ofrece la posibilidad de que
con un solo método puedan obtenerse todos los actores dirigidos por un director, es el
Actor el que tiene una referencia del Director. De esta manera, desde un Actor puedo
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 19
obtener todos los actores que se encuentran bajo la dirección de un Director de la siguiente
manera:
for actor in director.actor_set:
#...
Mostramos entonces un ejemplo de estas interacciones en CAKE:
class 02- Viabilidad
Todos los objetos del dominio extienden de un Model Class, perteneciente al App Engine, paquete google.appengine.ext.db
TestViabilidad
- estado: String- fechaAlta: datetime.datetime- usuarioAlta: Usuario
01-Gestor del Proyecto::Proyecto
- fechaAlta: datetime.datetime- fechaFinalizacion: datetime.datetime- fechaInicio: datetime.datetime- nombre: String- usuarioAlta: Usuario
Pregunta
- denominacion: String- orden: int- peso: int- pregunta: String- tipo: Dimension- valorUmbral: String
Los estados del test son:NUEVO (N)PROCESADO (P)CERRADO (C)ELIMINADO (E)INVIABLE(I)
Naturaleza
- tipo: String- valores: var
Booleana DifusaNumericaSi valorUmbral es nulo, entonces no tiene umbral.Si tiene umbral, entonces la pregunta es escencial
Respuesta
- analisis: String- valor: String
Dimension
- peso: int- tipo: String
01-Gestor del Proyecto::Usuario
- apellido: String- nombre: String
+ mail() : String+ nickname() : String1
1
1
usuarioAlta0..*
1
usuarioAlta
1
0..* 1
1
0..*
1..* 1
0..*
tipo
1
Fig. 3. Diagrama de clases que muestra relación entre objetos.
Antes mencionamos que Google App Engine era el intérprete de Python. Es posible
conseguir la misma funcionalidad utilizando el intérprete nativo de Python en un servidor
dedicado y así independizarse de Google App Engine. Lo ventaja de GAE en este sentido
es que nos brinda la consola de administración que nos permite ver el tráfico de la
aplicación.
Nos permite además, realizar el manejo de las versiones en producción. GAE permite
tener muchas versiones en producción y habilitar aquella que se crea conveniente utilizar.
Permite un sistema de bitácora que mediante el administrador de aplicaciones se puede ver
todo lo logueado y permite también analizar y evaluar el tráfico en las diferentes pantallas.
El Framework del almacén de datos también ofrece el manejo de transacciones. Sin
embargo, aunque es seguro, nos encontramos que era bastante limitado y complicado su
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 20
uso. En un primer momento es sencillo pero obliga a que una transacción contenga en su
cuerpo objetos del modelo que pertenezcan a un mismo grupo. Para que los objetos sean
del mismo grupo deben ser parientes entre ellos. No es tan sencillo mantener esta relación
ya que en ciertas ocasiones no tiene lógica de diseño los parentescos.
Para que el manejo de transacciones quede lo más controlado posible realizamos la capa
Facade denominada transactionFacade. Se puede ver en la siguiente línea como esta capa
encapsula el uso de transacciones de Google.
def registrar(self,gtNuevo):
gtNuevo.nombre = string.upper(gtNuevo.nombre)
gtAGrabarDAO = GrupoTrabajoDAO.from_GrupoTrabajo_2_GrupoTr……
integrante = Integrante(gtNuevo.usuarioAlta,gtNuevo,…
gtNuevoDAO = db.run_in_transaction(facadeGestorProyect…
gtNuevo = gtNuevoDAO.from_GrupoTrabajoDAO_2_GrupoTrabajo()
return gtNuevo
Se puede observar en el código que la funcion db.run_in_transaction recibe por argumento
un método de facade. Dentro del método se realizan las siguientes operaciones:
def registrar_grupo_trabajo(gtDAO, integrante, userDAO):
gtDAO.put()
IntegranteDAO.registrar_Integrante(integrante,userDAO,gtDAO,gtDAO)
return gtDAO
Todos los objetos del método deben ser parientes. Además cuando se desee obtener un
elemento que tenga un padre deberá pasarse su padre y he allí la dificultad y habilidad del
programador para pasarle el padre en el momento debido.
La herramienta de envío de mail es otra opción muy conveniente del uso de Google App
Engine. Los desarrolladores de CAKE hemos concentrado el uso de envíos de mail en el
paquete fiuba.cake.util.email. De querer utilizar otro componente para administración de
mail, se necesita reimplementar esta interfaz.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 21
En la integración de Django con GAE nos dimos cuenta que el manejo de sesiones por
parte del Framework Web Django utilizaba la base de datos. Esto era un inconveniente
debido a que el almacén de datos de Google no es una base de datos convencional y por lo
tanto, no era factible su uso directo.
Como mencionamos en otro capítulo de este informe, existe un proyecto que adapta la
necesidad planteada arriba. La solución a nuestro problema entonces ya estaba
desarrollada e implicó utilizar la versión del repositorio de Django, versión estable 1.1.
En el capítulo Django de este informe, se adelantó la solución y el desarrollo realizado
para la integración.
A partir de que pudimos utilizar el manejo de sesiones con Django realizamos un
desarrollo más profundo, generando que las sesiones vivan en cierto contexto. Para
realizar dicha implementación se aprovecho los Middleware de Django. La clase
Middleware intercepta request, response y excepciones. Además de las clases que brinda
Django, uno puede tener sus propias Middleware. Si uno quiere:
• interceptar la request, debe implementar el método
o def process_request(self, request):
• interceptar el response, debe implementar el método:
o def process_response(self, request):
• interceptar las excepciones, debe implementar el método:
o def process_exception(self, request):
Como se mencionó en el párrafo anterior, a partir de la sesiones sentimos la necesidad de
que las variables en sesión vivan en diferentes contextos, se eliminen en forma automática
cuando no se estén en un contexto válido, evitando dejar al programador la obligación de
vaciar la sesión cuando la deja de usar.
Con la ayuda de los Middleware, interceptamos la request, identificamos la url y mediante
un archivo propio de configuración (sessionContext.py) sabemos a que contexto la url
puede acceder. Todos los contextos que no se utilizan para la url interceptada son vaciados
de forma automática.
Para ver los diagramas que explican este proceso ver ANEXO II .
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 22
Otra implementación que se hizo con las clases Middleware es el control de que el
usuario esté logeado en el sistema. En caso de no estar logueado, se redirecciona al log in
del sistema.
Uno de los requisitos planteados en CAKE fue que ciertas pantallas debían poseer la
opción de representar informes en archivos de tipo PDF, realizar ciertos reportes. Luego
de una ardua investigación llegamos a la conclusión que el Framework Pisa era el más
conveniente. En su página principal tenía una demo funcionando en GAE y además ofrece
la facilidad de que una página HTML se transforma en un PDF. Por lo tanto solo nos
tenemos que preocupar de desarrollar el reporte en código HTML con la capacidad de
utilizar Django para ingresar datos dinámicos.
Por supuesto todo lo que es sencillo de utilizar tiene sus limitaciones, sobre todo siendo
una versión gratuita y existiendo una versión más poderosa pero paga.
En primera instancia las imágenes soportadas pueden ser solo en formato JPEG. Además
cualquier recurso externo, como ser estilos, archivos de imágenes, etc, deben estar en una
URL válida de la NET.
Ambas limitaciones no fueron demasiado problema. Hoy en día cualquier imagen puede
ser convertida a casi cualquier formato fácilmente. En cuanto a la url por suerte Google
ofrece una URL pública de la aplicación por lo tanto solo hay que asegurarse que los
recursos que se incluyen en la página, futuro documento PDF, tienen que estar en el
servidor de Google.
En caso de que en el futuro se desee utilizar un servidor propietario hay que asegurarse de
poner una URL válida.
Una ayuda de implementación es el método que se ha dejado para realizar, el cual resuelve
la url, según un path relativo:
def fetch_resources(request,uri):
"""
Toma la uri y construye la url absoluta (con el http)
"""
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 23
path = request.build_absolute_uri(uri)
return path
Este método tiene una implementación básica, sin embargo es bastante ilustrativo de lo se
debe hacer.
Además hay que destacar que no todos los estilos están permitidos y que el Framework
ofrece tags útiles como por ejemplo para incluir el número de página.
Para utilizar el Framework fue necesario incluir las librerias al igual que lo hicimos con
Django en formato comprimido ZIP para no subir demasiados archivos a Google ya que
como mencionamos antes, impone una limitación en este aspecto.
La manera de incluir los .zip es de la siguiente manera:
En el archivo main.py incluir las líneas siguientes:
sys.path.insert(0,'reportlab.zip')
sys.path.insert(0,'html5lib.zip')
sys.path.insert(0,'ho.zip')
sys.path.insert(0, 'sx.zip')
sys.path.insert(0,'pyPdf.zip')
Notar que para cualquier Framework futuro que se desee utilizar hay que realizar los
mismos pasos con el zip que corresponda. Como recomendación, se debe comprimir el
archivo teniendo en cuenta las importaciones que se realizan en los fuentes
correspondientes ya que de otra manera no reconocerá los componentes utilizados en el
Framework.
1.9. Subida de Aplicación y Mantenimiento.
Google App Engine nos provee de un comando para subir cualquier aplicación Web
desarrollada en Python a sus servidores. Una vez productiva una versión de la aplicación,
tendrá asociada una dirección pública como la siguiente:
• http://application-id.appspot.com
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 24
En el caso de CAKE será:
• http://herramientacake.appspot.com/cake/
Se puede ver que se agregó ‘/cake/’ a la URL. Esto se debe a que la aplicación CAKE fue
configurada para interpretar esta dirección relativa.
Para configurar la URL de la aplicación, es decir el application-id, se debe modificar el
archivo app.yaml del proyecto. En CAKE este archivo se encuentra configurado de la
siguiente manera:
application: herramientacake
version: 1
runtime: python
api_version: 1
handlers:
- url: /stylesheets
static_dir: stylesheets
- url: /imagenes
static_dir: imagenes
- url: /js
static_dir: js
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 25
- url: /cake/.*
script: main.py
Como puede apreciarse luego de la etiqueta application se configura el ID de la aplicación.
Puede escribirse además la versión, el lenguaje, la api_version.
Como se puede apreciar bajo los handlers se encuentra la ruta relativa cake. Allí le
especificamos que solo entenderá una URL que contenga esta ruta relativa y todo lo que
luego de ella exista.
Para subir la aplicación al servidor productivo se hace uso de un comando o herramienta
que GAE nos brinda. No es ni más ni menos que un módulo Python denominado
appcfg.py.
La herramienta multiuso llamada appcfg.py se encarga de gestionar toda la interacción
entre las líneas de comandos mientras tu aplicación se esté ejecutando en App Engine.
appcfg.py puede subir tu aplicación a App Engine o simplemente actualizar la
configuración de los índices del almacén de datos para que puedas crear nuevos índices
antes de actualizar el código. También puede descargar los datos de registro de la
aplicación para que puedas analizar el rendimiento de tu aplicación mediante tus propias
herramientas.
Para subir archivos de aplicaciones, de debe ejecutar el comando appcfg.py con la acción
update y el nombre del directorio raíz de la aplicación. El directorio raíz debe contener el
archivo app.yaml de la aplicación. Como mencionamos anteriormente este archivo es el
que configura nuestra aplicación, por ejemplo para nombrar la URL pública que nos ofrece
Google.
Un ejemplo de subida de la aplicación sería:
appcfg.py update myapp/
Un ejemplo más concreto con CAKE en un sistema operativo Unix sería de la siguiente
manera:
appcfg.py update /Users/userEjemplo/Documents/workspace/CAKE
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 26
Luego de aplicar este comando, le solicitarán el mail y clave Google. También puede
especificar el email para no ingresarlo más tarde:
appcfg.py --email=Albert.Johnson@example.com update myapp/
Si se conecta a Internet a través de un Proxy. Debe realizar los siguientes comandos en
Windows en la consola:
set HTTP_PROXY=http://cache.mycompany.com:3128
appcfg.py update myapp
En Mac OS X o Linux en la terminal:
export http_proxy="http://cache.mycompany.com:3128"
appcfg.py update myapp
Es posible acceder a la consola de CAKE que nos brinda Google en la dirección
• www.appspot.com o http://appengine.google.com/
Si disponemos de un usuario desarrollador del sistema podremos ver herramientacake
como aplicación posible a entrar. Al ingresar verá el tablero de estadísticas y tendrá a su
disposición un menú que entre otras cosas permite ver el almacén de datos y realizar
asignaciones de rol Developer de CAKE para usuarios Google.
Es una consola muy útil y muy completa. Allí dispondrá de funcionalidades muy
completas para un servicio gratuito.
Además Google nos ofrece la siguiente planilla con commandos:
El comando appcfg.py incluye un conjunto de opciones, una acción y argumentos para la
acción.
Están disponibles las siguientes acciones:
appcfg.py [options] update <app-directory>
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 27
Sube archivos para una aplicación en función del directorio raíz de la aplicación. La ID y
la versión de la aplicación se toman del archivo app.yaml situado en el directorio de la
aplicación.
appcfg.py [options] rollback <app-directory>
Deshace una actualización completada parcialmente en una aplicación determinada. Esta
acción resulta útil si se interrumpe una actualización y el comando indica que la aplicación
no se puede actualizar a causa de un bloqueo.
appcfg.py [options] update_indexes <app-directory>
Para incluir índices nuevos añadidos, actualiza los índices del almacén de datos en App
Engine. Si alguna versión nueva de tu aplicación requiere una definición de índices
adicional añadida a index.yaml, puedes actualizar las definiciones de los índices en App
Engine antes de subir la versión nueva de la aplicación. Si ejecutas esta acción unas horas
antes de subir la versión nueva de la aplicación, consigues que los índices estén creados y
se muestren en el momento de la implementación de la aplicación.
appcfg.py [options] vacuum_indexes <app-directory>
Elimina índices de almacenes de datos no utilizados en App Engine. Si se elimina una
definición de índice de index.yaml, el índice no se eliminará automáticamente al subir la
aplicación porque es posible que lo esté utilizando otra versión de la aplicación. Ejecuta
esta acción cuando ninguno de los índices antiguos sea ya necesario.
appcfg.py [options] request_logs <app-directory> <output-file>
Recupera datos de registro de la aplicación que se ejecuta en App Engine. output-file es el
nombre del archivo que se va a crear, sustituir o añadir (si el indicador --append está
establecido). Si el valor de output-file es un guión (-), los datos de registro se imprimirán
en la consola. Las siguientes opciones se aplican a request_logs:
--num_days=...
El número de días que se recuperarán datos de registro hasta la fecha actual a medianoche
(UTC). Si el valor es 0, se recuperarán todos los registros disponibles. Si se especifica --
append, el valor predeterminado será 0; de lo contrario, será 1.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 28
--severity=...
El nivel mínimo de registro para los mensajes de registro que se van a recuperar. El valor
es un número que se corresponde con el nivel de registro: 4 para CRITICAL (CRÍTICO),
3 para ERROR, 2 para WARNING (ADVERTENCIA), 1 para INFO (INFORMACIÓN) y
0 para DEBUG (DEPURAR). Se recuperarán todos los mensajes pertenecientes a un nivel
de registro determinado y a los niveles superiores. El valor predeterminado es 1 (INFO).
--append
Añade los datos extraídos al archivo de salida, comenzando por la primera línea del
registro que no aparece en el archivo. Si se ejecuta este comando una vez al día con --
append, se obtendrá un archivo que contendrá todos los datos de registro.
La acción predeterminada consiste en sobrescribir el archivo de salida. No se aplica si el
valor de output-file es - (impresión en la consola).
appcfg.py [options] upload_data <app-directory>
Sube los datos al almacén de datos desde los archivos CSV. Si deseas obtener toda la
información sobre el uso de esta función, consulta Subida de datos.
appcfg.py help <action>
Imprime un mensaje de ayuda sobre la acción en cuestión y finaliza.
El comando appcfg.py acepta las siguientes opciones para todas las acciones:
--quiet
No imprime mensajes cuando se ejecuta correctamente.
--verbose
Imprime mensajes sobre lo que está haciendo el comando.
--noisy
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 29
Imprime muchos mensajes sobre lo que está haciendo el comando. Esto resulta
especialmente útil al trabajar con el equipo de App Engine para resolver problemas
relacionados con la subida de aplicaciones.
--email=...
La dirección de correo electrónico de la cuenta de Google de un administrador de la
aplicación, para aquellas acciones que requieren credenciales de acceso. Si omites esta
opción y no hay ninguna cookie almacenada de un uso anterior del comando, el comando
te pedirá que introduzcas este valor.
--passin
Si la especificas, la herramienta acepta la contraseña de la cuenta de Google en stdin en
lugar de pedirla de forma interactiva. Esto te permite ejecutar la herramienta desde una
línea de comandos sin tener que introducir en ella la contraseña.
--server=...
El nombre de host del servidor de App Engine. El valor predeterminado es
"appengine.google.com".
--host=...
El nombre de host del equipo local que se utilizará con las llamadas a procedimientos
remotos.
--no_cookies
No almacenes las credenciales de acceso del administrador como una cookie; debes hacer
que se pida la contraseña cada vez.
--force
Fuerza la eliminación de índices no utilizados. De forma predeterminada, al subir una
aplicación no se eliminan del servidor los índices no utilizados, aunque no aparezcan en el
archivo index.yaml.
--max_size=...
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 30
El tamaño máximo de los archivos que se pueden subir, en forma de número de bytes. Los
archivos que superen este tamaño no se subirán. El valor predeterminado es "1048576". El
servidor actualmente sólo admite un tamaño de archivo máximo de 1.048.576 bytes, por lo
que resultará inútil especificar un valor mayor.
1.10. Repositorio CAKE.
Google Code es una iniciativa de Google que además de ofrecer el Google App Engine,
ofrece el almacenamiento gratuito de proyectos mediante SVN.
A la hora de seleccionar el repositorio del proyecto nos pareció muy conveniente utilizar
el almacenamiento gratuito de proyectos de Google.
Para poder bajar el proyecto CAKE, es necesario tener un usuario Google registrado y
tener permisos sobre el proyecto opensource herramientacake. Nuestro tutor técnico
Hernán Merlino, docente de la facultad de Ingenieria de la Universidad de Buenos Aires
posee rol de owner y los permisos quedarán a su cargo.
La URL para configurar el cliente SVN es
https://herramientacake.googlecode.com/svn/trunk/.
El usuario que deben usar es el usuario Google y en su Profile de Google code busque su
contraseña.
Para bajar en el IDE que guste debe agregarle a la URL dada la ruta relativa aplicacion/.
Algo a destacar del almacenamiento de proyectos es que ofrece un Issue Tracker. En los
comienzos del desarrollo de CAKE este Issue Tracker fue muy útil y queda disponible
para los futuros desarrolladores de CAKE y sus agregados.
1.10.1. Subida de Datos.
Este tutorial de subida de datos para una aplicación GAE se encuentra en la siguiente
dirección para el momento en que este informe ha sido realizado:
http://code.google.com/intl/es/appengine/docs/python/tools/uploadingdata.html
Para evitar que el día de mañana la URL desaparezca, agregamos este anexo de tutoría
Google.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 31
1.10.2. Tutorial subida de datos.
La herramienta appcfg.py permite subir datos al almacén de datos de tu aplicación. Con
una pequeña configuración, puedes crear entidades nuevas del almacén de datos a partir de
archivos CSV. La mayoría de las aplicaciones de hojas de cálculo pueden exportar
archivos CSV, lo que hace más fácil la producción de datos que se pueden importar a la
aplicación para aquellos que no son desarrolladores y para otras aplicaciones.
Configuración de remote_api
La función de cargador de datos se comunica con la aplicación que se ejecuta en App
Engine mediante el uso de "remote_api", un controlador de solicitud incluido en la
biblioteca Python de App Engine que permite el acceso remoto al almacén de datos de las
aplicaciones remotas con las credenciales adecuadas. Para utilizar remote_api, tienes que
asignarle una URL a tu archivo app.yaml.
Edita app.yaml y, a continuación, añade las siguientes líneas a la sección handlers:
- url: /remote_api script: $PYTHON_LIB/google/appengine/ext/remote_api/handler.py
login: admin
De ese modo, se asigna el controlador de solicitud remote_api a la URL /remote_api de tu
aplicación. Puedes utilizar la URL que desees. El acceso a esta URL queda restringido a
los administradores de la aplicación.
Para instalar el nuevo archivo app.yaml y la URL de remote_api, tienes que actualizar la
aplicación:
appcfg.py update
1.10.3. Instalación de Sqlite (Recomendada).
appcfg.py upload_data utiliza un archivo de datos para realizar el seguimiento de su
progreso mientras se suben los datos en caso de que la subida se vea interrumpida y
necesite comenzar de nuevo a mitad del archivo de datos. Esta función requiere que la
biblioteca Sqlite administre el archivo de progreso. Si no tienes instalada la biblioteca
Sqlite 3 en tu sistema, consulta el sitio web de Sqlite para obtener información acerca de
su descarga e instalación.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 32
Nota: si has instalado Python en tu sistema mediante su compilación a partir de código
fuente, tras la instalación de Sqlite, tienes que volver a compilarlo con compatibilidad para
esta biblioteca.
Mediante la introducción del siguiente comando, puedes comprobar si dispones de la
instalación de Sqlite para Python:
python -c 'import sqlite3'
Si Sqlite 3 está instalada, el comando no hace nada. Si no lo está, el comando imprime:
ImportError: No module named sqlite3
Si no deseas instalar Sqlite 3, puedes inhabilitar el uso de un archivo de progreso. Para
ello, dale al archivo appcfg.py upload_data este argumento: --db_filename=skip. Si
inhabilitas el archivo de progreso y se interrumpe la subida, debes editar el archivo CSV
para evitar la creación de entidades duplicadas al volver a iniciar la subida.
1.10.4. Creación de Clase Loader.
Para hacer que el comando appcfg.py upload_data sepa cómo traducir las filas del archivo
CSV en entidades del almacén de datos, debes definir clases Loader en un archivo de
origen Python. Este archivo importa o define las clases Model para las entidades que se
crean y define la clase Loader para cada tipo que desees importar.
Por ejemplo, si dispones de una clase Model llamada Album definida en un archivo
llamado models.py (que se encuentra en PYTHONPATH, como, por ejemplo, el directorio
donde vas a ejecutar la herramienta), encontrarás algo parecido a lo siguiente:
from google.appengine.ext import db
class Album(db.Model):
artist = db.StringProperty()
title = db.StringProperty()
publication_date = db.DateProperty()
length_in_minutes = db.IntegerProperty()
Deseas importar un archivo CSV que presente las columnas en el orden siguiente: título,
artista, fecha de publicación y longitud en minutos. El archivo CSV contiene
representaciones de cadenas para todos estos valores.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 33
A continuación, se muestra un archivo de clase Loader para estos datos:
import datetime
from google.appengine.ext import db
from google.appengine.tools import bulkloader
import models
class AlbumLoader(bulkloader.Loader):
def __init__(self):
bulkloader.Loader.__init__(self, 'Album',
[('title', str),
('artist', str),
('publication_date',
lambda x: datetime.datetime.strptime(x, '%m/%d/%Y').date()),
('length_in_minutes', int)
])
loaders = [AlbumLoader]
La herramienta de carga masiva busca una variable global en el archivo de clase Loader
con el nombre loaders, cuyo valor es una lista de clases Loader que se pueden utilizar. En
este ejemplo, la herramienta carga la clase AlbumLoader para la carga de las entidades de
la clase Album.
La clase Loader define un método __init__() que ejecuta __init__() en la clase Loader. El
primer argumento es self, la instancia de clase Loader. El segundo argumento es el nombre
del tipo de almacén de datos como una cadena, en este caso 'Album'. El tercer argumento
es una secuencia de tuplas, donde cada tupla contiene el nombre de la propiedad (una
cadena) y una función de conversión. La función de conversión debe tomar una cadena y
devolver uno de los tipos de valores del almacén de datos.
En este ejemplo, tanto la propiedad 'title' como la propiedad 'artist' toman unos valores de
cadenas, por lo que la función de conversión es str, el constructor de cadenas. La
propiedad 'length_in_minutes' toma un número entero y el constructor int toma una cadena
y la convierte en un valor de número entero.
Para la propiedad 'publication_date', el modelo necesita un valor datetime. En este caso,
sabemos (por nuestro archivo de datos) que las fechas de publicación se representan en
con el formato mm/dd/yyyy. La función de conversión es una expresión lambda (una
función corta) que toma una cadena y, a continuación, la pasa a
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 34
datetime.datetime.strptime() con un patrón para analizar el valor a datetime.datetime.
Finalmente, para obtener el valor final datetime.date, ejecuta su método date().
Si una función de conversión genera alguna excepción o no consigue devolver un valor
que cumpla con los requisitos de la clase Model, se detiene el procesamiento del archivo
de datos y se informa de un error. Si haces uso de un archivo de progreso (con Sqlite,
como se ha descrito anteriormente), puedes corregir el archivo CSV (o el código, cuando
sea necesario) y, a continuación, volver a ejecutar la subida para continuar y empezar por
la fila donde se produjo el error.
Si el nombre del archivo que contiene la definición de la clase Loader es album_loader.py,
debes darle a appcfg.py upload_data el siguiente argumento:
--config_file=album_loader.py
1.10.5. Preparación de Datos.
El comando appcfg.py upload_data acepta datos en forma de archivo con el formato CSV
(valores separados por comas), es decir, un archivo de texto sencillo que representa una
tabla de valores con un valor por cada línea y columnas delimitadas por comas (,). Si el
valor contiene una coma o más, el valor va comprendido entre comillas dobles ("). Si un
valor contiene comillas dobles, estas aparecen dos veces (""). Para analizar el archivo de
datos, la herramienta utiliza el módulo csv de la biblioteca estándar Python.
Para los datos de texto, el archivo debe utilizar la codificación UTF-8. La codificación
UTF-8 es compatible con la codificación ASCII, por tanto, también funciona cualquier
aplicación de hojas de cálculo que guarde archivos CSV como ASCII.
La mayoría de las aplicaciones de hojas de cálculo pueden exportar una hoja en forma de
archivo CSV. Para exportar una hoja en forma de archivo CSV desde las hojas de cálculo
de Google Docs, debes seleccionar Archivo menú > Exportar > Sólo hoja .csv y, a
continuación, guardar el archivo desde la ventana del navegador que se abra.
Si el nombre del archivo CSV que debes cargar es album_data.csv, tienes que darle a
appcfg.py upload_data el siguiente argumento:
--filename=album_data.csv
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 35
Si la primera fila del archivo CSV no contiene datos (como, por ejemplo, una fila de
encabezado), utiliza la siguiente opción para omitirla:
--has_header
1.10.6. Subida de Datos a AppEngine.
Para comenzar la subida de los datos, ejecuta appcfg.py upload_data con los argumentos
adecuados:
appcfg.py upload_data --config_file=album_loader.py --filename=album_data.csv --
kind=Album <app-directory>
Si estás utilizando un nombre de dominio de Google Apps y, para acceder mediante una
cuenta de ese dominio necesitas appcfg.py, debes especificar la opción --auth_domain=...,
cuyo valor es tu nombre de dominio.
1.10.7. Subida de Datos al servidor de Desarrollo.
Si deseas probar el funcionamiento de tus datos en la aplicación antes de subirlos, puedes
cargarlos al servidor de desarrollo. Para apuntar la herramienta a la URL del servidor de
desarrollo, utiliza la opción --url. Por ejemplo:
appcfg.py upload_data --config_file=album_loader.py --filename=album_data.csv --
kind=Album --url=http://localhost:8080/remote_api <app-directory>
1.10.8. Argumentos de la Línea de Comandos.
El comando appcfg.py upload_data acepta los argumentos que se muestran a continuación.
También puedes consultar todas las acciones que acepta appcfg.py en Subida y
administración de la aplicación Python: Argumentos de línea de comandos.
appcfg.py upload_data [options] <app-directory>
--filename=...
Obligatorio. Se trata de la ruta del archivo de datos CSV que se va a cargar.
--kind=...
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 36
Obligatorio. Se trata del nombre del tipo de base de datos que se va a utilizar para crear
entidades nuevas.
--config_file=...
Obligatorio. Se trata de un archivo de origen Python que importa o define las clases Model
para los tipos de entidades que puede crear una subida, así como las clases Loader para
cada tipo. Al evaluar este archivo, appcfg.py upload_data proporciona la clase básica
Loader en el nombre de espacio local.
--loader_opts=...
Se trata de una opción para transmitir al método de la clase initialize(). Puedes
implementar este método para transmitir argumentos a tus clases Loader.
--log_file=...
Se trata del nombre del archivo de la escritura de la información de acceso acerca de la
subida. Lo que se hace de forma predeterminada es crear un archivo con el nombre
bulkloader-log-timestamp en el directorio de trabajo actual (donde timestamp es el tiempo
de ejecución de la herramienta).
--auth_domain=...
Se trata del nombre del dominio de autenticación de la cuenta que se utiliza para contactar
con remote_api. Si utilizas un dominio de Google Apps y necesitas appcfg.py para acceder
con una cuenta de Google Apps, debes especificar tu nombre de dominio mediante esta
opción.
--num_threads=#
Se trata del número de cadenas que se envían para cargar entidades nuevas en paralelo. El
valor predeterminado es 10.
--batch_size=#
Se trata del número de entidades que se van a crear mediante cada ejecución de
remote_api. Para entidades grandes, debes utilizar un tamaño de lote reducido para limitar
la cantidad de datos publicados en cada lote. El valor predeterminado es 10.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 37
--bandwidth_limit=#
Se trata el número máximo total de bytes por segundo que deben enviar todas las cadenas.
Es posible que las ráfagas excedan este máximo, pero el ancho de banda general es menor
que esta cantidad. El valor predeterminado es 250.000 bytes por segundo.
--rps_limit=#
Se trata el número máximo total de registros por segundo que deben enviar todas las
cadenas. El valor predeterminado es 20.
--http_limit=#
Se trata el número máximo total de solicitudes HTTP por segundo que deben enviar todas
las cadenas. El valor predeterminado es 7,5 (15 cada dos segundos).
--db_filename=...
Se trata del nombre de archivo que se ha de utilizar para el archivo de progreso en esta
ejecución. Si no viene especificado, se le da el nombre bulkloader-progress-timestamp,
donde timestamp representa el tiempo de ejecución del comando. Si se especifica este
argumento con el valor skip, la subida no hace uso de un archivo de progreso.
--has_header
Si está presente, omita la primera fila del archivo CSV, asumiendo que esta se trate de la
fila de encabezado.
--app_id=...
Se trata de la ID de la aplicación si esta es distinta a la ID que se especifica en el archivo
app.yaml de la aplicación.
--url=...
Se trata de la URL del controlador remote_api que se utiliza para realizar la conexión con
el almacén de datos. De forma predeterminada, deriva del archivo app.yaml de la
aplicación.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 38
2. Manual de Usuario.
2.1 ¿Qué es CAKE?
Cake (Computer Aided Knowledge Engineering) es una herramienta Web cuya
funcionalidad es la gestión de la metodología IDEAL, metodología para la construcción de
sistemas basados en conocimiento. Este documento no intenta explicar la citada
metodología.
Este sistema da la posibilidad de realizar el estudio de viabilidad, la etapa de
conceptualización que incluye la modelización de conocimientos fácticos, estratégicos y
tácticos y la generación del modelo dinámico.
El estudio de Viabilidad permitirá detectar si el desarrollo es posible, justificado,
adecuado y si va a tener éxito.
En la etapa de conceptualización, el conocimiento fáctico incluye el diccionario de
concepto y tabla de concepto – atributo – valor. Los conocimientos estratégicos permiten
identificar el diagrama jerárquico de tareas (Árbol de descomposición funcional), el
conocimiento táctico incluye la tabla de decisión y seudoreglas. Finalmente, la generación
del modelo dinámico incluye el árbol de estrategias (grafo causal) y mapa de
conocimientos.
Además de estos módulos característicos de la metodología ideal, además existen en el
sistema, los módulos de Gestión de Proyecto y Administración.
Para ver todas las funcionalidades que tiene el módulo de Gestión de Proyecto, lea Gestor
Proyecto.
Para ver todas las funcionalidades que tiene el módulo de Administración, lea
Administración.
2.2 Requisitos del Sistema.
• Tener una cuenta en gmail. (El servidor de aplicaciones corre bajo AppEngine)
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 39
• Navegador web que soporte AJAX. Preferentemente Firefox 2 o superior.
• Adobe Acrobat 5.0 o posterior.
2.3 ¿Nuevo en el Sistema? ¿Cómo registrarse?
Si usted es nuevo en el sistema, para poder entrar al mismo deberá acceder a la siguiente
URL. http://herramientacake.appspot.com/cake/.
Una vez que entra a la dirección antes mencionada, el sistema lo redireccionará al login.
Aquí usted tendrá que ingresar con su usuario y contraseña de google y presionar en
acceder.
Como es la primera vez que entra al sistema CAKE, el mismo le pedirá autentificación.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 40
En esta pantalla usted tendrá que poner su nombre y su apellido. No podrá modificar ni el
email, ni el nickname.
Luego de registrarse en el sistema CAKE, accederá automáticamente a la pantalla
principal del sistema.
Como usted es nuevo en el sistema, las únicas funcionalidades que puede hacer es crear un
grupo de trabajo, listar grupos de trabajos a los cuales pertenece (como es nuevo no
pertenece a ninguno y por lo tanto no verá ninguno), unirse a grupos de trabajos ya
existentes y por último administrar los datos del usuario.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 41
2.4 ¿Qué Roles existen y qué funcionalidades pueden hacer?
Existen dos roles en el sistema, Grupo Trabajo Administrador y Grupo Trabajo Integrante.
Grupo Trabajo Administrador es todo aquel usuario que cree al grupo de trabajo. Este
usuario podrá:
• Crear, modificar y eliminar grupos de trabajos.
• Asignar y eliminar integrantes al grupo de trabajo.
• Aceptar y rechazar peticiones de grupo de trabajo.
• Crear, modificar y eliminar un proyecto.
Grupo de Trabajo Integrante, es todo aquel usuario integrante de un grupo del cual no es
administrador. El usuario podrá:
• Crear, modificar y eliminar un proyecto
• Asignar integrantes al grupo de trabajo.
• Abandonar un grupo de trabajo.
• Todos los usuarios del sistema podrán:
• Generar peticiones para participar de grupos de trabajos.
• Eliminar las peticiones generadas por ellos mismos.
• Realizar consultas teóricas Online
• Modificación de Datos de usuario
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 42
2.5 Gestión de Grupos
2.5.1 ¿Qué es un Grupo?
Un grupo de trabajo es una forma de agrupar a usuarios, que pasan a ser parte del mismo,
para que trabajen en proyectos colectivos entre sí.
El mismo está formado por al menos 1 integrante, que es quien lo crea.
2.5.2 ¿Quién lo administra y quien puede formar parte del mismo?
El administrador del grupo de trabajo es el creador del mismo.
Cualquier usuario del sistema puede formar parte de cualquier grupo de trabajo. Sin
embargo hay ciertas restricciones.
El administrador puede asignar a cualquier persona registrada en el sistema CAKE. Ver
¿Cómo asignar a un usuario al Grupo? La persona asignada por el administrador, pasa
a formar parte del grupo en forma instantánea.
Cualquier usuario del sistema puede realizar su deseo de participar en el grupo, mediante
una petición de grupo. Ver Gestión de Peticiones de Grupo. Sin embargo, al realizar la
petición de grupo, el usuario no pasa a formar parte del grupo inmediatamente, sino que
debe esperar a que el administrador acepte dicha petición. Ver Gestión de Peticiones de
Grupo.
2.5.3 ¿Qué compone a un grupo?
Un grupo está compuesto por integrantes y por proyectos.
Los integrantes pueden ser 1 Grupo Trabajo Administrador y un Grupo Trabajo
Integrante. Siendo n la cantidad que desee el administrador.
2.5.4 ¿Qué funcionalidades puede hacer?
Las funcionalidades varían según el rol que se tenga dentro el grupo de trabajo.
Bajo el rol de Grupo Trabajo Administrador, las funcionalidades son:
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 43
• Crear, modificar y eliminar grupos de trabajos.
• Asignar y eliminar integrantes al grupo de trabajo.
• Aceptar y rechazar peticiones de grupo de trabajo.
• Crear, modificar y eliminar un proyecto.
Bajo el rol de Grupo Trabajo Integrante, las funcionalidades son:
• Crear, modificar y eliminar un proyecto
• Asignar integrantes al grupo de trabajo.
• Abandonar un grupo de trabajo.
2.5.5 ¿Cómo crear un grupo?
Para crear un grupo de trabajo usted tendrá que acceder al menú principal y bajo la solapa
Grupo de Trabajo, deberá hacer click en Alta.
En la pantalla de Alta de Grupo de Trabajo usted tendrá que registrar un nombre para el
mismo. El nombre deberá ser único en el sistema, lo que quiere decir que si existe un
grupo registrado en el sistema con el mismo nombre que usted desee, el sistema le
informará mediante un mensaje de error.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 44
Una vez que usted registra el grupo, pasa a formar parte del mismo y además pasa a ser el
administrador, permitiéndole hacer todas las funcionalidades descriptas anteriormente en
el punto. ¿Qué funcionalidades puedo hacer?
Para poder acceder al grupo ver. ¿Cómo accedo a un Grupo en el cual soy integrante?
2.5.6 ¿Cómo accedo a un Grupo en el cual soy integrante?
Todos los grupos a los cuales usted pertenece, les aparecerá en la pantalla principal de la
siguiente manera.
Si usted quiere acceder a los grupos que pertenece, deberá dirigirse en el menú principal, a
la solapa Grupo de Trabajo y allí posicionarse sobre listar. Consiguientemente se le
listarán todos los grupos de trabajos a los cuales usted pertenece. Con sólo click en uno,
usted accede al mismo.
2.5.7 ¿Cómo Modificar un Grupo?
Para modificar a un grupo de trabajo, usted deberá ser el administrador del mismo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 45
Para poder acceder a la funcionalidad, deberá primero acceder al grupo de trabajo como se
explicó anteriormente.
Una vez que se encuentra en la ficha del grupo de trabajo, se dirige al menú principal, bajo
la solapa Grupo de Trabajo y hace click en Modificar.
La funcionalidad de modificar cumple los mismos requisitos que el alta.
2.5.8 ¿Cómo Eliminar un Grupo?
Para eliminar un grupo de trabajo, usted deberá ser el administrador y además el grupo de
trabajo no deberá tener ningún proyecto.
Para poder acceder a la funcionalidad, deberá primero acceder al grupo de trabajo como se
explicó anteriormente.
Una vez que se encuentra en la ficha del grupo de trabajo, se dirige al menú principal, bajo
la solapa Grupo de Trabajo y hace click en Eliminar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 46
Una vez que hace click, el grupo se eliminará automáticamente y junto a él todos los
integrantes.
2.5.9 ¿Cómo asignar a un usuario al Grupo?
Para poder acceder a la funcionalidad, deberá primero acceder al grupo de trabajo como se
explicó anteriormente.
Una vez que se encuentra en la ficha del grupo de trabajo, se dirige al menú principal, bajo
la solapa Grupo de Trabajo y hace click en Asignar Integrante.
En la pantalla de Usuario Buscar, primero deberá buscar un usuario perteneciente al
sistema y luego asignarlo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 47
Para asignar al usuario deberá hacer click en Asignar. Al usuario asignado le llegará un
mail con asunto [CAKE] Integrante nuevo al grupo de trabajo: "nombr e del grupo"
Para corroborar que el usuario fue asignado correctamente, puede visualizarlo en el listado
que se encuentra por debajo del cuadro de búsqueda, bajo el nombre de Integrantes. Al
clickear sobre el mismo, se desplegará un listado de todos los integrantes del grupo, en
donde podrá localizar al recién asignado. El listado podrá ser ordenado por todas las
columnas.
2.5.10 ¿Cómo me uno a un Grupo?
Para unirse a un grupo, deberá pararse sobre la pantalla principal.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 48
Una vez que se encuentra en la pantalla principal, se dirige al menú principal, bajo la
solapa Grupo de Trabajo y hace click en Unirse.
Una vez que accede a la funcionalidad de unirse a un grupo de trabajo, primero deberá
buscar al grupo de trabajo y luego podrá unirse.
El campo de búsqueda es auto – completable, para facilitarle a usted la búsqueda de los
grupos.
Esta funcionalidad tiene las siguientes restricciones para unirse al grupo.
• No tiene que ser integrante del mismo.
• No tiene que tener petición pendiente de aceptación.
Si cumple con todas las restricciones, podrá unirse al mismo sin problemas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 49
Finalmente, deberá esperar que el administrador acepte la petición que usted acaba de
realizar. Ver Gestión de Peticiones de Grupo.
En la pantalla principal, usted podrá ver todas las peticiones que tiene pendiente de
aceptación.
2.5.11 ¿Cómo abandono un grupo de trabajo?
Para poder acceder a la funcionalidad, deberá primero acceder al grupo de trabajo como se
explicó anteriormente.
Una vez que se encuentra en la ficha del grupo de trabajo, se dirige al menú principal, bajo
la solapa Grupo de Trabajo y hace click en Abandonar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 50
Requisitos para abandonar un grupo:
• El usuario debe tener el rol de Grupo Trabajo Integrante.
Para corroborar que el abandono del grupo anduvo bien, usted podrá dirigirse a la pantalla
principal y observar que el grupo de trabajo ya no le aparece.
Otra forma es mediante el listado de grupos de trabajos.
Como se observa el grupo de trabajo ORKUT ya no aparece listado ni en la pantalla principal ni en el listado de grupos en el menú.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 51
Gestión de Proyectos
2.5.12 ¿Qué es un proyecto?
Un proyecto, es lo que agrupa y une a un test de viabilidad, un conocimiento estático y un
conocimiento dinámico.
Sólo el conocimiento dinámico de un proyecto determinado podrá alimentarse de un
conocimiento estático del mismo proyecto.
2.5.13 ¿Quiénes tienen permisos y que tipo de permisos?
Todos los integrantes de un grupo de trabajo tienen los mismos permisos sobre todos los
proyectos pertenecientes al mismo grupo de trabajo.
Todas las funcionalidades que un usuario puede hacer sobre un proyecto son:
• Gestionar el Test de Viabilidad
• Gestionar el Conocimiento Estático
• Gestionar el Conocimiento Dinámico
2.5.14 ¿Qué compone a un proyecto?
Un proyecto está compuesto de un test de viabilidad, un conocimiento estático y un
conocimiento dinámico.
2.5.15 ¿Cómo se crea un proyecto?
Para crear un proyecto, primero se debe posicionar sobre la ficha del grupo de trabajo.
Una vez que accede a la ficha del grupo de trabajo, sobre el menú principal, se posiciona
sobre la solapa proyecto y hace click en Alta.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 52
En la pantalla de alta de proyecto deberá llenar todos los campos. El campo nombre es
único dentro del grupo de trabajo. Lo que quiere decir que no debe existir un proyecto de
igual nombre dentro del grupo de trabajo.
Una vez que se crea el proyecto, a todos los integrantes del grupo de trabajo le llegará un
mail con el asunto: [CAKE] Proyecto nuevo: "nombre del proyecto". En el mail se
detalla que integrante creó el proyecto y además todos los datos del mismo.
2.5.16 ¿Cómo accedo a un Proyecto?
Para acceder a un proyecto, primero se debe posicionar sobre la ficha del grupo de
trabajo.
Una vez que accede a la ficha del grupo de trabajo, sobre el menú principal, se posiciona
sobre la solapa proyecto, luego sobre listar y hace click en el nombre del proyecto al cual
se quiere acceder.
2.5.17 ¿Cómo se modifica un proyecto?
Para modificar a un proyecto, primero se debe posicionar sobre la ficha del proyecto a
modificar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 53
Una vez que accede a la ficha del proyecto, sobre el menú principal, se posiciona sobre la
solapa proyecto y hace click en Modificar.
La funcionalidad de modificar cumple los mismos requisitos que el alta.
2.5.18 ¿Cómo se elimina a un proyecto?
Para eliminar a un proyecto, primero se debe posicionar sobre la ficha del proyecto a
eliminar.
Una vez que accede a la ficha del proyecto, sobre el menú principal, se posiciona sobre la
solapa proyecto y hace click en Eliminar.
Para poder eliminar un proyecto se debe cumplir con los siguientes requisitos:
• No debe existir un test de viabilidad.
• No debe existir un conocimiento estático.
• No debe existir un conocimiento dinámico.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 54
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 55
2.6 Gestión de Peticiones de Grupo
2.6.1 ¿Qué es una petición de grupo?
Una petición de grupo es el deseo de un usuario del sistema CAKE de formar parte de un
grupo determinado.
Una vez que la petición es aceptada, el usuario pasa a ser integrante del grupo bajo el rol
de Grupo Trabajo Integrante.
2.6.2 ¿Quién puede realizar una petición de grupo y cómo?
Cualquier usuario del sistema puede realizar una petición de grupo.
• Los requisitos son los siguientes:
• No debe pertenecer como integrante.
• No debe tener petición pendiente de aceptación.
Para realizar una petición de grupo, ver ¿Cómo me uno a un Grupo?
Una vez que se una al grupo, al usuario administrador del grupo le llega un mail con el
asunto [CAKE] Petición nueva de grupo: nombre del grupo.
En la pantalla principal podrá ver todas las peticiones de grupo que están pendientes de
aceptación.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 56
2.6.3 ¿Quién la puede eliminar y cómo?
Una petición de grupo puede ser eliminada sólo por el usuario que la creó.
Para eliminarla, usted se debe para sobre la pantalla, y ahí sobre el listado de peticiones.
Debe apretar Eliminar sobre la petición deseada.
Una vez que usted hace clic sobre eliminar, la misma se elimina instantáneamente. Para
corroborar que se eliminó, accede de nuevo al listado y podrá ver que ya no está más.
Una vez que se elimina la petición, al administrador del grupo al cual se quería pertenecer,
le llega un mail con el asunto [CAKE] Petición de grupo eliminada: nombre grupo.
2.6.4 ¿Quién puede aceptarla y cómo?
La petición de grupo sólo puede ser aceptada por el administrador del mismo.
Para aceptar a la petición, el administrador del grupo deberá ir a la ficha del grupo de
trabajo.
Una vez en la ficha del grupo de trabajo, deberá listar todas las peticiones pendientes de
procesamiento que tiene.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 57
Una vez que el administrador acepta la petición, el usuario que realizó la petición pasa a
ser integrante del grupo permitiéndole trabajar con todos los proyectos.
Instantáneamente, al usuario que realizó la petición le llega vía mail la confirmación de la
aceptación, bajo el asunto [CAKE] Petición de grupo aceptada: nombre del grupo.
El administrador puede corroborar que el nuevo integrante forma parte del grupo mediante
el listado de integrantes que se encuentra en la ficha del grupo de trabajo
2.6.5 ¿Quién puede rechazarla y cómo?
La petición de grupo sólo puede ser rechazada por el administrador del mismo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 58
Para rechazar la petición, el administrador del grupo deberá ir a la ficha del grupo de
trabajo.
Una vez en la ficha del grupo de trabajo, deberá listar todas las peticiones pendientes de
procesamiento que tiene.
Una vez que el administrador rechace la petición al usuario que realizó la petición le llega
un mail informando que el administrador rechazó la petición con el asunto [CAKE]
Petición de grupo rechazada: nombre del grupo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 59
2.7 Gestión de Ayuda Online
2.7.1 ¿Qué es la ayuda Online?
La ayuda online es una asistencia en línea simple sobre el sistema y sobre la metodología
ideal.
2.7.2 ¿Quién puede consultarla y cómo?
Todo usuario del sistema puede consultar la ayuda teórica en línea.
Cada pantalla tiene su propia ayuda teórica y podrá ser consultada haciendo click en el
signo de interrogación que se encuentra en el margen derecho de cada pantalla.
Una vez que se presiona sobre el signo, sale un recuadro sobre la pantalla como el
siguiente, con toda la información que usted necesita.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 60
2.8 Administración.
2.8.1 Administración de Usuario
Para acceder a la administración de usuario, usted tendrá que pararse sobre la pantalla
principal y ahí acceder a la solapa Menú Administrador del menú principal. Luego debe
hacer clic en Modificar Datos.
En la siguiente pantalla, usted únicamente podrá modificar su nombre y su apellido, datos
que usted cargó al registrarse en el sistema.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 61
2.9 Test de Viabilidad
2.9.1 ¿Cómo registro un Test de Viabilidad?
Para registrar un test de viabilidad primero hay que acceder al detalle del proyecto. Ver
¿Cómo accedo a un proyecto?
En el detalle del proyecto, en el menú principal, bajo la solapa de test de viabilidad, haga
click en Alta.
Como restricción importante, un proyecto sólo puede tener un test creado.
En la siguiente pantalla, usted podrá responder las preguntas en su completitud o parciales.
En caso de no contestar ninguna, el test queda registrado, sin ninguna respuesta registrada.
Fig. 4
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 62
Una vez que responde todo lo que desea, debe hacer click en el botón Grabar.
Las preguntas que contienen la leyenda Valor Umbral: son particulares, de no responder
por sobre dicho valor el Test se encontrará en estado no viable; lo que significa que el
proyecto no será viable.
En la figura anterior (Fig. 4), de seleccionarse NO en la primer pregunta, no se estará
cumpliendo con el valor umbral.
Al seleccionar un valor por debajo del umbral el sistema le alertará dicha situación.
2.9.2 ¿Cómo modifico un Test de Viabilidad?
Para modificar un test de viabilidad primero hay que acceder al detalle del proyecto. Ver
¿Cómo accedo a un proyecto?
En el detalle del proyecto, en el menú principal, bajo la solapa de test de viabilidad, haga
click en Modificar.
La pantalla de modificación del test, es exactamente igual al alta. En la modificación,
usted podrá seguir registrando respuestas o modificando las ya registradas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 63
2.9.3 ¿Cómo elimino un Test de Viabilidad?
Para eliminar un test de viabilidad primero hay que acceder al detalle del proyecto. Ver
¿Cómo accedo a un proyecto?
En el detalle del proyecto, en el menú principal, bajo la solapa de test de viabilidad, haga
click en Eliminar
Al hacer click en Eliminar y realizar la confirmación de la eliminación, instantáneamente
el test se eliminará del proyecto.
2.9.4 ¿Cómo accedo a un Test de Viabilidad?
Para acceder a un test de viabilidad primero hay que acceder al detalle del proyecto. Ver
¿Cómo accedo a un proyecto?
En el detalle del proyecto, en el menú principal, bajo la solapa de test de viabilidad, haga
click en Detalle
En la pantalla del detalle, podrá ver los datos del test.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 64
Si se hace click sobre alguno de los cuatro tipos de características del test (plausabilidad,
adecuación, justificación y éxito) se despliega un listado con las preguntas de cada uno de
los tipos, y las respuestas relacionadas con cada una de dichas preguntas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 65
2.9.5 ¿Cómo registrar conclusiones?
Para registrar conclusiones, primero debe acceder al detalle del test. Ver ¿Cómo accedo al
test?
Una vez que está en el detalle del test, haga click en el link conclusiones y agregue todas
conclusiones que desea. Luego haga click en Guardar Conclusiones y las conclusiones de
guardarán sin un submit.
Fig. 5. Al escribir algo en la caja de texto de las conclusiones, se le informa que hubo cambios y puede guardarlos con
el botón Guardar Conclusiones.
Al guardar las conclusiones, si se guardaron con éxito. Se emitirá un mensaje afirmando la
operación.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 66
2.9.6 ¿Cómo cerrar un Test de Viabilidad?
Para cerrar un test, primero deberá acceder a la pantalla de Detalle del test. Ver ¿Cómo
accedo a un Test de Viabilidad?
Dentro de estas pantallas, si usted contestó todas las respuestas, usted podrá cerrar el Test.
Para eso debe hacer click en Cerrar.
El Test debe estar en estado Viable.
Una vez que cierra el test, no podrá modificarlo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 67
2.9.7 ¿Cómo abro un Test de Viabilidad?
Para abrir un test, primero deberá acceder a la pantalla detalle del test. Ver ¿Cómo accedo
a un Test de Viabilidad? Para eso debe hacer click en Abrir Test.
El test no debe estar abierto.
2.9.8 ¿Cómo generar el informe del Test en formato PDF?
Para generar el informe en formato PDF, primero debe acceder al detalle del test. Ver
¿Cómo accedo a un Test de Viabilidad?
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 68
Luego, sobre la pantalla, haga click en el botón Generar PDF
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 69
2.10 Conocimiento Estático
2.10.1 ¿Qué compone al Conocimiento Estático?
El conocimiento estático está compuesto por un Diccionario de Conceptos, una TCAV,
una Tabla de Decisión, Pseudoreglas y por el Árbol de Descomposición Funcional.
2.10.2 ¿Cómo registro un Conocimiento Estático?
Para registrar al conocimiento estático, primero deberá acceder a la ficha del proyecto. Ver
¿Cómo accedo a un Proyecto?
Una vez que usted se encuentra en la ficha del proyecto, en el menú principal posiciónese
sobre la solapa Conocimiento Estático y ahí haga click en Alta.
Automáticamente, el Conocimiento Estático queda dado de alta y las opciones en el menú
cambian y aparecen las siguientes:
2.10.3 ¿Cómo accedo al Conocimiento Estático?
Para acceder al conocimiento estático, primero deberá acceder a la ficha del proyecto. Ver
¿Cómo accedo a un Proyecto?
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 70
Una vez que usted se encuentra en la ficha del proyecto, en el menú principal posiciónese
sobre la solapa Conocimiento Estático y ahí haga click en Detalle.
La pantalla del detalle del conocimiento estático es la siguiente.
2.10.4 ¿Cómo registro el Diccionario de Conceptos?
Para registrar al diccionario de conceptos, primero deberá acceder a la ficha del
conocimiento estático. Ver ¿Cómo accedo al Conocimiento Estático?
Una vez que usted se encuentra en la ficha del conocimiento estático, en el menú principal
posiciónese sobre la solapa Conocimiento Estático, luego en Diccionario de Concepto y
ahí haga click en Alta. También puede hacerlo haciendo click sobre la leyenda
“Diccionaro de Conceptos”.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 71
Una vez que se da de alta al diccionario de conceptos, se le habilitará la opción de
visualizar el diccionario y de dar de alta reglas.
2.10.5 ¿Qué compone al Diccionario de Conceptos?
El diccionario de conceptos está compuesto por todos los conceptos registrados,
mostrando todos los atributos que tiene cada concepto.
2.10.6 ¿Cómo accedo al Diccionario de Conceptos?
Para acceder al diccionario de conceptos, primero deberá acceder a la ficha del
conocimiento estático. Ver ¿Cómo accedo al Conocimiento Estático?
Una vez que usted se encuentra en la ficha del conocimiento estático, en el menú principal
posiciónese sobre la solapa Conocimiento Estático, luego en Diccionario de Concepto y
ahí haga click en Visualizar Diccionario
La siguiente es la pantalla de la ficha del diccionario de conceptos
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 72
2.10.7 ¿Cómo visualizo el diccionario de conceptos en formato PDF?
Para visualizar el diccionario de conceptos en formato PDF, primero deberá acceder al
diccionario de conceptos. Ver ¿Cómo accedo al Diccionario de Conceptos?
En el diccionario de conceptos, haga click en el botón Generar PDF.
2.10.8 ¿Cómo accedo a la TCAV?
Para acceder a la TCAV, primero deberá acceder a la ficha del conocimiento estático. Ver
¿Cómo accedo al Conocimiento Estático?
Una vez que usted se encuentra en la ficha del conocimiento estático, en el menú principal
posiciónese sobre la solapa Conocimiento Estático, ahí haga click en TCAV-
2.10.9 ¿Cómo visualizo la TCAV en formato PDF?
Para visualizar la TCAV en formato PDF, primero deberá acceder a la TCAV. Ver ¿Cómo
accedo a la TCAV?
En la TCAV, haga click en el botón Generar PDF.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 73
2.10.10 ¿Cómo registro un Concepto?
Para registrar un concepto, primero deberá acceder a la ficha del diccionario de concepto.
Ver ¿Cómo accedo al diccionario de conceptos?
Una vez que usted se encuentra en la ficha del diccionario de conceptos, debe hacer click
sobre el botón Ingresar Nuevo.
En la siguiente pantalla, deberá completar todos los datos del concepto.
Como podrá ver, aún no tiene atributos cargados, para cargar atributos Ver ¿Cómo registro
un atributo?
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 74
Una vez que hace clic en registrar, podrá ver que el concepto se registró correctamente,
accediendo al diccionario de conceptos
2.10.11 ¿Cómo modifico un Concepto?
Para modificar un concepto, primero deberá acceder a la ficha del diccionario de concepto.
Ver ¿Cómo accedo al diccionario de conceptos?
Una vez que usted se encuentra en la ficha del diccionario de conceptos, debe hacer click
sobre el link representado por el nombre del concepto que desea modificar.
Luego accede a la siguiente pantalla, donde podrá modificar todos los campos del
concepto.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 75
En la misma pantalla podrá dar de alta nuevos atributos si lo desea. Ver ¿Cómo registro un
atributo?
Para finalizar debe hacer click en el botón modificar.
2.10.12 ¿Cómo elimino un Concepto?
Para eliminar un concepto, primero deberá acceder a la ficha del diccionario de concepto.
Ver ¿Cómo accedo al diccionario de conceptos?
Una vez que usted se encuentra en la ficha del diccionario de conceptos, debe ingresar al
detalle del concepto de la misma forma que en el inciso anterior donde se mostró cómo
modificar.
Luego accede a la siguiente pantalla, donde podrá eliminar todos los campos del concepto.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 76
Para finalizar debe hacer click en el botón eliminar. Debe tener en cuenta que al eliminar
el concepto se elimina los atributos y sus respectivos valores asociados al concepto
eliminado.
2.10.13 ¿Cómo registro un Atributo?
Para poder registrar a un atributo, es necesario estar en la pantalla de alta o detalle de un
concepto.
En el siguiente ejemplo, se muestra la pantalla de alta de un concepto. Tanto en la pantalla
de alta como de modificación de un concepto, debe hacer click sobre el botón Nuevo
Atributo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 77
Una vez que accede a la pantalla de alta de atributo, usted tendrá que completar una
descripción y si lo desea agregar valores del atributo en cuestión.
Para finalizar la carga haga click en Registrar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 78
Cuando se registra el concepto, simultáneamente se registra los atributos.
2.10.14 ¿Cómo modifico un Atributo?
Para modificar un atributo, tanto desde la pantalla de alta o detalle de un concepto, haga
click en el link del atributo.
Usted accederá a la pantalla de detalle del atributo y ahí podrá modificar la descripción
del atributo y agregar o eliminar valores asociados al atributo en cuestión.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 79
Por último haga click en modificar. Para que los cambios tengan efecto, por último deberá
hacer click en modificar en la pantalla de detalle del concepto (tenga en cuenta esto último
ya que de lo contrario, los cambios no se llevarán a cabo).
2.10.15 ¿Cómo elimino un Atributo?
Para eliminar un atributo debe acceder al detalle del concepto, y a través del link en el
nombre de dicho atributo, acceder a la modificación del atributo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 80
Una vez en la modificación del atributo, hacer click sobre el botón Eliminar:
Al presionar el botón Eliminar la aplicación se redirecciona al detalle del concepto. Para
que la eliminación del atributo se haga efectiva, debe presionar finalmente el botón
Modificar.
2.10.16 ¿Cómo registro un Valor de un Atributo?
Para registrar un valor de un atributo, primero deberá ir a la pantalla de alta o
modificación de un atributo.
En la pantalla, debe llenar el campo valor y luego hacer click sobre el botón Agregar
Valor. Si desea eliminar el valor ingresado, haga click en Eliminar Valor. El agregar y
eliminar valor, funciona como un pila, algoritmo LIFO.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 81
Cuando agrega valores, se enlistarán de la siguiente manera.
Los valores se registran simultáneamente con el atributo y estos con el concepto. Por lo
tanto, primero deberá hacer click en registrar atributo y luego registrar concepto. Como se
mencionó antes, también se puede dar de alta desde la pantalla de modificación. La única
diferencia es que debe hacer click en el botón modificar.
2.10.17 ¿Cómo modifico un Valor de un Atributo?
Para modificar un valor, haga click en el link del valor. Deberá estar en la pantalla de
modificación de un atributo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 82
En la siguiente pantalla, usted podrá modificar el valor.
Para confirmar la modificación haga click en el botón Modificar.
Para que la modificación sea efectiva, deberá hacer click en modificar en la pantalla de
modificación del atributo y por último registrar o modificar al concepto.
2.10.18 ¿Cómo elimino un Valor de un Atributo?
Como se comentó anteriormente, el agregado y eliminación de valores de atributos es una
pila (LIFO). Por lo tanto lo que se debe hacer es en la pantalla de modificación de atributo
(o en el caso de un alta de un nuevo atributo) es presionar el botón Eliminar Valor:
Al presionar el botón mencionado previamente observamos como el valor “valor2”
desaparece:
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 83
Para hacer efectiva la eliminación luego debe presionarse el botón Modificar (en el caso
del alta de un nuevo atributo el botón Registrar) y luego en el detalle del concepto volver a
presionar Modificar.
2.10.19 ¿Cómo registro a una Regla?
Para dar de alta una regla deberá tener cargado al menos un concepto condición y un
concepto acción.
Una vez cumplida esta restricción, deberá ir al menú principal, pararse sobre la solapa
conocimiento estático, luego sobre reglas y ahí hacer click sobre alta.
Luego accederá a la pantalla de selección del concepto condición y concepto acción.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 84
Para continuar, debe hacer click en Continuar.
En la pantalla de alta, deberá completar el campo nombre y cargar las condiciones y las
acciones.
Para cargar las condiciones debe seleccionar un atributo del concepto condición y luego su
valor. Por último haga click en Cargar Condición. Para cargar acciones, el mecanismo es
el mismo, pero con el atributo y valor acción.
Las condiciones y acciones cargadas, se van apilando, (FILO). En caso de querer eliminar
alguna condición o acción, haga click en Eliminar Condiciones o Eliminar Acciones.
Por último, haga click en Registrar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 85
2.10.20 ¿Cómo modifico a una Regla?
Para modificar una regla, primero deberá acceder a la tabla de decisión o a las
pesudoreglas.
Ver ¿Cómo accedo a la Tabla de Decisión? O ¿Cómo accedo a las Pseudoreglas?
En el siguiente ejemplo, accedemos desde la tabla de decisión. Haga click en modificar.
La pantalla de modificación opera de la misma manera que el alta.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 86
2.10.21 ¿Cómo elimino a una Regla?
Para eliminar una regla, primero deberá acceder a la tabla de decisión o a las pseudoreglas.
Ver ¿Cómo accedo a la Tabla de Decisión? O ¿Cómo accedo a las Pseudoreglas?
En el siguiente ejemplo, accedemos desde las pseudoreglas. Haga click en eliminar.
Una vez que haga click, la regla se eliminará del sistema.
2.10.22 ¿Cómo accedo a la Tabla de Decisión?
Para acceder a la tabla de decisión, deberá estar primero en el detalle del conocimiento
estático. Ver ¿Cómo accedo al Conocimiento Estático?
Luego sobre el menú principal, sobre la solapa de conocimiento estático, se para sobre
reglas y hace click en Ver Tabla de Decisión.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 87
Accederá a la siguiente pantalla.
2.10.23 ¿Cómo visualizo la Tabla de Decisión en formato PDF?
Para visualizar la tabla de decisión en formato PDF, deberá acceder a la tabla de decisión.
Ver ¿Cómo accedo a la Tabla de Decisión?
En la Tabla de Decisión, haga click en Generar PDF.
2.10.24 ¿Cómo accedo a las Pseudoreglas?
Para acceder a las pseudoreglas, deberá estar primero en el detalle del conocimiento
estático.
Luego sobre el menú principal, sobre la solapa de conocimiento estático, se para sobre
reglas y hace click en Ver Pseudoreglas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 88
Accederá a la siguiente pantalla.
2.10.25 ¿Cómo visualizo las Pseudoreglas en formato PDF?
Para visualizar las pseudoreglas en formato PDF, deberá acceder a las pseudoreglas. Ver
¿Cómo accedo a las pseudoreglas?
En las pseudoreglas, haga click en Generar PDF.
2.10.26 ¿Cómo registro al Árbol de Descomposición Funcional?
Para dar de alta al Árbol de Descomposición Funcional, deberá dirigirse primero al detalle
del conocimiento estático.
Luego sobre el menú principal, sobre la solapa de conocimiento estático, luego sobre
A.D.F y finalmente hace click en Alta.
Automáticamente el árbol quedará creado y le mostrará las posibles acciones a realizar:
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 89
Una vez que dio de alta al menos un nodo, se habilita la opción de visualizar el árbol:
2.10.27 ¿Cómo registro un nodo para el Árbol de Descomposición Funcional?
Al ingresar a la pantalla de alta debe seleccionarse el nodo padre e ingresarse una
descripción. Como se darán cuenta el primer nodo será la raíz con lo cual, no deberá
seleccionar obligatoriamente un nodo padre, pero a partir de los siguiente nodos sí deberá
hacerlo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 90
Una vez seleccionado el padre e ingresada la descripción, se presiona el botón Agregar
Nodo. Tener en cuenta que al presionar el botón el nodo queda dado de alta efectivamente
y queda listado en pantalla:
(NOTA: que en la imagen anterior el botón Visualizar Árbol está deshabilitado, esto es
porque todavía no existe ningún nodo para el árbol)
Como se observa, el nodo queda dado de alta y el botón Visualizar Árbol se habilita.
2.10.28 ¿Cómo visualizo al Árbol de Descomposición Funcional?
Para visualizar el árbol debe presionar desde el detalle del Conocimiento estático o desde
el menú o desde el alta de nodos el acceso a Visualizar Árbol. Tener en cuenta que en la
pantalla de alta de nodos es un botón:
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 91
Luego el árbol se despliega de la siguiente forma (puede demorar algunos cuantos
segundos):
Si se presiona el botón Generar PDF, se desplegará el árbol en formato pdf, en un esquema
de tabla.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 92
2.10.29 ¿Cómo elimino o modifico un nodo para el Árbol de Descomposición Funcional?
Para eliminar o modificar un nodo del árbol deberá acceder a través de link que se
encuentra en el nombre del nodo a eliminar o modificar:
A través del link se accederá al detalle del nodo, donde se puede modificar los datos del
mismo y luego, presionando el bóton Modificar, hacerlos efectivos. O también, puede
presionar el botón Eliminar para que el nodo sea quitado del árbol. Para efectuar esta
última operación el nodo seleccionado debe ser hoja (si selecciona un nodo que no sea
hoja, el botón eliminar no se visualizará):
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 93
2.11 Conocimiento Dinámico
2.11.1 ¿Qué compone al Conocimiento Dinámico?
El conocimiento dinámico está compuesto por un Árbol de Estrategias, y por el Mapa de
Conocimientos.
2.11.2 ¿Cómo registro un Conocimiento Dinámico?
Para registrar al conocimiento dinámico, primero deberá acceder a la ficha del proyecto.
Ver ¿Cómo accedo a un Proyecto?
Una vez que usted se encuentra en la ficha del proyecto, en el menú principal posiciónese
sobre la solapa Conocimiento Dinámico y ahí haga click en Alta.
Automáticamente, el conocimiento dinámico queda dado de alta y las opciones en el menú
cambian y aparecen las siguientes:
2.11.3 ¿Cómo accedo al Conocimiento Dinámico?
Para acceder al conocimiento dinámico, primero deberá acceder a la ficha del proyecto.
Ver ¿Cómo accedo a un Proyecto?
Una vez que usted se encuentra en la ficha del proyecto, en el menú principal posiciónese
sobre la solapa Conocimiento Dinámico y ahí haga click en Detalle.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 94
La pantalla de detalle del conocimiento dinámico es la siguiente:
2.11.4 ¿Cómo registro el Árbol de Estrategias?
Para dar de alta el Árbol Jerárquico, deberá dirigirse primero al detalle del conocimiento
dinámico.
Luego sobre el menú principal, sobre la solapa de conocimiento dinámico, luego sobre
Árbol Jerárquico y finalmente hace click en Cargar.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 95
El Árbol de Estrategias de genera en base a los nodos del Árbol de Descomposición
Funcional desarrollado previamente en el Conocimiento Estático, por lo cual, se le
solicitará que seleccione un nodo de tarea:
Una vez seleccionado el nodo de tarea, debe presionar el botón Continuar.
En la siguiente pantalla, debe seleccionar las entradas, razonamientos y salidas de cada
nodo.
2.11.5 ¿Cómo visualizo el Árbol Jerárquico?
Para visualizar el Árbol Jerárquico, primero deberá acceder al detalle del conocimiento
dinámico.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 96
Una vez en el detalle, debe ir al menú principal, conocimiento dinámico y allí
posicionarse sobre Árbol Jerárquico ->Detalle
Usted verá la siguiente pantalla.
2.11.6 ¿Cómo visualizo al Árbol Jerárquico en formato PDF?
Para visualizar el árbol en formato PDF, primero deberá acceder al detalle del Árbol
Jerárquico.
Una vez allí, haga click en el botón Generar PDF.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 97
2.11.7 ¿Cómo elimino o modifico una entrada, razonamiento o salida en un nodo del
Árbol Jerárquico?
Para modificar o eliminar una entrada, razonamiento o salida en un nodo del Árbol
Jerárquico, debe operar de la misma forma que para darlos de alta, pero presionando en
Elimina Entrada / Salida / razonamiento
2.11.8 ¿Cómo registro nodos para el Mapa de Conocimientos?
Para registrar nodos para el mapa primero se debe tipificar los atributos que van a
componer a los nodos.
Una vez hecho esto se puede dirigir a la opción Cargar del mapa de conocimientos.
En la pantalla de alta deberá seleccionar un atributo para luego setear las relaciones entre
los atributos que conformarán el mapa.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 98
2.11.9 ¿Cómo visualizo el Mapa de Conocimientos?
Una vez realizado esto puedo ir a visualizar el mapa a través de la opción Detalle que se
encuentra en el menú. Lo que se observará será una tabla representativa del Mapa de
Conocimiento.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 99
2.11.10 ¿Cómo visualizo Mapa de Conocimientos en formato PDF?
Para visualizar el mapa en formato PDF, primero deberá acceder al detalle Mapa de
Conocimientos.
Una vez allí, haga click en el botón Generar PDF.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 100
3. Dominio del Problema. Caso de Estudio
Test de Viabilidad sin Herramienta CAKE. En el siguiente ejemplo vamos a representar las preguntas de la dimensión plausibilidad.
Característica P1: Existen expertos, están disponibles y son cooperativos.
Los expertos son un grupo de una universidad de los Estados Unidos y están disponibles para poder consultarles
continuamente.
Valor: SI
Característica P2: El experto es capaz de estructurar sus métodos y procedimientos de trabajo.
Los expertos expusieron sus conocimientos a través de un paper bien detallado, el cual contiene varios anexos
de investigación adicional.
Valor: TODO
Característica P3: La tarea está bien estructurada y se entiende.
Se encuentra estructurada y subdividida. Presenta anexos con preguntas y ejemplos / actividades
correspondientes a cada sector de una organización.
Valor: TODO
Característica P4: Existen suficientes casos de prueba y sus soluciones asociadas.
Si bien no contamos con casos de pruebas brindados por los expertos, hay gran material, bibliografía y artículos
sobre el tema.
Valor: 8
Característica P5: La tarea sólo depende de los conocimientos y no del sentido común.
Si bien la tarea no depende del sentido común, sino del conocimiento que el experto o el especialista fue
tomando en base a su experiencia.
Valor: 7
Test de Viabilidad con Herramienta CAKE.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 101
En el siguiente ejemplo vamos a representar las preguntas de plausibilidad. Vamos a mostrar este ejemplo
con los mismos resultados expuestos en el ejemplo sin Herramienta CAKE.
Ejemplo de Carga:
En las siguientes pantallas se muestra la forma de responder cada pregunta de cada dimensión.
Ejemplo de Vista:
La siguiente pantalla es la forma de cómo se ve el test de viabilidad para la dimensión de plausibilidad.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 102
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 103
Conceptualización sin Herramienta CAKE.
Conocimiento Estático Conocimiento fáctico Diccionario de Conceptos. Usted debe cargar el diccionario de conceptos armando una tabla en algún editor de textos.
Concepto Función Sinónimo Atributos
Estabilidad Mantenerse sin cambios a través del tiempo equilibrio Estable
duración Interfaces
Exhaustividad Completo TBD en especificaciones
Especificar de manera completa todo el contenido del concepto
Falta de especificaciones
Especificaciones no escritas
Interfaces externas definidas
Claridad Facilita la comprensión del problema Simple
Requerimientos escritos
Riesgo
Son los riesgos que puede someterse el proyecto en caso de seguir adelante Inconvenientes Tipo
TCAV
Usted debe cargar la tcav armando una tabla en algún editor de textos. Tiene la desventaja que tiene que ir
copiando los conceptos ingresados en el diccionario de concepto. Además si un atributo en el diccionario de
concepto, deberá cambiar en la TCAV, debiendo ser mantenido por usted a mano.
Concepto Atributo Valor
Estabilidad Estable Si No
Interfaces Si No
Exhaustividad TBD en especificaciones Si No
Falta de especificaciones Si No
Especificaciones no escritas Si
No
Interfaces externas Si
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 104
definidas No Claridad Requerimientos escritos Si No
Riesgo Tipo Catastrófico Crítico Serio Menor
Sin Importancia
Conocimiento Estratégico y Táctico
Tabla de Decisión.
Usted debe ir cargando en tablas todas las reglas creadas Concepto: Estabilidad
Condición R1 R2
Estable Si/No No
Interfaces Si No
Tipo de
Riesgo
Crítico Serio
Concepto: Exhaustividad Condición R3 R4 R5 R6
TBD en especificaciones
No Si Si Si
Falta de
especificaciones
Si/No Si Si/No No
Especificaciones
no escritas
Si/No Si/No Si/No Si
Interfaces externas
definidas
Si/No Si/No No Si
Tipo de Riesgo Crítico Serio Serio Menor
Pseudoreglas.
A partir de las reglas cargadas, usted deberá ir deduciendo las pseudoreglas y pasarlas manualmente a una tabla de algún editor de texto.
Nombre Regla Texto Regla
R1 Si Interfaces = Si entonces severidad de riesgo = Crítico
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 105
R2 Si Estable = No y Interfaces = No entonces severidad de riesgo = Serio
R3 Si TBD en especificaciones = No entonces severidad de riesgo = Crítico
R4 Si TBD en especificaciones =Si y Falta de especificaciones = Si entonces severidad de riesgo = Serio
R5 Si TBD en especificaciones =Si y Interfaces externas definidas = No entonces severidad de riesgo = Serio
R6 Si TBD en especificaciones =Si y Falta de especificaciones = No y Interfaces externas definidas =Si y Especificaciones no escritas =Si entonces severidad de riesgo = Menor
Árbol de Descomposición Funcional.
Usted deberá buscar alguna herramienta para poder graficar los nodos del ábol de descomposición
funcional
Conocimiento Dinámico Mapa de conocimiento
Determinar severidad del riesgo total
P
Determinar riesgos
ocasionados en el área de Ing. de Producto
P
Ingresar atributos del área de Ing. de Producto
P
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 106
Debe identificar manualmente los atributos metas, inferencia y contexto y armar los mapas con algún
software que les permita graficar.
cd Mapa de conocimientos
Tipo de Riesgo
- Catastrófico: - Crítico: - Menor: - Serio: - Sin Importancia:
TDB en especificaciones
- No: - Si:
Falta de Especificaciones
- No: - Si:
Especificaciones no escritas
- No: - Si:
Interfaces externas definidas
- No: - Si:
Árbol Jerárquico
Debe hacer una copia del árbol de descomposición funcional, tomar las reglas, los atributos y empezar a
ingresarlos en los nodos.
cd Árbol jerárquico
Proc 4
- Entrada: Todos los atributos de los conceptos del área Ing. Producto- Razonamiento: No aplica ninguno- Salida: no se genera
Proc 1
- Entrada: Todos los atributos de los conceptos del área Ing. Producto- Razonamiento: Desde R1 a R72- Salida: Tipos de riesgo
Proc 0
- Entrada: Tipos de riesgos de las diferentes áreas - Razonamiento: Tabla de riesgos y frecuencia- Salida: Tipo de riesgo Total
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 107
Conceptualización con Herramienta CAKE.
Conocimiento Estático Conocimiento fáctico Diccionario de Conceptos y TCAV Una vez cargado los conceptos con sus atributos y sus respectivos valores, el diccionario de conceptos y la
TCAV quedan automáticamente generados. Cualquier dato que se modifique impactará en forma
automática en las tablas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 108
Conocimiento Estratégico y Táctico
Tabla de Decisión y Pseudoreglas
Usted selecciona los conceptos condiciones y acciones y ahí va cargando las reglas. Una vez cargadas, tanto la tabla de decisión como las pseudoreglas, quedan automáticamente generadas.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 109
Árbol de Descomposición Funcional.
Sólo deberá cargar los nodos y el árbol se graficará sólo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 110
Conocimiento Dinámico Mapa de conocimiento
Cómo los atributos ya están cargados en el sistema, sólo deberá mencionar qué tipo de atributo es cada
atributo (META, CONTEXTO o INFERENCIA) y relacionarlos con otros.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 111
Árbol Jerárquico
Automáticamente toma los datos del árbol de descomposición funcional y le pide al usuario que cargue las
entradas, razonamiento y salidas y luego grafica automáticamente.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 112
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 113
4. ANEXO I
4.1.1 Propuesta presentada
La propuesta presentada al departamento de computación fue desarrollada como la
práctica de Especificación de Requerimiento de Software IEEE 830. (SRS IEEE 830 en
inglés).
Nota: El siguiente texto está en otra tipo de letra debido a que pertenece a un documento
como antes se mencionó ya presentado.
1- Introducción
1.2- Propósito
El objetivo de este documento es definir alcance y requerimientos de una herramienta Web,
gestor de la metodología IDEAL, metodología para la construcción de sistemas basados en
conocimiento. Este documento no intenta explicar la citada metodología. Su finalidad es
definir los requerimientos para desarrollar las tres principales etapas de la metodología y el
entorno en el que el sistema se desarrolla.
Este documento está realizado para que lo lean los docentes, profesionales y alumnos de la
especialización de Sistemas de Producción de la carrera de Ingeniería en Informática de la
Universidad de Buenos Aires con el propósito de evaluar los beneficios de realizar el Sistema,
identificar las características principales de este trabajo así como proveer una estimación
básica del tiempo y esfuerzo necesario para su desarrollo.
1.3- Alcance
Este sistema da la posibilidad de realizar el estudio de viabilidad, la etapa de
conceptualización que incluye la modelización de conocimientos fácticos, estratégicos y
tácticos y la generación del modelo dinámico.
El estudio de Viabilidad permitirá detectar si el desarrollo es posible, justificado, adecuado y
si va a tener éxito.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 114
En la etapa de conceptualización, el conocimiento fáctico incluye el diccionario de concepto y
tabla de concepto – atributo – valor. Los conocimientos estratégicos permiten identificar el
diagrama jerárquico de tareas (Árbol de descomposición funcional), el conocimiento táctico
incluye la tabla de decisión y seudoreglas. Finalmente, la generación del modelo dinámico
incluye el árbol de estrategias (grafo causal) y mapa de conocimientos.
El sistema estará desarrollado para un entorno Web, los datos de los diferentes estudios,
podrán ser persistidos. El sistema brindará diversos reportes on-line en las distintas etapas
antes descriptas.
1.4- Contexto del sistema
El sistema no interactuará con ningún otro sistema.
1.5- Principales Interesados
La siguiente es una lista de áreas interesadas en el uso del sistema.
Rol Principal interesado Interesados
Dr.Ramón Dra. Paola
Britos
M. Ing.
Hernán
Merlino
Docente Laboratorio de
sistemas inteligentes
M. Ing.
Enrique
Fernandez
Alumno Alumno del
departamento
Alumno del
departamento.
1.6- Acrónimos y Abreviaciones
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 115
Acrónimos /
Abreviaciones
Descripción
API Application Programmers Interface
DBMS Database Management System
FR Functional requirement
GUI Graphical User Interface
LAN Local-Area Network
NFR Non-functional requirement
SRS System Requirements Specification
WAN Wide-Area Network
WUI Web-based User Interface
1.7- Referencias
GARCIA MARTINEZ, BRITOS. “Ingeniería de Sistemas Expertos”. Primera edición.
Buenos Aires. Nueva Librería, 2004.
Laboratorio de Sistemas Inteligentes. Facultad de Ingeniería. Universidad de Buenos Aires.
http://laboratorios.fi.uba.ar/lsi. Vigencia Nov. 2008
2- Restricciones y Supuestos
El sistema será una aplicación Web.
Se supone que la Facultad de Ingeniería nos facilitará un servidor Web para instalar la
aplicación.
2.1- Restricciones de entorno
• El sistema será desarrollado en Python.
• El sistema será a código abierto.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 116
• Compatible con los browsers Mozilla FireFox e Internet Explorer.
• La aplicación tendrá un tamaño menor a 500 MB.
3- Requerimientos Funcionales
3.1- Módulo “Viabilidad” comprende los requerimientos:
IDENTIFICADOR DE
REQUERIMIENTO:
F-VIAB
Nombre:
Test de Viabilidad de un sistema basado en
conocimiento y/o sistema experto.
Responsable: Pablo Bragán
Descripción:
� Se requiere que el sistema:
o Realice los cálculos del test de viabilidad para determinar si el SBC o SE es posible,
justificado, adecuado y exitoso.
o Soporte intervalos difusos e intervalos binarios para responder a cada característica dentro
de cada dimensión.
o Brinde de ayuda teórica para responder cada dimensión.
o En base a cada dimensión, soporte el ingreso del valor de cada característica y su análisis
descriptivo.
o Brinde para cada dimensión tenga una presentación de resultados en una tabla
acompañados de sus respectivos gráficos.
o Presente los resultados finales en una tabla acompañados de sus respectivos gráficos.
o Permita al usuario la posibilidad de ingresar sus propios comentarios y conclusiones.
o Tenga la capacidad de realizar reportes de los análisis, resultados parciales, resultados
finales y exposición de conclusiones del usuario. Dicho reportes tienen que estar diseñados para
ser impresos.
o Permita que el test realizado deberá ser persistente, en forma parcial y/o total.
o Brinde la posibilidad de eliminación, modificación de test ya realizados.
3.2- Módulo “Conocimiento Estático” comprende los requerimientos:
IDENTIFICADOR DE
REQUERIMIENTO:
F-DICCCONCEP
Nombre:
Diccionario de Conceptos – Conocimiento
Fáctico – Modelo Estático
Responsable: Mariano Kfuri
Descripción:
� Se requiere que el sistema:
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 117
o Permita el agregado de conceptos, su modificación y eliminación.
o Para cada concepto permita especificar su función, sinónimos, atributos y de dónde se
derivan los valores de dichos atributos.
o Permita visualizar los conceptos agregados, con todos sus atributos, en un listado.
o Permita agregar o modificar conceptos y que brinde una ayuda.
o Permita que todos los conceptos generados en el diccionario aparezcan en la Tabla Atributo
Valor, así como modificaciones y eliminaciones.
o Realice reportes del diccionario de conceptos que permitan ser impresos.
o Permita separar los conceptos que definen condición del problema de aquellos que definen
la acción del mismo.
IDENTIFICADOR DE
REQUERIMIENTO:
F-TABLAATRVAL
Nombre:
Tabla Atributo Valor – Conocimiento Fáctico –
Modelo Estático
Responsable: Mariano Kfuri.
Descripción:
� Se requiere que el sistema:
o Muestre en la tabla de atributo valor, los conceptos que ya han sido agregados en el
diccionario de conceptos.
o Permita que en la tabla solo se ingrese o modifique el valor y la sigla (Los conceptos y
atributos deberán ser agregados automáticamente por el sistema)
o Realice reportes de la Tabla Atributo Valor para realizar su impresión.
IDENTIFICADOR DE
REQUERIMIENTO:
F-SEUREG
Nombre:
Seudoreglas – Conocimiento Táctico – Modelo
Estático
Responsable: Mariano Kfuri.
Descripción:
� Se requiere que el sistema:
o Genere automáticamente el listado de Seudoreglas a partir de la Tabla de Decisión.
o Realice un reporte de las Seudoreglas en formato tal que permita la impresión.
o Restrinja el alta de Seudoreglas y su modificación. Solo pueden modificarse o agregarse
modificando la Tabla de Decisión.
IDENTIFICADOR DE
REQUERIMIENTO:
F-TABDEC
Nombre:
Tabla de Decisión – Conocimiento Táctico –
Modelo Estático
Responsable: Mariano Kfuri.
Descripción:
� Se requiere que el sistema:
o Genere por cada concepto una tabla de decisión.
o Permita el agregado de reglas relacionada a un concepto condición, en donde por cada
atributo del concepto se cargue el valor, el cual debe estar en la tabla concepto atributo valor.
o Solicite al usuario a relacionar un concepto condición a uno o más conceptos acción.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 118
o No permita reglas de igual nombre.
o No permita que haya reglas con iguales valores, para evitar duplicidad y ambigüedad.
IDENTIFICADOR DE
REQUERIMIENTO:
F-ARBDESCFUNCIONAL
Nombre:
Árbol de descomposición funcional –
Conocimiento Estratégico – Modelo Estático
Responsable: Luciano Hammoe
Descripción:
� Se requiere que el sistema:
o Permita agregar nodos de tareas con un número de orden y descripción para que el usuario
pueda representar las estrategias que a seguir.
o No permita número de orden repetido.
o Muestre los nodos agregados por el usuario en forma de árbol con un solo nodo raíz, que un
nodo padre tenga varios hijos.
o Represente nodos descendientes para un número de orden x como x.n siendo n, la cantidad
de nodos en el nivel siguiente.
o Genere un diagrama de árbol con formato tal que pueda ser impreso por el usuario.
3.3 Módulo “Conocimiento Dinámico” comprende los requerimientos:
IDENTIFICADOR DE
REQUERIMIENTO:
F-ARBESTR
Nombre:
Árbol de Estrategias – Modelo Dinámico
Responsable: Luciano Hammoe
Descripción:
� Se requiere que el sistema:
o Genere automáticamente el árbol de estrategias basado en los datos cargados en el Árbol de
descomposición funcional.
o Requiera para cada nodo, generado automáticamente: ingresar y modificar los datos de
Entrada, Razonamiento y Salida.
o Valide que la Entrada sean los atributos que figuran en el diccionario de conceptos y en la
tabla de concepto atributo valor.
o Valide que los datos cargados en Razonamiento sean Seudoreglas existentes.
o Se requiere que la Salida sean atributos definidos en el diccionario de conceptos y en la
tabla de concepto atributo valor.
o Represente a la falta de razonamientos como “No Corresponde”.
o Genere un diagrama con formato tal para que el usuario pueda realizar su impresión.
IDENTIFICADOR DE
REQUERIMIENTO:
F-MAPCONOC
Nombre:
Mapa de Conocimientos – Modelo Dinámico
Responsable: Luciano Hammoe
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 119
Descripción:
� Se requiere que el sistema:
o Genere los atributos meta, y atributos de inferencia y de contexto automáticamente.
o Permita unir los atributos meta y atributos no meta con dos tipos de uniones: de inferencia
y de contexto.
o Relacionar los atributos meta con uniones de inferencia.
o Genere un diagrama sea un mapa y que tenga formato tal que el usuario pueda imprimirlo.
3.4- Módulo “Gestor del Proyecto” comprende los requerimientos:
IDENTIFICADOR DE
REQUERIMIENTO:
F-PROYECTO
Nombre:
Proyecto
Responsable: Pablo Bragan.
Descripción:
� Se requiere que el sistema:
o Permita mantener diferentes proyectos.
o Permita identificar cada proyecto por usuario dueño y un nombre.
o Validar que los proyectos estén compuestos por un único test de viabilidad, un único
modelo estático y un único modelo dinámico de conocimientos. No es necesario que existan las
tres etapas de la metodología IDEAL.
o Permita que todos los datos de los proyectos se persistirán, como así también los datos del
test de viabilidad y de los modelos estático y dinámico.
IDENTIFICADOR DE
REQUERIMIENTO:
F-AYTEORICA
Nombre:
Ayuda teórica.
Responsable: Pablo Bragan.
Descripción:
o Se requiere que el sistema incorpore ayuda teórica sobre cada uno de las etapas de la
metodología IDEAL.
4- Requerimientos no Funcionales
Req. Code Requirement Description
NF-NAV Navegación entre pantallas.
NF-ESCA Escalabilidad del sistema.
NF-SEGU Seguridad en el acceso de usuarios
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 120
4.1- Escalabilidad
NF-ESCA Escalabilidad del sistema.
• El sistema se desarrollará en módulos que se irán integrando a medida que se avance en
el proyecto. El primer de los módulos a entregar será el de Viabilidad y luego se
complementará el proyecto con las fases restantes de la metodología que se especificaron
previamente.
• Como esta no es una herramienta que cubre todas las fases de la metodología IDEAL, se
dejará la posibilidad de poder desarrollar a futuro nuevos módulos sin necesidad de
modificar el modelo actual.
4.2- Seguridad
NF-SEGU Seguridad en el acceso de usuarios
• Se desarrollará un menú de acceso a través del cual se validará el log in a la aplicación
mediante un usuario y una contraseña. Con esto garantizamos que cada usuario tenga
acceso a sus proyectos y que la creación y/o modificación de los mismos recaiga sobre
dicho usuario.
4.3- Usabilidad
NF-NAV Navegación entre pantallas.
• Se requiere desarrollar navegabilidad en las diferentes pantallas del sistema, utilizando
links de acceso rápido y permitiendo observar el detalle de los diferentes elementos
cargados en las distintas etapas de la metodología.
• Se desarrollará un menú de acceso rápido a cada proyecto y a cada módulo desarrollado.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 121
5- Glosario del Proyecto
Término Definición
CAKE Computer Aided Knowledge Engineering
metodología IDEAL Metodología para llevar a cabo un Sistema Basado en
Conocimiento. IDEAL es una sigla que significa:
Identificación de la tarea; Desarrollo de los prototipos;
Ejecución de la construcción del sistema integrado;
Actuación para conseguir el mantenimiento perfectivo;
Lograr una adecuada transferencia tecnológica. Cada
una de éstas es una fase de la metodología.
ingeniero de conocimiento
(IC)
Ingeniero o técnico informático especialista en la
construcción de SS.BB.CC y SS.EE.
estudio de Viabilidad Pertenece a la fase I (Identificación de la tarea) de la
metodología IDEAL. Es un estudio basado en una serie
de aseveraciones en donde un ingeniero de
conocimiento evalúa a través de un puntaje cuánto se
cumple o no dichas aseveraciones. A través de esta
realización se determina si el sistema será exitoso o no.
etapa de conceptualización Forma parte de la fase II de la metodología IDEAL y
consiste básicamente en el entendimiento del dominio
del problema y de la terminología usada. Esta etapa
permite al IC formar un marco inicial o mapa mental
del dominio de la aplicación.
conocimiento fáctico Especifica los datos que el sistema necesita de entrada,
salida y para realizar las distintas tareas.
diccionario de concepto Describe las características de cada uno de los
conceptos involucrados en el sistema.
tabla de concepto –
atributo – valor
Describe los conceptos relevantes para la tarea del SE.
Identifica los atributos que describen los conceptos y
sus valores.
conocimientos estratégicos Especifican qué hacer, dónde y por qué hacerlo, es
decir, fijan la secuencia de pasos que el SE deberá
seguir para ejecutar su tarea.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 122
Término Definición
diagrama jerárquico de
tareas (Árbol de
descomposición funcional)
Ilustra cómo puede descomponerse la tarea del SE en
pasos y subpasos modulares, y en metas y submetas.
conocimiento táctico Se los conoce como conocimiento de acción u
operativos también. Especifican cómo y cuándo el SE
puede añadir a sus conocimientos genéricos
información actual acerca del caso.
tabla de decisión Describe cómo el SE puede usar dos atributos básicos
para inferir un atributo conclusión particular.
seudoreglas Describe una colección de pautas de propósito especial
relacionadas que no siguen una estructura estándar.
modelo dinámico Integra los conocimientos fácticos, estratégicos y
tácticos en: mapa de conocimientos y árbol de
estrategias.
árbol de estrategias (grafo
causal)
Integra los tres tipos de conocimientos del modelo de
conocimientos estáticos en un árbol que contiene en
cada nodo una de las estrategias definidas en el
diagrama jerárquico de tareas.y a su vez cada nodo está
unido de forma tal que las estrategias lleven a cabo el
objetivo del sistema.
mapa de conocimientos Es similar a un mapa mental. Representa el proceso de
inferir valores de los atributos. Los enlaces entre los
atributos y los valores inferidos forman una parte
importante de los conocimientos.
SBC Sistema informático basado en el conocimiento
público.
dimensión (test de
viabilidad)
Define al tipo de aseveración del test de viabilidad.
Existen cuatro dimensiones en el conjunto de
aseveraciones: plausiblidad, justificación, adecuación y
éxito.
SE Sistema basado en conocimiento cuyas prestaciones
intentan emular a la de los expertos humanos. En otros
términos, los sistemas expertos son programas de
computadora que aplican conocimientos sustanciales
de áreas específicas de experiencia a la solución del
problema.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 123
Término Definición
Atributo Meta (Mapa de
conocimientos)
Son aquellos atributos que definen una decisión a
tomar en base al resto de los atributos.
Atributo Inferencia (Mapa
de conocimientos)
Atributos que ayudan a inferir la decisión meta
Atributo contexto (Mapa
de conocimientos)
Aquellos atributos que no infieren en la resolución del
problema pero le dan entorno y contexto al mismo.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 124
5. ANEXO II
5.1 Casos de Usos
El sistema se divide en 5 módulos. Dos módulos son de gestión y 3 módulos de negocio.
Módulos de gestión:
• 01- Gestor del Proyecto. A la vez este módulo se divide en los siguientes sub-
módulos
o 01.01- Acceso Al Sistema.
o 01.02- Gestor Proyecto Grupo Trabajo Administrador.
o 01.03- Gestor Proyecto Grupo Trabajo Integrante.
• 05 – Administración
Módulos de negocio:
• 02- Viabilidad
• 03- Conocimiento Estático
• 04- Conocimiento Dinámico
Los usuarios que interactúan con los diferentes casos de usos son:
• App Administrador
• Grupo Trabajo Administrador
• Grupo Trabajo Integrante
Diagramas de actores
ud Actors
Grupo Trabajo Integrante
Grupo Trabajo Administrador
App Administrador
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 125
Diagramas de casos de usos
01- Gestor del Proyecto - 01.01- Acceso Al Sistema.
ud Acceso Al Sistema
App Administrador
(from Actores)
Grupo Trabajo Integrante
(from Actores)
01.01- Login
01.09- Registrar Usuario
01.10- Login Administrador
«extend»
01- Gestor del Proyecto - 01.02- Gestor Proyecto Grupo Trabajo Administrador.
ud Gestor Proyecto Grupo Trabajo Administrador
Grupo Trabajo Administrador(from Actores)
01.03- Crear Grupo de Trabajo
01.07- Aceptar Petición
(from 01.03- Gestor Proyecto Grupo Trabajo Integrante)
01.06- Ver Grupo de Trabajo
01.15- Modificar Grupo de Trabajo
01.16- Eliminar Grupor de Trabajo
01.17- Rechazar Petición
01.18- Eliminar Integrante
(from 01.03- Gestor Proyecto Grupo Trabajo Integrante)
01.20- Eliminar Petición
«include»
«include»
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 126
01- Gestor del Proyecto - 01.03- Gestor Proyecto Grupo Trabajo Integrante
ud Gestor Proyecto Integrante
Grupo Trabajo Integrante
(from Actores)
01.02- Crear Proyecto
01.04- Asignar Integrante a Grupo
01.05- Petición de Grupo
01.08- Consultar Ayuda Teórica
01.11- Modificar Usuario
01.06- Ver Grupo de Trabajo
01.12- Ver Proyecto
01.13- Modificar Proyecto
01.14- Eliminar Proyecto
01.19- Dejar Grupo de Trabajo
01.20- Eliminar Petición
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 127
02- Viabilidad
ud 02- Viabilidad
Grupo Trabajo Integrante
(from Actores)
02.01- Crear Test Viabilidad
02.02- Visualizar Resultados Finales
02.03- Agregar análisis
02.05- Realizar Informe
02.06- Realizar Conclusiones
02.08- Eliminar Test
02.07- Modificar Test
02.04- Visualizar Test
02.09- Cerrar Test
«include»
«precedes»
«include»
«precedes»«precedes»
«precedes»
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 128
03- Conocimiento Estático
ud 03- Conocimiento Estático
Grupo Trabajo Integrante
(from Actores)
03.06- Crear Conocimiento
Estático 03.07- Crear Diccionario de
Concepto
03.15- Visualizar Diccionario de
Concepto
03.01- Administrar Concepto
03.11- Imprimir
03.17- Visualizar TCAV
03.04- Administrar atributos
03.16- Visualizar Seudoreglas
03.03- Administrar Reglas
03.18- Visualizar Tabla de Decisión
03.09- Crear Árbol de Descomposición
Funcional
03.19- Visualizar Árbol de
Descomposición Funcional
03.02- Administrar Nodos de tareas
03.20 - Cerrar Conocimiento
Estatico
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
«precedes» «precedes»
«precedes»
«precedes»
«precedes»
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 129
04- Conocimiento Dinámico
ud 04- Conocimiento Dinámico
04.01- Crear Conocimiento
Dinámico
04.03- Modificar Árbol de Estrategia
04.04- Generar Informe
04.02- Visualizar Arbol Estratégico
04.05- Visualizar Mapa de
Conocimiento
04.06- Modificar Mapa de
Conocimiento
Grupo Trabajo Integrante
(from Actores) 04.07- Imprimir
04-08- Registrar Entrada/Razonamiento/Salida
04.09- Tipificar Atributos
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
«precedes»
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 130
05- Administración
ud 05 - Administración
App Administrador
(from Actores)
05.01- Registrar Administrador
05.02 - Registrar Dimensión
05.03 . Registrar Pregunta
05.04 - Generar Naturaleza
5.1.1 Diagramas de Dominio
El dominio fue dividido en 4 paquetes:
• 01-Gestor del Proyecto.
• 02-Viabilidad.
• 03- Conocimiento Estático
• 04- Conocimiento Dinámico
Hay que aclarar que todos las clases extienden de la clase Model, perteneciente al App
Engine, paquete google.appengine.ext.db.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 131
01-Gestor del Proyecto
cd 01- Gestor del Proyecto
google.appengine.api.User
+ mail() : String+ nickname() : String
Usuario
- apel lido: String- isAdministrador: Booleana- mail : String- nickname: String- nombre: String
GrupoDeTrabajo
- estado: String- fechaAlta: datetime.datetime- nombre: String- usuarioAlta: Usuario
Proyecto
- estado: String- fechaAlta: datetime.datetime- fechaFinalizacion: datetime.datetime- fechaInicio: datetime.datetime- nombre: String- usuarioAlta: Usuario
Peticion
- estado: String
Integrante
- estado: String- isAdministrador: Booleana
Estado:- Nuevo: N- Eliminado : E
Estados:- Nueva: N- Procesada: P- Rechazada: R- Eliminada: E
0..1
1
1
usuarioAlta0..*
0..*
+usuarioAlta
1
0..*
1
0..*
1
0..*1
1..*
1
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 132
02-Viabilidad
cd 02- Viabilidad
TestViabilidad
- estado: String- fechaAlta: datetime.datetime- usuarioAlta: Usuario
01-Gestor del Proyecto::Proyecto
- estado: String- fechaAlta: datetime.datetime- fechaFinalizacion: datetime.datetime- fechaInicio: datetime.datetime- nombre: String- usuarioAlta: Usuario
Pregunta
- denominacion: String- orden: int- peso: int- pregunta: String- tipo: Dimension- valorUmbral: String
Los estados del test son:NUEVOPROCESADOCERRADOELIMINADO
Naturaleza
- tipo: String- valores: var
Booleana DifusaNumericaSi valorUmbral es nulo, entonces no tiene umbral.Si tiene umbral, entonces la pregunta es escencial
Respuesta
- analisis: String- valor: String
Dimension
- peso: int- tipo: String
01-Gestor del Proyecto::Usuario
- apell ido: String- isAdministrador: Booleana- mail: String- nickname: String- nombre: String
1
usuarioAlta
0..*
1
0..*
1
usuarioAlta
11
1
1..* 1
0..*
tipo
1
0..* 1
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 133
03- Conocimiento Estático
cd 03- Conocimiento Estatico
01-Gestor del Proyecto::Proyecto
- estado: String- fechaAlta: datetime.datetime- fechaFinalizacion: datetime.datetime- fechaInicio: datetime.datetime- nombre: String- usuarioAlta: Usuario
ConocimientoEstatico
- estado: String- fechaAlta: datetime.datetime- usuarioAlta: Usuario
01-Gestor del Proyecto::Usuario
- apellido: String- isAdministrador: Booleana- mail: String- nickname: String- nombre: String
Estados del CE:NUEVO (N)CERRADO (C)
DiccionarioConcepto
- estado: String
Concepto
- deriva: Concepto- estado: String- funcion: String- nombre: String- sinonimo: StringListProperty- tipo: String
Atributo
- descripcion: String- estado: String- tipo: String
ValorAtributo
- descripcion: String- estado: String
Estado del DC:NUEVO.
Estado de los conceptos, atributos y valoresNUEVOELIMINADO
Regla
- conceptoAccion: Concepto- conceptoCondicion: Concepto- estado: String- nombre: String
Estado de Regla:NUEVOCONFLICTOELIMINADO
ReglaValorAtributo
ArbolDF
- estado: String
NodoTarea
- descripcion: String- estado: String- padre: NodoTarea
Estado de los nodos:NUEVOELIMINADO
Cuando orden = 0 es la raiz
+padre 1..*
+hijo 1
1..*
1
0..1
1
0..*
1
1 1..*
0..*
+conceptoAccion
1
0..*
+conceptoCondicion1
1
0..1
0..*
1
0..*1
+deriva0..1
+derivado0..*
1
0..*
1
usuarioAlta
0..*
1
usuarioAlta
0..*
1
0..*
1
0..1
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 134
04- Conocimiento Dinámico
cd 04- Conocimiento Dinámico
01-Gestor del Proyecto::Proyecto
- estado: String- fechaAlta: datetime.datetime- fechaFinalizacion: datetime.datetime- fechaInicio: datetime.datetime- nombre: String- usuarioAlta: Usuario
ConocimientoDinamico
- estado: String- fechaAlta: datetime.datetime- usuarioAlta: Usuario
01-Gestor del Proyecto::Usuario
- apellido: String- isAdministrador: Booleana- mail: String- nickname: String- nombre: String
Razonamiento
03- Conocimiento Estatico::Regla
- conceptoAccion: Concepto- conceptoCondicion: Concepto- estado: String- nombre: String
UnionMapaConocimiento
- destino: Atributo- origen: Atributo
03- Conocimiento Estatico::Atributo
- descripcion: String- estado: String- tipo: String
NodoAtributo
- tipo: String03- Conocimiento
Estatico::NodoTarea
- descripcion: String- estado: String- padre: NodoTarea El nodo atributo simboliza la entrada
o la salida:Los tipos pueden ser:- ENTRADA: E- SALIDA: S
Tipos Atributos:M: MetaC: ContextoI: inferencia
0..*
1
1
0..*
+padre 1..*
+hijo 1 10..*
1
+destino 1
1
+origen 1
0..* 1
1 0..*
0..*
+usuarioAlta
11
0..1
5.1.2 Implementación de SessionContext
A continuación se podrá ver el diagrama de clases de la solución planteada, como además
diagramas de actividad y una simple reseña de cómo usar el contexto en sesiones.
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 135
Diagrama de clases:
cd Session
SessionHandlerMiddleWare
+ process_request(HttpRequest) : response
SessionManager
- session: - session_context: - session_exception:
+ __init__(django_ae_utils.sessions.backends.datastore) : void+ auto_clean_session() : void+ cargar_contextos() : void+ clean_session() : void+ dar_contextos() : void+ eliminar_contexto(String) : void+ get_atributo(String, String) : void+ is_exception(String) : void+ set_atributo(<anytype>, String, String) : void+ validar_contexto(String, StringList) : void
Views View: Es cualquier tipo de vista que necesite sacar o poner datos en session
sessionContext.py
- context: DiccionarioConcepto- exeption: DiccionarioConcepto
sessionContext.py: En realidad no es una clase, es un módulo, pero no se como documentarlo, por lo que lo pongo como una clase
Diagrama de actividades:
• Proceso ejecutado mediante Middleware
ad Business Process Model
Request
CargarContextos
v alidarContexto
obtenerContextos
¿Contexto Valido?
eliminarContexto
¿Hay más contextos?
Auto Clear Sesion
Continua Request
[Si]
[No]
[Si][No]
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 136
• Método get_Atributo:
ad get_Atributo
Busco elatributo ensession y contexto
Busco atributo encontexto GLOBAL
¿Contexto = None?
¿Existe Contexto?
Busco atributo encontexto pasado por
parámetro
Arrojar ExceptionInv alidContextValueException
(from Set_Atributo)
ActivityFinal
[si][No]
[Si][No]
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 137
• Método set_Atributo:
ad Set_Atributo
Cargar Atributo ensession y contexto
¿Contexto = None?
Setear Atributo encontexto GLOBAL
¿Existe Contexto?
Setear Atributo encontexto pasado por
parámetroArrojar Exception
Inv alidContextValueException
[No] [Si]
[No] [Si]
Instructivo para usar SessionManager.
1) Crear el contexto en cake.fiuba.conf.sessionContext.py
context = {'GrupoTrabajo':[r'^cake/alta_proyecto/$',
r'^cake/proyecto/(\d+)/ficha/$',
],
'Peticiones':[r'^cake/peticion/(\d+)/eliminar/$',],
'AsignarIntegrante':[r'^cake/asignar_integrante/alta/$',],
'UnirseGrupo':[r'^cake/unirse_grupo_trabajo/alta/$',],
'Proyecto':[r'^cake/proyecto/modificar/$',
r'^cake/proyecto/eliminar/$',
],
}
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 138
La variable context es un diccionario, en el cual las claves son los nombre de los
contextos de la sesion y los valores de los mismos es una lista de patrones de
expresiones regulares en las cuales toda url que matchee con el patrón se dice que debe
contener poder usar las cosas cargadas en la sesión. Caso que no matchee, se borrará
todos los datos en sesión del contexto.
2) Es importante tener en cuenta desde que url se va a poder acceder a los atributos
cargados en los contextos.
3) El contexto global no se encuentra en este archivo, ya que es global a toda la
aplicación.
4) El contexo en el diccionario no puede ser una lista vacía, si el contexto no se usa en
ningún lado, entonces no se usa por lo tanto no es necesario que exista.
5) Todas las url que no requieren del manejo de sessiones o no deben borrarse como por
ejemplo las url llamadas por ajax, deben agregarse a las excepciones dentro del
archivo cake.fiuba.conf.sessionContext.py.
exeption = [r'^cake/ajax/unirse_gt/$',
r'^cake/ajax/combo_pregunta_naturaleza/$',
r'^cake/ajax/combo_pregunta_dimension/$',
r'^cake/ajax/valor_umbral/$',]
6) Para que desde una url se haga un auto_clear de la session, se debe poner la
expresión regular de la url en el mismo archivo dentro de la variable
clear = [r'^cake/$',]
Herramienta CAKE: Computer Aided Knowledge Engineering
Bragán – Hammoe - Kfuri Pág. 139
6. Referencias
• “Ingeniería de Sistemas Expertos”. García Martínez, R. y Britos, P. 2004. Editorial Nueva Librería. 649 páginas. ISBN 987-1104-15-4
• http://code.google.com/intl/es-AR/appengine/docs/python/gettingstarted/
• http://docs.djangoproject.com/en/1.0//
• http://www.djangobook.com/en/1.0/
• http://aralbalkan.com/1311
• http://jquery.com/
• http://www.dojotoolkit.org/
• http://www.djangosnippets.org/snippets/
• http://www.42topics.com/dumps/django/docs.html
• “Advanced Python Programming”. David M. Beazley. Department of Computer
Science University of Chicago. O’Reilly Open Source Conference. July 17, 2000
• “Core Python Programming”. Wesley J. Chun -Publisher: Prentice Hall PTR. First
Edition December 14, 2000. ISBN: 0-13-026036-3, 816 pages.
top related