ILDE API documentation
  • Description
  • ILDE debug
  • ILDE github

This website collects the API documentation of the "Integrated Learning Design Environment" (ILDE). ILDE has been created as part of the METIS project (2012-2015). More information and a demo ILDE server is available at http://ilde.upf.edu/about.


Built on top of the LdShake learning design community platform, ILDE supports cooperation between educators in the creation of learning design solutions using multiple authoring tools integrated in the ILDE (such as WebCollage, OpenGLM, OULDI templates...). ILDE also integrates Glue!PS, which enables the implementation of learning designs into different existing virtual learning environments (VLEs, e.g., Moodle).


To integrate new learning design tools (templates, Web-based or desktop) in ILDE, please check the LdShake API. The LdShake API is organized around REST. This means that every operation will be performed through stanstard HTTP requests and every design will be a REST resource. You will need to set up a REST server with your platform of choice and implement a couple of endpoints according to our API. We have written a guide to facilitate this task explaining every detail that you need to known.


To support implementation into VLEs of designs created with the new learning design tool, please check how to develop new adapters for Glue!PS (both the adapter for the learning design tool depending on the design computational representation and the adapter for the VLE).


In case of inquiries, feel free to contact us at ldshake@upf.edu

The ILDE debug is a special build targeted at web applications developers so they can easily integrete their apps in the ILDE.

If you register an account you can go to the developers settings page enter your editor configuration. Once you have finished the new editor will be available in the "New LdS" menu. However for your editor to work properly you must follow the LdShake integration guide amd perform the necessary changes to the editor.

This should be enough to get ready you editor integration, then tou can submit the configuration details to the ILDE team so we can add your app in the stable ILDE release.

The ILDE development takes place at our github repository. If you are familiar with git and github you can just fork our reposiroty and perform the desired modifications.

In the reposiroty there are three tools available, LdShake, GLUE-PS! and OpenGLM. Each tool development has a specific branch where all the activity takes place. For now we have the wic, LdShake, GLUE-PS! and OpenGLM branches.

If you find a bug in the ILDE you can file a issue so the corresponding team can have a look on it.

If you want to submit some patches you can send a pull request to us.
  • Introduction to LdShake
  • LD integration guide
  • LD editor API
  • LD template
ILDE environment

In this guide we will go through every step necessary to complete a succesfull integration of your editor in the ILDE. To facilitate this task there is a debug version already set up on our servers where you can register and start working right away, just register an account at http://ilde.upf.edu/debug. When logged in if you click on your username and select "Developer settings" you will be able to configure your authoring tool settings. Once the authoring tool is configured it will appear in the topbar New LdS menu.

The LdShake editor system API must be implemented as a set of REST endpoints located on a server on your end, the Figure A shows the two components that you must implement enclosed in a red square. LdShake has a REST client that will connect to your server REST endpoints to perform operations like created new document save or load. If you are using our debug ILDE your REST service must be reachable online. The REST service location must be entered in the developer settings page.


Figure A

The main components in the editing view are the LdShake top frame environment and the authoring tool iframe as shown in the Figure B. In the LdShake environment your authoring tool UI will be displayed as an embedded app. The user will be presented with the LdShake environment common to all tools that allows to perform task like setting sharing rights, add tags, change the title, set the granularity and completion levels and save the document.

The editor iframe is loaded remotely either from the editor server or a development machine. The editor location needs to be entered in the developer settings page.


Figure B
LdShake (standing for Learning design Solutions Sharing and (K)co-Edition) is a social platform that enables members of educational communities to share and co-edit learning design solutions (design of learning activities, design of courses, educational materials, etc.) using various authoring tools. LdShake is designed as an “integrative” platform where learning design tools (templates, Web-based and desktop applications) can be integrated adopting the common features of LdShake (sharing, commenting, tagging, co-editing, duplicating, ...). If you want to know more about LdShake you can visit the website http://ldshake.upf.edu.
You have the possibility to add a Conceptualization template in a ILDE installation by just writing a xml and the template text.

Here is a example of a template configuration.


<tool>
    <name>Pupil pattern</name>
    <internalname>pupil_pattern</internalname>
    <type>template</type>
    <menu>conceptualize</menu>
    <settings>
        <filename>pupil_pattern.txt</filename>
    </settings>
</tool>



The filename must contain the template in html code. To ensure that all the code is compatible is recomended that you first edit the text in the ILDE rich text editor and format it and then just click on the code button of the editor and copy the code on the template file. By doing this your users will be presented with a template that will look es expected.
  • Introduction
  • Setting up the development environment
  • Developing your own Learning Design Adapter
