HERRAMIENTA CAKE: COMPUTER AIDED...

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.



Í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



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



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



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



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.



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



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.



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.



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.



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,



• 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



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



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



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



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



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.



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 .



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)

"""



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



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



- 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



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 protected] 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>



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.



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



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=...



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.



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.



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.



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



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



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=...



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.



--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.



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)



• 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.



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.



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



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:



• 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.



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.



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.




la solapa Grupo de Trabajo y hace click en Eliminar.



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?




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.



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.



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.



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?




la solapa Grupo de Trabajo y hace click en Abandonar.



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ú.



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.



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.



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.



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.



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.



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.



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.



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.



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.



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



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



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.



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



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



click en Detalle

En la pantalla del detalle, podrá ver los datos del test.



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.



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.



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.



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?



Luego, sobre la pantalla, haga click en el botón Generar PDF



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?




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”.



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?


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



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?


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.



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?



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.


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.



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.


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.



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.



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.



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.



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.



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.



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.



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:



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.



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.



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.



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.



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.



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:



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.



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:



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.



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á):



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?


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?


sobre la solapa Conocimiento Dinámico y ahí haga click en Detalle.



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.



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.



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.



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.



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.



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.



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.



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.



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



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



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



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



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.



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.



Árbol de Descomposición Funcional.

Sólo deberá cargar los nodos y el árbol se graficará sólo.



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.



Á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.



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.



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



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.



• 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:




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:


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


Descripción:


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


Descripción:


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.



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:


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


Descripción:


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




Descripción:


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:


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



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.



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.




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.




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.



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



Diagramas de casos de usos

01- Gestor del Proyecto - 01.01- Acceso Al Sistema.

ud Acceso Al Sistema

App Administrador

(from Actores)


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

.



01- Gestor del Proyecto - 01.03- Gestor Proyecto Grupo Trabajo Integrante

ud Gestor Proyecto 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»



02- Viabilidad

ud 02- Viabilidad


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



03- Conocimiento Estático

ud 03- Conocimiento Estático


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



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


(from Actores) 04.07- Imprimir

04-08- Registrar Entrada/Razonamiento/Salida

04.09- Tipificar Atributos

«precedes»

«precedes»

«precedes»

«precedes»

«precedes»

«precedes»



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.



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



02-Viabilidad

cd 02- Viabilidad

TestViabilidad




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


- 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



03- Conocimiento Estático

cd 03- Conocimiento Estatico



ConocimientoEstatico



- 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



04- Conocimiento Dinámico

cd 04- Conocimiento Dinámico



ConocimientoDinamico



- 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.



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]



• 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]



• 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/$',

],

}



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/$',]



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.

HERRAMIENTA CAKE: COMPUTER AIDED...

Documents

Transcript of HERRAMIENTA CAKE: COMPUTER AIDED...