Ver el código de «Cómo compilar paso a paso»

<p>Cuando un centro es modificado, bien sea mediante cambios en el diccionario o en el modelo, es necesario realizar una serie de operaciones para que los cambios realizados se vean reflejados en la aplicación egExplorer. En este artículo abordaremos aquellos aspectos que influyen en dichas modificaciones, así como los pasos a seguir en función de qué elementos o ficheros del modelo se modifiquen. Para ello, es necesario entender los ficheros que intervienen en el funcionamiento de un centro, y cómo afectan a éste.</p>

__TOC__

==Ejecutando egCompiler==
Al crear un proyecto nuevo o modificar uno ya creado, la primera operación a realizar es compilar el proyecto. Si no se encuentran errores en la compilación, nuestro compilador, egCompiler, generará dos ficheros: un diccionario cuya extensión es '''.ndc''' y un modelo con extensión '''.nmc'''. Pero, ¿y cómo ejecutamos el compilador?<p>Para ejecutar el compilador, hay que indicar ciertos parámetros de entrada, ya que el compilador necesita cierta información del proyecto para poder realizar el proceso de compilación.</p>Hay un parámetro de entrada fundamental para el compilador, que es el fichero .npc. En este fichero se indican, entre otras cosas, la correspondencia entre las definiciones realizadas en ODL, con los ficheros .ndf donde están declaradas. Cualquier definición o fichero .ndf nuevo que se genere, deberá ser introducido por el programador en este fichero. Por tanto, deberemos indicar como primer parámetro la ruta de dicho fichero .npc.<p>Además de este parámetro, que es el único que realmente necesita el compilador, existen otros parámetros opcionales, de forma que podamos configurar ciertos aspectos del compilador. Veamos cuales son:</p>

:*'''/O:''' --> Indicaremos el diccionario previo a la compilación para compararlo con el nuevo diccionario a generar.
:*'''/N:''' --> Indicaremos el directorio de definiciones.
:*'''/D:''' --> Indicaremos el directorio destino donde queramos que se generen el diccionario(.ndc) y el modelo(.nmc). En caso de no especifircarlo se almacenarán en el directorio donde se encuentre el fichero .npc.
:*'''/S:''' --> Su inclusión indica que sólamente se genere el diccionario y no el modelo.

Una vez conocidos los parámetros que admite egCompiler, utilizaremos la consola del sistema para ejecutarlo. De esta manera podremos introducir los parámetros que nos interesen en cada ejecución. Veamos un ejemplo:

<center>
{|
|align="center" |[[Imagen:compilarconsola.jpg|thumb|250px|Compilación mediante la consola del sistema]]
|}
</center>

Como habrás visto, lo primero es indicar la ruta del ejecutable del compilador. A continuación especificamos la ruta del fichero .npc y seguidamente, añadimos los parámetros opcionales. En este caso, hemos indicado con el parámetro '''/O:''' la existencia de un diccionario previo con el que vamos a comparar el nuevo a generar.  Con el parámetro '''/D:''' indicamos una ruta donde queremos guardar los ficheros de salida que generará el compilador, que en este caso, será sólo el diccionario ya que la inclusión del parámetro '''/S:''' así lo indica.<p>NOTA: En caso de incluir rutas con espacios en blanco en ellas, debemos acotar la ruta completa entre comillas dobles.</p>

==Configuración de egCompiler en EditPlus==
Es probable que la persona que esté desarrollando en ODL tenga que realizar numerosas y repetitivas compilaciones en su proyecto. Por ello, facilitamos una forma de configurar el '''egCompiler''' en un editor de programación, que en este caso, hemos optado por el EditPlus. Sin más preámbulos, veamos cómo configurar dicho editor para ejecutar directamente el compilador desde él:

*Primer paso: ir a '''''Tools''''' -> '''''Preferences'''''

<center>
{|
|align="center" |[[Imagen:Paso0.jpg|thumb|250px|Tools -> Preferences]]
|}
</center>

*Segundo paso: dentro de '''''Preferences''''', ir a la etiqueta '''''User tools'''''