GLUE!-PS (standing for Group Learning Unified Environment - Pedagogical Scripting) is a software architecture and data model designed to deploy (and manage in run-time) learning designs specified in different languages (e.g. the IMS-LD specification), into different existing Virtual Learning Environments (VLEs, e.g. Moodle). If you want to know more about Glue!-PS you can visit the website http://www.gsic.uva.es/glueps/.

This is a quick guide to get started in the task of developing your own Learning Environment adapter for Glue!-PS. If you are interested in adding new functionality to Glue!-PS you can use this guide as a start point as well.

These instructions are based on the current stable GLUE!-PS version 0.5.1, which is available to download in our website. If you have another software version, you should first check it with our team: glueps at gsic dot uva dot es.

At the moment, the Learning Environment adapters used by GLUE!-PS are part of the Glue!-PS architecture, non stand-alone components, so the first step to develop your own adapter is setting up the development environment you are going to work with.

1 Prerrequisites

Glue!-PS is mainly developed in Java, so you will need an IDE for Java. We are going to use Eclipse IDE for Java EE (other Java IDEs should also work, but we have not tested them). If you do not have currently an Eclipse installation working, you can download it from http://eclipse.org/downloads/

Important: We strongly recommend you to set the “Text file encoding” to UTF-8 in Eclipse’s preferences (Window->Preferences->General->Workspace) to avoid problems with the encoding of the HTML pages of the GLUE!-PS UI.