<center>
{|
|align="center" |[[Imagen:Paso1.jpg|thumb|250px|Entrar en User Tools]]
|}
</center>

*Tercer paso: una vez en '''''User tools''''', hay varias opciones y campos que debemos configurar. En primer lugar, vemos que existen varios grupos. Seleccionamos uno de ellos, y para cambiar el nombre haremos click en '''''Group Name...'''''. Estos grupos sirven para etiquetar conjuntos de herramientas que definamos en EditPlus, como por ejemplo, en nuestro caso, la configuración del compilador.

<center>
{|
|align="center" |[[Imagen:Paso2.jpg|thumb|250px|Editar el nombre de un grupo]]
|}
</center>

*Cuarto paso: ahora tenemos que crear una herramienta. Para ello, hacemos click en '''''Add Tool >>'''''. Nos aparecerá un desplegable, donde seleccionaremos '''''Program''''' para indicar que vamos a configurar una aplicación.

<center>
{|
|align="center" |[[Imagen:Paso3.jpg|thumb|250px|Añadimos una herramienta, en este caso, nuestro compilador]]
|}
</center>

*Quinto paso: vemos que hay ciertos campos como '''''Menu text''''', '''''Command''''', '''''Argument''''' o '''''Initial directory''''' además de ciertas opciones activables.

<center>
{|
|align="center" |[[Imagen:Paso4.jpg|thumb|250px|Introducir datos necesarios para la ejecución del compilador]]
|}
</center>

<p>En '''''Menu text''''' pondremos el nombre que aparecerá en el menú de herramientas para ejecutar el compilador.</p>
<p>En '''''Command''''' introduciremos la ruta en donde está almacenado el ejecutable del egCompiler.</p>
<p>En el campo '''''Argument''''' podremos especificar los argumentos que acepta el egCompiler. En nuestro caso, añadiremos el parámetro '''/O:''' (además del fichero .npc como explicamos en el apartado anterior) para que al compilar compare el diccionario previo con el nuevo creado, de manera que pueda detectar los cambios.</p>
<p>A continuación, añadiremos en el campo '''''Initial directory''''' el directorio donde se encuentra el fichero .npc (si no indicamos el directorio destino con el parámetro /D: el compilador almacenará el diccionario y el modelo en este directorio).</p>
<p>Finalmente, activaremos las casillas '''''Capture output''''' para ver los mensajes de compilación en el propio EditPlus (en vez de en una ventana) y '''''Save open files''''' para que al compilar se guarden los ficheros abiertos del proyecto en cuestión. Los ficheros abiertos que no pertenezcan al proyecto no se guardarán.<p>Ahora veremos que la opción '''''Compilar''''' estará disponible en el menú '''''Tools''''' o '''''Herramientas'''''.</p>

<center>
{|
|align="center" |[[Imagen:Paso5.jpg|thumb|250px|El compilador ya se puede utilizar desde EditPlus]]
|}
</center>

==Compilando...==
Una vez hemos ejecutado nuestro compilador, bien mediante la consola del sistema, o bien mediante un editor, el compilador informará al programador de aquellas definiciones que o bien son nuevas y puede generar un DRC en la base de datos para cada una de ellas, o bien detecta definiciones anteriores que ya no se encuentran en el código (en comparación con un modelo anterior) y por tanto es posible la liberación de su DRC. Existe otra operación, que es asignar el DRC de una definición que vamos a eliminar a una nueva que vamos a generar, para conservar los valores que se han creado a partir de la definición a eliminar.<p>Como ya sabemos, una vez liberamos y generados los nuevos DRC, si los hubiere, el compilador generará un diccionario y un modelo.</p>Veamos un ejemplo práctico:

:*En primer lugar, vamos a generar por primera vez nuestro modelo, de forma que se generará un DRC para todas las definiciones. Podemos ir generando las nuevas definiciones seleccionando de una en una con el botón '''''Generar''''', o bien utilizar el botón '''''Generar todos'''''.<p>Nuestro sistema de información está constuído por dos definiciones de tipo ('''''Cliente''''' y '''''Expediente''''') con sus respectivas colecciones ('''''Clientes->Contenido)''''' y '''''Expedientes->Contenido'''''). Además también hay definida una habitación '''''Mi organización''''' para ubicar dichas colecciones y una definición de rol para acceder a los recursos definidos:</p>

<center>
{|
|align="center" |[[Imagen:Generar_drc.jpg|thumb|250px|Generamos los DRC de las definiciones por primera vez]]
|}
</center>

:*Ahora, hemos decidido eliminar ciertas definiciones, de forma que al compilar, se comparará el diccionario creado en el paso anterior con el nuevo, y detectará aquellas definiciones que ya no se encuentren en el código. Al igual que al generar DRCs, existe un botón para ir liberando uno a uno cada DRC mediante el botón '''''Liberar''''' o bien liberarlas todas automáticamente, sin tener que seleccionar ninguna, con el botón '''''Liberar todas''''':

<center>
{|
|align="center" |[[Imagen:Liberar_drc.jpg|thumb|250px|Eliminamos la definición de tipo '''''Expediente''''', así como todo aquello relacionado con dicha definición (colección, ubicación y permisos)]]
|}
</center>

:*La tercera posibilidad que nos podemos encontrar es la asignación de un DRC, correspondiente a una definición que vamos a eliminar, a una definición nueva que vamos a generar. En este caso debemos tener en cuenta las posibilidades que se nos pueden presentar, pues pueden ser varias.<p>Normalmente, esta operación se suele realizar al cambiar el nombre de alguna definición, de forma que nos puede interesar asignar el DRC de la definición anterior a la nueva definición para que los valores generados anteriormente al cambio de nombre se mantengan en la nueva definición.</p>Otra posibilidad es, por ejemplo, cambiar el tipo de un campo. En este caso, se podrá asignar el DRC del campo previo al nuevo campo, pero las consecuencias de dicho cambio tendrá que valorarlas el programador, pues puede no conseguirse el efecto deseado.<p>Un nuevo caso, en el que vamos a basar nuestro ejemplo, puede ser el cambio de nombre de un formulario, junto con el cambio de nombre de un campo incluído en dicho formulario. En cuanto a los formularios hay que tener en cuenta que deben tener el mismo número de campos, además, los campos deben tener el mismo nombre.</p> Vayamos viendo los pasos a realizar uno a uno, de manera que los vayamos comentando:

<center>
{|
|align="center" |[[Imagen:Asignar_drc.jpg|thumb|250px|Relación de las definiciones a liberar o a generar]]
|}
</center>

:Vemos que el compilador ha detectado definiciones que, o bien pueden ser liberadas, o bien pueden ser generadas. Pero nuestra intención es asignar el DRC del formulario '''''Datos generales''''' al formulario '''''Datos generales del cliente'''''. Además, ha detectado que el campo '''''DNI''''' ha cambiado de nombre, detectando un nuevo campo denominado '''''NIF''''' así como el cambio de nombre de la columna '''''DNI''''' de la colección '''''Clientes''''' por '''''NIF''''':

<center>
{|
|align="center" |[[Imagen:Asignar_drc1.jpg|thumb|250px|Primero seleccionamos la definición del DRC que vamos a asignar]]
|align="center" |[[Imagen:Asignar_drc2.jpg|thumb|250px|Seleccionamos la definición nueva, indicando que el DRC será asignado a esa definición]]
|align="center" |[[Imagen:Asignar_drc3.jpg|thumb|250px|Y generamos la asignación con el botón '''''Asignar''''']]
|}
</center>

:Ya tenemos realizada la asignación de la columna que ha cambiado de nombre en la colección '''''Clientes'''''. Ahora vamos a asignar el formulario, y para ello, hay que tener en cuenta que un campo ha cambiado de nombre, y por tanto deberemos asignar dicho DRC antes de hacerlo con el formulario:

<center>
{|
|align="center" |[[Imagen:Asignar_drc4.jpg|thumb|250px|Seleccionamos el campo que contiene el DRC]]
|align="center" |[[Imagen:Asignar_drc5.jpg|thumb|250px|Seleccionamos el campo nuevo]]
|align="center" |[[Imagen:Asignar_drc6.jpg|thumb|250px|Y generamos la asignación, al igual que en el caso anterior]]
|}
</center>

:Una vez tratado el campo que ha cambiado de nombre, ya no hay restricciones para asignar el DRC del formulario '''''Datos generales''''' al formulario '''''Datos generales del cliente''''':

<center>
{|
|align="center" |[[Imagen:Asignar_drc7.jpg|thumb|250px|Seleccionamos el formulario que contiene el DRC]]
|align="center" |[[Imagen:Asignar_drc8.jpg|thumb|250px|Seleccionamos el formulario nuevo]]
|align="center" |[[Imagen:Asignar_drc9.jpg|thumb|250px|Y realizamos la asignación]]
|}
</center>

:'''¿Y qué pasa si introduzco, elimino o modifico un atributo en alguna definición?''' Los atributos no tienen asignado un DRC, por lo que cualquier edición que hagamos sobre ellos, el compilador no detectará posibles modificaciones en los DRC del sistema.

==¿Actualizamos el diccionario, el modelo o el centro?==
Cuando realizamos modificaciones en algunos de los elementos que constituyen el modelo de un sistema de información, es necesario utilizar la aplicación '''egAdmin''' para actualizar los cambios que hemos realizado y que se reflejen en la herramienta '''egExplorer'''. En función de los cambios realizados, será necesario actualizar el diccionario, el modelo o el centro.<p>Por tanto:</p>
:*'''¿Cuándo debo actualizar sólo el diccionario?'''<p>Actualizaremos el diccionario cuando modifiquemos una definición de tipo o creemos una definición de tipo nueva en los ficheros .ndf que se encuentran en el directorio '''''#Source'''''</p>

<center>
{|
|align="center" |[[Imagen:actualizardiccionario.jpg|thumb|250px|Actualizar diccionario en egAdmin]]
|}
</center>

:*'''¿Cuándo debo actualizar sólo el modelo?'''<p>Si cambiamos o agregamos algún fichero .rtf (plantillas), .nmt (métodos), .csv (representación de datos), scripts SQL, etc. Es decir, todo aquello que no sea un fichero .ndf.</p>

<center>
{|
|align="center" |[[Imagen:actualizarmodelo.jpg|thumb|250px|Actualizar modelo en egAdmin]]
|}
</center>

:*'''¿Cuándo debo actualizar el diccionario y el centro?'''<p>Actualizaremos el diccionario y el centro cuando incluyamos nuevas definiciones de sistema. Además, cuando creamos tablas nuevas en la base de datos (por ejemplo, nuevas colecciones) o cualquier cambio que afecte a la base de datos. Este caso tiene una particularidad, y es que al tener que actualizar el centro, deberemos pararlo previamente, y una vez actualizado, arrancarlo nuevamente.</p>

<center>
{|
|align="center" |[[Imagen:actualizarmodelo.jpg|thumb|250px|Actualizamos primero el modelo]]
|align="center" |[[Imagen:pararcentro.jpg|thumb|250px|A continuación paramos el centro en el botón '''''Parar''''']]
|align="center" |[[Imagen:actualizarcentro.jpg|thumb|250px|Lo actualizamos y arrancamos en el botón '''''Arrancar''''']]
|}
</center>

:*'''¿Cuándo debo actualizar el diccionario y reiniciar el centro?'''<p>Cuando cambiamos el nombre a la definición de una tarea o definimos una nueva en nuestro código ODL, evidentemente tendremos que actualizar el diccionario. Pero a diferencia del primer caso, en el que sólo tenemos que actualizar el diccionario, en este caso también es necesario parar el centro y volver a arrancarlo (reiniciarlo), pero sin actualizarlo.</p>

[[Categoría:Tutoriales]]