Besides you will need a MySQL server for the GLUE!-PS database. You can use XAMPP server (http://www.apachefriends.org), which provides a web-based graphical tool to administrate the database called phpMyAdmin, but you can use whatever you like.

2 Downloading the source code

Download the latest GLUECommon source package from GLUE! at http://gsic.uva.es/glue/download.html. This common library is used for all the Glue!’s components. You have to download the compressed file corresponding to the centralized authentication version. The current version is 0.9.2.

Download the latest Glue!-PS code release at http://gsic.uva.es/glueps from the section “Install GLUE!-PS on your own server”.

3 Configuring the project

  1. Uncompress the GLUE! Common source package in your workspace for Eclipse.
  2. Create a new Java project (File->New->Project->Java Project) with the same name as the directory created in the workspace for the GLUE! Common code.
  3. Uncompress the GLUE!-PS source package in your workspace for Eclipse.
  4. Create a new Java project (File->New->Project->Java Project) with the same name as the directory created in the workspace for the GLUE!-PS code.
  5. In order for the GLUE! Common to build correctly, right-click on that project, Build Path-> Configure Build Path. Go to the “Libraries” tab and click the “Add External JARs...” button. Then, search within the GLUE!-PS project, in its lib folder, and select the following jar files:
    • org.restlet.jar
    • org.restlet.ext.xml.jar
    • org.restlet.ext.atom.jar
  6. Now the GLUE! Common project should not display any build errors. Let’s go to the GLUE!-PS project again.
  7. In order for the GLUE!-PS to build correctly, right-click on that project, Build Path-> Configure Build Path. Go to the “Libraries” tab and click the “Add JARs...” button. Then, search within the GLUE!-PS project, in its lib folder, and select all the jar files.
  8. In order for the GLUE!-PS to find the configuration files, right-click on the project, Build Path -> Configure Build Path. Go to the “Libraries” tab and click the “Add Folder...” button. Then, search within the GLUE!-PS project and select the conf folder.
  9. In order for the GLUE!-PS to work with the GLUE! Common project, right-click on the project, Build Path -> Configure Build Path. Go to the “Project” tab and click the “Add...” button. Then, select the GLUE! Common project to be added to the build path.
  10. Now the GLUE!-PS project should not display any build errors.

4 Running GLUE!-PS

  1. First of all, make sure that your MySQL server is running and that you have created a database name “glueps”, and that you have created a database user that has privileges over that database.
  2. In MySQL, run the following database scripts that are located in the conf/db folder of the GLUE!-PS project:
    • create_glueps_database.sql. This script will create the database tables required by GLUE!-PS.
    • initial_glueps_population.sql. This script will add some default learning environment installations (maybe not all of them could be working) and a default lprisan/lprisan user. You can add more Glue!-PS users to the glueps_users table if you want. Besides, you can add your own learning environment installations to the glueps_learning_environment_installations table.
  3. Edit the conf/app.properties file of the GLUE!PS project to change the properties values according to your GLUE!PS installation. The main properties are the following:
    • app.path=path to your GLUE!PS project folder
    • app.external.uri=the URL where the GLUE!-PS can be accessed, normally http://localhost:8287/GLUEPSManager
    • gluelet.uri=the URL where the GlueletManager can be accessed, from the VLE point of view. Unless you have your own Glue! Installation, a valid value could be http://pandora.tel.uva.es/GLUEletManager/
    • gluelet.uri.internal=the URL where the GlueletManager can be accessed, from the GLUE!-PS point of view. Unless you have your own Glue! Installation, a valid value could be http://pandora.tel.uva.es/GLUEletManager/
  4. Edit the conf/META-INF/persistence.xml file in order to set the database property values:
    • javax.persistence.jdbc.user: the user in the glueps database.
    • javax.persistence.jdbc.password: the password for the user.
    • javax.persistence.jdbc.driver: the name of the driver class. Its value is “com.mysql.jdbc.Driver” for MySQL.
    • Javax.persistence.jdbc.url: driver specific url specifying the port and database name. It should be “jdbc:mysql://localhost:3306/glueps”.
  5. Create a new Run Configuration for Glue!-PS. In Eclipse, go to Run -> Run configurations, and create a new one under “Java Application”. Give it a name, choose the GLUE!-PS project and search for the main class (glueps.core.gluepsManager.GLUEPSManagerServerMain). Go to the “Arguments” tab and set the “Working directory” to be the Default value: ${workspace_loc:GLUEPSManager}, where GLUEPSManager is the name of your project.
  6. Finally, run (or debug) the GLUE!-PS server by going to Run->Run As...-> your run configuration’s name.
  7. Open a web browser and go to http://localhost:8287/GLUEPSManager/gui/glueps. You should see the main GLUE!-PS GUI, where a user/password will be asked. Now, you could upload new learning designs to the system.

Once you have set properly your development environment, checked that you can run Glue!PS without any errors and the connection with the database is working properly, you can develop your own LD Adapter for Glue!-PS. The src directory contains the Java source code of the GLUE!-PS server. The package glueps.adaptors.ld is the container of the different LD adapters. Each adapter has its own package called glueps.adaptors.ld.adapter_name, where adapter_name is the name of the LD adapter. The adapter has to comply with an interface which defines the methods we have to implement in order to translate the original LD model into the lingua franca model. This is the model used by GLUE!-PS.

We recommend you take a look at the glueps.core.model.* package to familiarize yourself with the GLUE!-PS data model before starting to code. You can also see a GLUE!-PS data model description at http://www.gsic.uva.es/wikis/juaase/index.php/GLUEPSDataModel.

Now, in order to develop the new LD adapter you have to:

  1. Create a new package glueps.adaptors.ld.adapter_name for your LD Adapter. This package will contain all the code you need to add.
  2. Create a new Java class in your package that implements the glueps.adaptors.ld.ILDAdaptor interface. This interface has two methods to be implemented:
    • glueps.core.model.Design fromLDToLF(String filepath).
      This method takes a file with the original design representation, reads it and make whatever transformations are necessary to convert such design into the GLUE!-PS data model concepts of a design. The parameter filepath is the path to the file in the disk containing the original LD model. The returned Design object is the LF design.
    • glueps.core.model.Deploy processInstantiation(String filepath, Design design, HashMap vleUsers).
      This method gets an expression of instantiation data in the original LD model, reads it and make whatever transformations are necessary to translate it into a Deploy in the LF used by GLUE!-PS. Filepath is the path to the file containing the instantiation data, design is the Design of which the instantiation data is a particularization. The HashMap contains the glueps.core.model.Participant users of the course where the design is going to be deployed. The returned Deploy object is the particularized LF design.

    Probably, your LD model is represented by using XML. In that case, you will have to read the file, parse its XML content using a library for Java, create a Design object and provide it the information contained in your LD model that can be translated into the LF model by using its setter methods.
  3. Once your adapter has been created and these methods have been implemented, you have to add this adapter to the glueps.adaptors.ld.LDAdaptorFactory class. Import the adaptor in this class, create a constant String with the name of the adaptor and edit the getLDAdaptor(String ldType, String designId) method so that it checks if the ldType value is of that type and, in this case, it returns an instance of your adapter.
  4. Slight modifications will have to be made in the GLUE!-PS UI to let the user import designs in the new format, but you can contact the GLUE!-PS team for that.
  5. That’s it!
The LKL’S Pedagogical Pattern Collector adaptor (glueps.adaptors.ld.ppc package) is a simple example of LD adapter. You can take a look at it and use it as a base to build your own adapter. 
//TODO