Changeset 556

Timestamp:

Jun 10, 2010, 4:45:53 PM (13 years ago)

Author:

roberth

Message:

Improved the TemplateEditor? again: templates can be created and removed and some checks were built in to ensure that the same fields in different templates point to the same TemplateField? object.

Location:

trunk

Files:

• grails-app/controllers/dbnp/studycapturing/TemplateEditorController.groovy (modified) (14 diffs)
• grails-app/domain/dbnp/studycapturing/Template.groovy (modified) (2 diffs)
• grails-app/domain/dbnp/studycapturing/TemplateField.groovy (modified) (1 diff)
• grails-app/views/templateEditor/elements/_available.gsp (moved) (moved from trunk/grails-app/views/templateEditor/elements/_all.gsp) (1 diff)
• grails-app/views/templateEditor/elements/_liField.gsp (added)
• grails-app/views/templateEditor/elements/_liFieldInUse.gsp (added)
• grails-app/views/templateEditor/elements/_liFieldNotInUse.gsp (moved) (moved from trunk/grails-app/views/templateEditor/elements/_liContent.gsp) (2 diffs)
• grails-app/views/templateEditor/elements/_liFieldSelected.gsp (added)
• grails-app/views/templateEditor/elements/_liTemplateEditable.gsp (added)
• grails-app/views/templateEditor/elements/_liTemplateNonEditable.gsp (added)
• grails-app/views/templateEditor/elements/_selected.gsp (added)
• grails-app/views/templateEditor/elements/_templateForm.gsp (added)
• grails-app/views/templateEditor/index.gsp (modified) (1 diff)
• grails-app/views/templateEditor/template.gsp (added)
• test/integration/dbnp/studycapturing (added)
• test/unit/dbnp/studycapturing/TemplateFieldTests.groovy (modified) (2 diffs)
• test/unit/dbnp/studycapturing/TemplateTests.groovy (modified) (1 diff)
• web-app/css/templateEditor.css (modified) (2 diffs)
• web-app/js/templateEditor.js (modified) (9 diffs)

trunk/grails-app/controllers/dbnp/studycapturing/TemplateEditorController.groovy

@@ -28 +28 @@
     def index = {
         // Check whether a right entity is given
-        _checkEntity();
+        if( !_checkEntity() ) {
+                        return
+                }
 
         // fetch all templates for this entity
         def templates = Template.findAllByEntity(entity)
 
-        // Check whether a template is already selected
+                // Generate a human readable entity name
+                def parts = entityName.tokenize( '.' );
+                def humanReadableEntity = parts[ parts.size() - 1 ];
+
+        return [
+            entity: entity,
+            templates: templates,
+            encryptedEntity: params.entity,
+            humanReadableEntity: humanReadableEntity,
+        ];
+    }
+
+        /**
+         * Shows the editing of a template
+         */
+        def template = {
+        // Check whether a right entity is given
+        if( !_checkEntity() ) {
+                        return
+                }
+
+        // Check whether a template is selected. If not, redirect the user to the index
         def selectedTemplate = params.template;
         def template = null;
@@ -39 +62 @@
         if( selectedTemplate ) {
             template = Template.get( selectedTemplate );
-        }
+        } else {
+                        redirect(action:"index",params:[entity:params.entity])
+                        return;
+                }
+
+        // fetch all templates for this entity
+        def templates = Template.findAllByEntity(entity)
+
+                // Generate a human readable entity name
+                def parts = entityName.tokenize( '.' );
+                def humanReadableEntity = parts[ parts.size() - 1 ];
+
+
+
+                // Find all available fields
+                def allFields = TemplateField.findAllByEntity( entity ).sort { a, b -> a.name <=> b.name }
 
         return [
@@ -46 +84 @@
             encryptedEntity: params.entity,
             fieldTypes: TemplateFieldType.list(),
-            
-            template: template
+            humanReadableEntity: humanReadableEntity,
+
+            template: template,
+                        allFields: allFields
         ];
-    }
+
+        }
+
 
     /**
@@ -61 +103 @@
 
     /**
-     * Adds a new template field using a AJAX call
+     * Creates a new template using a AJAX call
+         *
+         * @return                      JSON object with two entries:
+         *                                              id: [id of this object]
+         *                                              html: HTML to replace the contents of the LI-item that was updated.
+         *                                      On error the method gives a HTTP response status 500 and the error
+     */
+    def createTemplate = {
+                // Decode the entity
+        if( !_checkEntity() ) {
+                        response.status = 500;
+                        render "Incorrect entity given";
+                        return;
+                }
+
+                params.entity = entity;
+
+                // Create the template field and add it to the template
+                def template = new Template( params );
+        if (template.save(flush: true)) {
+
+                        def html = g.render( template: 'elements/liTemplateEditable', model: [template: template] );
+                        def output = [ id: template.id, html: html ];
+                        render output as JSON;
+
+            //render '';
+        } else {
+            response.status = 500;
+            render 'Template could not be created because errors occurred.';
+            return
+        }
+    }
+
+    /**
+     * Updates a selected template using a AJAX call
+         *
+         * @param id    ID of the template to update
+         * @return              JSON object with two entries:
+         *                                      id: [id of this object]
+         *                                      html: HTML to replace the contents of the LI-item that was updated.
+         *                              On error the method gives a HTTP response status 500 and the error
+     */
+    def updateTemplate = {
+        // Search for the template field
+        def template = Template.get( params.id );
+        if( !template ) {
+            response.status = 404;
+            render 'Template not found';
+            return;
+        }
+
+        // Update the field if it is not updated in between
+        if (params.version) {
+            def version = params.version.toLong()
+            if (template.version > version) {
+                response.status = 500;
+                render 'Template was updated while you were working on it. Please reload and try again.';
+                return
+            }
+        }
+
+        template.properties = params
+        if (!template.hasErrors() && template.save(flush: true)) {
+                        def html = g.render( template: 'elements/liTemplateEditable', model: [template: template] );
+                        def output = [ id: template.id, html: html ];
+                        render output as JSON;
+        } else {
+            response.status = 500;
+            render 'Template was not updated because errors occurred.';
+            return
+        }
+    }
+
+    /**
+     * Deletes a template using a AJAX call
+     *
+         * @param template              ID of the template to move
+         * @return                              JSON object with one entry:
+         *                                                      id: [id of this object]
+         *                                              On error the method gives a HTTP response status 500 and the error
+     */
+    def deleteTemplate = {
+        // Search for the template field
+        def  template = Template.get( params.template );
+        if( !template ) {
+            response.status = 404;
+            render 'Template not found';
+            return;
+        }
+
+        // Delete the template field
+                try {
+                        template.delete(flush: true)
+
+                        def output = [ id: template.id ];
+                        render output as JSON;
+                }
+                catch (org.springframework.dao.DataIntegrityViolationException e) {
+            response.status = 500;
+            render 'Template could not be deleted: ' + e.getMessage();
+                }
+    }
+
+
+
+
+    /**
+     * Creates a new template field using a AJAX call
          *
          * @param template      ID of the template to add a field to
@@ -69 +218 @@
          *                                      On error the method gives a HTTP response status 500 and the error
      */
-    def addField = {
+    def createField = {
         // Search for the template
         def template = Template.get( params.template );
@@ -78 +227 @@
             return;
         }
+
+                // Decode the entity, in order to set a good property
+        if( !_checkEntity() ) {
+                        response.status = 500;
+                        render "Incorrect entity given";
+                        return;
+                }
+
+                params.entity = entity;
+
+                // See whether this field already exists. It is checked by name, type and unit and entity
+                // The search is done using search by example (see http://grails.org/DomainClass+Dynamic+Methods, method find)
+                def uniqueParams = [ name: params.name, type: params.type, unit: params.unit, entity: params.entity ];
+                if( TemplateField.find( new TemplateField( uniqueParams ) ) ) {
+                        response.status = 500;
+                        render "A field with this name, type and unit already exists.";
+                        return;
+                }
 
                 // Create the template field and add it to the template
                 def templateField = new TemplateField( params );
         if (templateField.save(flush: true)) {
-                        template.fields.add( templateField );
-
-                        def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
+
+                        def html = g.render( template: 'elements/liFieldNotInUse', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
                         def output = [ id: templateField.id, html: html ];
                         render output as JSON;
@@ -91 +257 @@
         } else {
             response.status = 500;
-            render 'TemplateField could not be added because errors occurred.';
+            render 'TemplateField could not be created because errors occurred.';
             return
         }
@@ -105 +271 @@
          *                              On error the method gives a HTTP response status 500 and the error
      */
-    def update = {
+    def updateField = {
         // Search for the template field
         def templateField = TemplateField.get( params.id );
@@ -125 +291 @@
         templateField.properties = params
         if (!templateField.hasErrors() && templateField.save(flush: true)) {
-                        def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
+                        def html = g.render( template: 'elements/liField', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
                         def output = [ id: templateField.id, html: html ];
                         render output as JSON;
@@ -136 +302 @@
 
     /**
-     * Deletes a selected template field from the template using a AJAX call
+     * Deletes a template field using a AJAX call
+     *
+         * @param templateField ID of the templatefield to move
+         * @return                              JSON object with one entry:
+         *                                                      id: [id of this object]
+         *                                              On error the method gives a HTTP response status 500 and the error
+     */
+    def deleteField = {
+        // Search for the template field
+        def  templateField = TemplateField.get( params.templateField );
+        if( !templateField ) {
+            response.status = 404;
+            render 'TemplateField not found';
+            return;
+        }
+
+        // Delete the template field
+                try {
+                        templateField.delete(flush: true)
+
+                        def output = [ id: templateField.id ];
+                        render output as JSON;
+                }
+                catch (org.springframework.dao.DataIntegrityViolationException e) {
+            response.status = 500;
+            render 'TemplateField could not be deleted: ' + e.getMessage();
+                }
+    }
+
+    /**
+     * Adds a new template field to a template using a AJAX call
+         *
+         * @param template      ID of the template to add a field to
+         * @return                      JSON object with two entries:
+         *                                              id: [id of this object]
+         *                                              html: HTML to replace the contents of the LI-item that was updated.
+         *                                      On error the method gives a HTTP response status 404 or 500 and the error
+     */
+    def addField = {
+        // Search for the template
+        def template = Template.get( params.template );
+
+        if( !template ) {
+            response.status = 404;
+            render 'Template not found';
+            return;
+        }
+
+        // Search for the template field
+        def templateField = TemplateField.get( params.templateField );
+        if( !templateField ) {
+            response.status = 404;
+            render 'TemplateField does not exist';
+            return;
+        }
+
+        // The template field should exist within the template
+        if( template.fields.contains( templateField ) ) {
+            response.status = 500;
+            render 'TemplateField is already found within template';
+            return;
+        }
+                if( !params.position || Integer.parseInt( params.position ) == -1) {
+                        template.fields.add( templateField )
+                } else {
+                        template.fields.add( Integer.parseInt( params.position ), templateField )
+                }
+
+                def html = g.render( template: 'elements/liFieldSelected', model: [templateField: templateField, template: template, fieldTypes: TemplateFieldType.list()] );
+                def output = [ id: templateField.id, html: html ];
+                render output as JSON;
+    }
+
+
+    /**
+     * Removes a selected template field from the template using a AJAX call
          *
          * @param templateField ID of the field to update
          * @param template              ID of the template for which the field should be removed
-         * @return                              Status code 200 on success, 500 otherwise
-     */
-    def delete = {
+         * @return                              JSON object with two entries:
+         *                                                      id: [id of this object]
+         *                                                      html: HTML to replace the contents of the LI-item that was updated.
+         *                                              On error the method gives a HTTP response status 404 or 500 and the error
+     */
+    def removeField = {
         // Search for the template
         def template = Template.get( params.template );
@@ -171 +415 @@
         template.fields.remove( currentIndex );
                 template.save();
-                render '';
-
-                /*
-                 *try {
-                        templateField.delete(flush: true)
-                        render "";
-                        return;
-                } catch (org.springframework.dao.DataIntegrityViolationException e) {
-                        response.status = 500;
-                        render "Templatefield not deleted: " + e.getMessage();
-                        return;
-                }
-                */
+
+
+                def html = g.render( template: 'elements/liField', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
+                def output = [ id: templateField.id, html: html ];
+                render output as JSON;
     }
 
@@ -197 +433 @@
          *                                              On error the method gives a HTTP response status 500 and the error
      */
-    def move = {
+    def moveField = {
         // Search for the template
         def template = Template.get( params.template );
@@ -227 +463 @@
         template.fields.add( Integer.parseInt( params.position ), moveField );
 
-                def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
+                def html = g.render( template: 'elements/liFieldSelected', model: [templateField: templateField, template: template, fieldTypes: TemplateFieldType.list()] );
                 def output = [ id: templateField.id, html: html ];
                 render output as JSON;
     }
+
+        /**
+         * Checks how many template use a specific template field
+         *
+         * @param       id      ID of the template field
+         * @return      int     Number of uses
+         */
+        def numFieldUses = {
+        // Search for the template field
+        def  templateField = TemplateField.get( params.id );
+        if( !templateField ) {
+            response.status = 404;
+            render 'TemplateField not found';
+            return;
+        }
+
+                render templateField.numUses();
+        }
 
     /**
@@ -252 +506 @@
         if( !entity ) {
             error();
-            retur; false
+            return false
         }
 

trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

@@ -1 +1 @@
 package dbnp.studycapturing
+import java.lang.reflect.Method
 
 /**
@@ -96 +97 @@
 
         /**
+         * Checks whether this template is used by any object
+         *
+         * @returns             true iff this template is used by any object, false otherwise
+         */
+        def inUse() {
+                return (numUses() > 0 );
+        }
+
+        /**
+         * The number of objects that use this template
+         *
+         * @returns             the number of objects that use this template.
+         */
+        def numUses() {
+                // This template can only be used in objects of the right entity. Find objects of that
+                // entity and see whether they use this method.
+                //
+                // Unfortunately, due to the grails way of creating classes, we can not use reflection for this
+                def elements;
+                switch( this.entity ) {
+                        case Event:
+                                elements = Event.findAllByTemplate( this ); break;
+                        case Sample:
+                                elements = Sample.findAllByTemplate( this ); break;
+                        case Study:
+                                elements = Study.findAllByTemplate( this ); break;
+                        case Subject:
+                                elements = Subject.findAllByTemplate( this ); break;
+                        default:
+                                return 0;
+                }
+
+                return elements.size();
+        }
+
+        /**
          * overloading the findAllByEntity method to make it function as expected
          * @param Class entity (for example: dbnp.studycapturing.Subject)

trunk/grails-app/domain/dbnp/studycapturing/TemplateField.groovy

@@ -53 +53 @@
                 return name.toLowerCase().replaceAll("([^a-z0-9])", "_")
         }
+
+        /**
+         * overloading the findAllByEntity method to make it function as expected
+         * @param Class entity (for example: dbnp.studycapturing.Subject)
+         * @return ArrayList
+         */
+        public static findAllByEntity(java.lang.Class entity) {
+                def results = []
+                // 'this' should not work in static context, so taking Template instead of this
+                TemplateField.findAll().each() {
+                        if (entity.equals(it.entity)) {
+                                results[results.size()] = it
+                        }
+                }
+
+                return results
+        }
+
+        /**
+         * Checks whether this template field is used in a template
+         *
+         * @returns             true iff this template field is used in a template (even if the template is never used), false otherwise
+         */
+        def inUse() {
+                return numUses() > 0;
+        }
+
+        /**
+         * The number of templates that use this template
+         *
+         * @returns             the number of templates that use this template.
+         */
+        def numUses() {
+                def templates = Template.findAll();
+                def elements;
+                if( templates && templates.size() > 0 ) {
+                        elements = templates.findAll { template -> template.fields.contains( this ) };
+                } else {
+                        return 0;
+                }
+
+                return elements.size();
+        }
+
+
 }

trunk/grails-app/views/templateEditor/elements/_available.gsp

@@ -1 +1 @@
 <li class="ui-state-default" id="templateField_${it.id}">
-        <g:render template="elements/liContent" model="['templateField': it, 'fieldTypes': fieldTypes]"/>
+    <g:render template="elements/liField" model="['templateField': it, 'fieldTypes': fieldTypes]"/>
 </li>

trunk/grails-app/views/templateEditor/elements/_liFieldNotInUse.gsp

@@ -1 @@
-<a class="title" href="#" onClick="showTemplateFieldForm( 'templateField_' + ${templateField.id}); this.blur(); return false;">
-        <span class="ui-icon ui-icon-arrowthick-2-n-s"></span>
-        <b>${templateField.name}</b>
-        (<g:render template="elements/${templateField.type.toString().toLowerCase().replaceAll(/ /,'_')}" />)
-</a>
+<span class="listButtons">
+  <img onClick="showTemplateFieldForm( 'templateField_' + ${templateField.id}); this.blur(); return false;" src="${createLinkTo( dir: 'images', file: 'icons/famfamfam/application_edit.png')}" alt="Edit template field properties" title="Edit template field properties">
+  <img onClick="if( confirm( 'Are you sure?' ) ) { deleteTemplateField( ${templateField.id} ); }" src="${createLinkTo( dir: 'images', file: 'icons/famfamfam/delete.png')}" alt="Delete this template field" title="Delete this template field">
+  <img onClick="addTemplateField( ${templateField.id} ); moveFieldListItem( ${templateField.id}, '#selectedTemplateFields' );" src="${createLinkTo( dir: 'images', file: 'icons/famfamfam/add.png')}" alt="Add field to template" title="Add field to template">
+</span>
 
-<form class="templateField_form" id="templateField_${templateField.id}_form" action="update">
+<b>${templateField.name}</b>
+(<g:if test="${templateField.unit}">${templateField.unit}, </g:if><g:render template="elements/${templateField.type.toString().toLowerCase().replaceAll(/ /,'_')}" model="[templateField: templateField]" />)
+
+<form class="templateField_form" id="templateField_${templateField.id}_form" action="updateField">
         <g:hiddenField name="id" value="${templateField.id}" />
         <g:hiddenField name="version" value="${templateField.version}" />
@@ -11 +14 @@
         <div class="templateFieldButtons">
                 <input type="button" value="Save" onClick="updateTemplateField( ${templateField.id} );">
-                <input type="button" value="Delete" onClick="deleteTemplateField( ${templateField.id} );">
                 <input type="button" value="Close" onClick="hideTemplateFieldForm( ${templateField.id} );">
         </div>

trunk/grails-app/views/templateEditor/index.gsp

@@ -24 +24 @@
         <body>
 
-                <script type="text/javascript">
-                        $(function() {
-                                $("#templateFields").sortable({
-                                        placeholder: 'ui-state-highlight',
-                                        cancel: '.empty',
+                <div class="templateEditorStep" id="step1_template">
+                        <h3>Select template</h3>
+                        <p>Showing templates for <b>${humanReadableEntity}</b>.</p>
+                        <p>Please select a template to edit or create a new template</p>
 
-                                        update: updateTemplateFieldPosition
-                                });
-                                $("#templateFields").disableSelection();
-                                //$('#templateFields li').bind('dblclick', showTemplateFormEvent);
-                        });
-                </script>
-
-                <p>Please select a template to edit or create a new template</p>
-                <g:form action="index" name="templateChoice">
-                        <g:hiddenField name="entity" value="${encryptedEntity}" />
-                        <select name="template" id="templateSelect" onChange="this.form.submit();">
-                                <option value=""></option>
+                        <ul id="templates">
+                                <li class="empty ui-state-default" <g:if test="${templates.size() > 0 }">style='display: none;'</g:if>>There are no templates for ${humanReadableEntity}. Use the 'Add template' button to add fields.</li>
                                 <g:each in="${templates}" var="currentTemplate">
-                                        <g:if test="${currentTemplate.id==template?.id}">
-                                                <option selected value="${currentTemplate.id}">${currentTemplate.name}</option>
-                                        </g:if>
-                                        <g:else>
-                                                <option value="${currentTemplate.id}">${currentTemplate.name}</option>
-                                        </g:else>
+                                        <li id="template_${currentTemplate.id}"class="ui-state-default">
+                                          <g:if test="${currentTemplate.inUse()}">
+                                                <g:render template="elements/liTemplateNonEditable" model="['template': currentTemplate]"/>
+                                          </g:if>
+                                          <g:else>
+                                                <g:render template="elements/liTemplateEditable" model="['template': currentTemplate]"/>
+                                          </g:else>
+                                        </li>
                                 </g:each>
-                        </select>
-                </g:form>
-
-                <g:if test="${template}">
-                        <p>Currently, this template contains the following fields. Drag fields to reorder and double click fields to edit.</p>
-                        <ul id="templateFields">
-                                <li class="empty ui-state-default" <g:if test="${template.fields?.size() > 0 }">style='display: none;'</g:if>>This template does not yet contain any fields. Use the 'Add new field' button to add fields.</li>
-                                <g:render template="elements/all" collection="${template.fields}" />
                         </ul>
 
                         <div id="addNew">
-                                <a href="#" onClick="showTemplateFieldForm( 'templateField_new' ); this.blur(); return false;">
-                                        <b>Add new field</b>
+                                <a href="#" onClick="editTemplate( 'new' ); this.blur(); return false;">
+                                        <b>Create new template</b>
                                 </a>
 
-                                <form class="templateField_form" id="templateField_new_form" action="addField">
-                                        <g:render template="elements/fieldForm" model="['templateField': null, 'fieldTypes': fieldTypes]"/>
+                                <form class="templateField_form" id="template_new_form" action="createTemplate">
+                                        <g:hiddenField name="entity" value="${encryptedEntity}" />
+                                        <g:render template="elements/templateForm" model="['template': null]"/>
                                         <div class="templateFieldButtons">
-                                                <input type="button" value="Save" onClick="addTemplateField( 'new' );">
-                                                <input type="button" value="Cancel" onClick="hideTemplateFieldForm( 'new' );">
+                                                <input type="button" value="Save" onClick="createTemplate( 'new' );">
+                                                <input type="button" value="Cancel" onClick="hideTemplateForm( 'new' );">
                                         </div>
                                 </form>
                         </div>
-                </g:if>
+
+                        <g:form action="template" name="templateChoice" method="GET">
+                                <g:hiddenField name="entity" value="${encryptedEntity}" />
+                                <input type="hidden" name="template" id="templateSelect" value="${template?.id}">
+                        </g:form>
+                </div>
 
         </body>

trunk/test/unit/dbnp/studycapturing/TemplateFieldTests.groovy

@@ -28 +28 @@
             );
 
+                // Add static methods to Template
+                mockDomain( Template, [testTemplate] );
+                mockDomain( TemplateField, testTemplate.fields );
+
         this.testEvent = new Event(
                 template: testTemplate,
                 startTime: 3600,
                 endTime: 7200
-        )
+        );
+
+                mockDomain( Event, [testEvent] );
+                this.testEvent.save();
     }
 
@@ -38 +45 @@
         super.tearDown()
     }
+
+        void testInUse() {
+                
+                // All template fields in the testTemplate are in use (even in use on a object)
+                assert testEvent.template.fields.size() == 3;
+                testEvent.template.fields.each {
+                        if( it != null ) {
+                                assert it.inUse();
+                        }
+                }
+
+                // Create 2 template fields and use the first in a template, the second is not used
+                TemplateField t1 = new TemplateField(
+                                                                name: 'test1',
+                                                                type: TemplateFieldType.DATE,
+                                                                entity: dbnp.studycapturing.Event
+                                                        ).save();
+                TemplateField t2 = new TemplateField(
+                                                                name: 'test2',
+                                                                type: TemplateFieldType.DATE,
+                                                                entity: dbnp.studycapturing.Event
+                                                        ).save();
+
+                mockDomain( TemplateField, [t1, t2] );
+
+        def template1 = new Template(
+                name: 'Template for testing inUse',
+                entity: dbnp.studycapturing.Event,
+                fields: [
+                                        t1
+                ]
+            ).save();
+
+                assert t1.inUse();
+                assert !t2.inUse();
+
+        }
 
     void testRelTimeFieldCreation() {

trunk/test/unit/dbnp/studycapturing/TemplateTests.groovy

@@ -12 +12 @@
     }
 
-    void testSomething() {
+    void testInUse() {
+                Template t1 = new Template( entity: dbnp.studycapturing.Subject );
+                Template t2 = new Template( entity: dbnp.studycapturing.Subject );
+                Template t3 = new Template( entity: dbnp.studycapturing.Subject );
+
+                Subject s1 = new Subject( template: t1 );
+                Subject s2 = new Subject( template: t1 );
+                Subject s3 = new Subject( template: t2 );
+
+                mockDomain(Template, [t1, t2, t3 ])
+                mockDomain(Subject, [ s1, s2, s3] )
+
+                assert t1.inUse();
+                assert t2.inUse();
+                assert !t3.inUse();
 
     }

trunk/web-app/css/templateEditor.css

@@ -1 @@
-#templateFields {
-    list-style-type: none;
-    margin: 0;
-    padding: 0;
-    width: 400px;
-}
-#templateFields li { 
-    margin: 0 5px 5px 5px; padding: 5px;
-}
-html>body #templateFields li { 
-    line-height: 16px; vertical-align: center;
-}
-.ui-state-highlight { 
-    height: 1.5em; line-height: 1.2em;
-}
-#templateFields .ui-icon { 
-    display: inline-block; 
-}
+/**
+ * Formatting the template editor with two columns
+ */
+.templateEditorStep { float: left; padding: 10px 0px; margin: 0 10px; }
+.templateEditorStep h3 { margin: 0 0 10px 0; padding-bottom: 10px; border-bottom: 1px solid #BBD; }
+#step2_selectedFields p, #step3_availableFields p { height: 42px; }
 
-#templateFields .empty { opacity: 0.6; padding: 5px 25px; }
+#step1_template { width:340px; }
+#step2_selectedFields { width: 340px; margin-right: 20px; }
+#step3_availableFields { width: 340px; }
 
+/**
+ * Formatting the template list and the forms to add/edit them
+ */
+
+#templates  { list-style-type: none; margin: 0; padding: 0; width: 330px; }
+#templates li { margin: 0 5px 5px 5px; padding: 5px; color: #2779AA; }
+html>body #templates li { line-height: 16px; vertical-align: center; }
+
+/* Butons within a list item */
+.listButtons { display: block; float: right; }
+.listButtons img { margin: 0 3px; cursor: pointer; }
+.listButtons img.disabled { cursor: default; opacity: 0.3; }
+
+/**
+ * Formatting of the template fields and the forms to edit/add them
+ */
+.templateFields { list-style-type: none;  margin: 0; padding: 0; width: 330px; }
+.templateFields li { margin: 0 5px 3px 5px; padding: 3px 5px; }
+html>body .templateFields li { line-height: 16px; vertical-align: center; }
+.ui-state-highlight { height: 17px; }
+.templateFields .ui-icon { display: inline-block; height: 13px; }
+
+.templateName { color: #2779AA; }
+a.switch { font-size: small; color: #68BFEF; text-decoration: none; }
+
+/* Box to show a list is empty */
+.templateFields .empty { opacity: 0.6; padding: 5px 25px; }
+
+/* The position where an item can be dropped in the available list will be red */
+#availableTemplateFields .ui-state-highlight { background: #FFD6D6; border-color: #EAAEAE; }
+
+/* Form to edit or add a template field, but also for editing a template itself */
 .templateField_form { display: none; margin: 5px; padding-top: 8px; border-top: 1px solid #BBD; }
 .templateField_form .templateFieldButtons { margin-top: 8px; padding-top: 8px; border-top: 1px solid #BBD; }
-.templateField_form label { width: 100px; float: left; display: block; }
-.templateField_form textarea {width: 240px; height: 100px;  }
+.templateField_form label { width: 80px; float: left; display: block; }
+.templateField_form textarea {width: 145px; height: 100px;  }
+.templateField_form input[type=text],
+.templateField_form select {width: 145px; }
 
+/* Add new form */
 #addNew {
-        width: 388px;
+        width: 318px;
         line-height: 16px;
         background-color: #EBF9D7;
@@ -40 +65 @@
 #addNew a {
         display: block;
-        padding: 7px 25px;
+        padding: 7px 7px;
         cursor: pointer;
         color:#79AA27;

trunk/web-app/js/templateEditor.js

@@ -15 +15 @@
 var formOpened = false;
 
+/*************************************
+ *
+ * Methods for the index page with templates on it
+ *
+ *************************************/
+
+/**
+ * Sends the user to the page where the fields of this template can be edited
+ */
+function editFields( id ) {
+        $( '#templateSelect' ).val( id );
+        $( '#templateChoice' ).submit();
+}
+
+/**
+ * Shows the form to edit template properties
+ */
+function editTemplate( id ) {
+    // Show the form is this item is not disabled
+    if( !formOpened ) {
+        formOpened = true;
+
+                // Show the form
+                $( '#template_' + id + '_form' ).show();
+        }
+}
+
+/**
+ * Hides the form to edit a template
+ */
+function hideTemplateForm( id ) {
+    $( '#template_' + id + '_form' ).hide();
+
+    formOpened = false;
+}
+
+/**
+ * Creates a new template using AJAX
+ */
+function createTemplate( id ) {
+    var formEl = $( '#template_' + id + '_form' );
+
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
+        data:       formEl.serialize(),
+                dataType:   'json',
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+            hideTemplateForm( id );
+            addTemplateListItem( data.id, data.html );
+        },
+        error:      function( request ) {
+            alert( "Could not create template: " + request.responseText );
+        }
+    });
+}
+
+/**
+ * Updates the properties of a template using AJAX
+ */
+function updateTemplate( id ) {
+    var formEl = $( '#template_' + id + '_form' );
+
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
+                dataType: 'json',
+        data:       formEl.serialize(),
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+            hideTemplateForm( id );
+            updateTemplateListItem( id, data.html );
+        },
+        error:      function( request ) {
+            alert( "Could not update template: " + request.responseText );
+        }
+    });
+}
+
+/**
+ * Deletes a template field using AJAX
+ */
+function deleteTemplate( id ) {
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/deleteTemplate',
+        data:       'template=' + id,
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+                        // Remove the list item
+                        deleteTemplateListItem( id );
+
+                        showHideEmpty( '#templates' );
+        },
+        error:      function( request ) {
+            alert( "Could not delete template: " + request.responseText );
+        }
+    });
+
+        return true;
+}
+
+// Adds a new listitem when a field has been added
+function addTemplateListItem( id, newHTML ) {
+        // Create a new listitem
+        var li = $( '<li></li>' );
+        li.attr( 'id', 'template_' + id );
+        li.addClass( "ui-state-default" );
+
+        // Insert the right HTML
+        li.html( newHTML );
+
+        // Append the listitem to the list
+        $( '#templates li:last').after( li );
+
+        // Hide the 'empty' listitem, if needed
+        showHideEmpty( '#templates' );
+}
+
+// Updates the contents of the listitem when something has changed
+function updateTemplateListItem( id, newHTML ) {
+        var li = $( '#template_' + id );
+        li.html( newHTML );
+}
+
+// Removes a listitem when the template field has been deleted
+function deleteTemplateListItem( id ) {
+        var li = $( '#template_' + id );
+        li.remove();
+
+        // Show the 'empty' listitem if the last item is deleted
+        showHideEmpty( '#templates' );
+}
+
+/*************************************
+ *
+ * Methods for the template page with templatefields on it
+ *
+ *************************************/
+
 /**
  * Is called on double click on a listitem
@@ -34 +175 @@
 
                 // Disable all other listitems
-                $( '#templateFields li:not(#' + list_item_id + ')').addClass( 'ui-state-disabled' );
+                $( '#availableTemplateFields li:not(#' + list_item_id + ')').addClass( 'ui-state-disabled' );
 
                 if( list_item_id != 'templateField_new' ) {
@@ -50 +191 @@
 
     // Enable all other listitems
-    $( '#templateFields li:not(#templateField_' + id + ')').removeClass( 'ui-state-disabled' );
+    $( '#availableTemplateFields li:not(#templateField_' + id + ')').removeClass( 'ui-state-disabled' );
         $( '#addNew').removeClass( 'ui-state-disabled' );
 
     formOpened = false;
+}
+
+
+
+/**
+ * Adds a new template field using AJAX
+ */
+function createTemplateField( id ) {
+    var formEl = $( '#templateField_' + id + '_form' );
+        var templateId = $('#templateSelect').val();
+
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
+        data:       "template=" + templateId + "&" + formEl.serialize(),
+                dataType: 'json',
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+            hideTemplateFieldForm( id );
+            addFieldListItem( data.id, data.html );
+        },
+        error:       function( request ) {
+            alert( "Could not add template field: " + request.responseText );
+        }
+    });
+}
+
+/**
+ * Updates the properties of a template field using AJAX
+ */
+function updateTemplateField( id ) {
+    var formEl = $( '#templateField_' + id + '_form' );
+
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
+                dataType: 'json',
+        data:       formEl.serialize(),
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+            hideTemplateFieldForm( id );
+            updateFieldListItem( id, data.html );
+        },
+        error:      function( request ) {
+            alert( "Could not update template field: " + request.responseText );
+        }
+    });
 }
 
@@ -61 +249 @@
  */
 function updateTemplateFieldPosition( event, ui ) {
+        // If the item is dragged to the 'availableTemplateFIelds list, we should not 'move' it
+        // Otherwise, when the item is dragged onto the selectedTemplateFields, but the 'sender' is availableTemplateFields,
+        // the item is added, and does not need to be moved
+        if(
+                ui.item.parent().attr( 'id' ) == 'availableTemplateFields' ||
+                ui.item.parent().attr( 'id' ) == 'selectedTemplateFields' && ui.sender != null && ui.sender.attr( 'id' ) == 'availableTemplateFields'
+        ) {
+                // Return true, otherwise the move operation is canceled by jquery
+                return true;
+        }
     // Find the new position of the element in the list
     // http://stackoverflow.com/questions/2979643/jquery-ui-sortable-position
-    var newposition = ui.item.index();
+    //
+    // Because there is also a hidden 'empty template' list item in the list,
+    // the number is decreased by 1
+    var newposition = ui.item.index() - 1;
 
     // Find the ID of the templateField and template
@@ -71 +272 @@
 
     // Create a URL to call and call it
-    var url = baseUrl + '/templateEditor/move';
+    var url = baseUrl + '/templateEditor/moveField';
 
     // Disable sorting until this move has been saved (in order to prevent collisions
@@ -83 +284 @@
                 type: 'POST',
         success: function(data, textStatus, request) {
-            updateListItem( templateFieldId, data.html );
+            updateFieldListItem( templateFieldId, data.html );
             $( '#templateFields' ).sortable( 'enable' );
         },
-        error: function() {
-            alert( "Could not move template field" );
-        }
-    });
-}
-
-/**
- * Adds a new template field using AJAX
- */
-function addTemplateField( id ) {
-    var formEl = $( '#templateField_' + id + '_form' );
+        error: function( request ) {
+            alert( "Could not move template field: " + request.responseText );
+        }
+    });
+}
+
+/**
+ * Adds a new template field to the template using AJAX
+ */
+function addTemplateFieldEvent( event, ui ) {
+    // Find the new position of the element in the list
+    // http://stackoverflow.com/questions/2979643/jquery-ui-sortable-position
+    //
+    // Because there is also a hidden 'empty template' list item in the list,
+    // the number is decreased by 1
+    var newposition = ui.item.index() - 1;
+
+        var item_id = ui.item.context.id;
+    var id = item_id.substring( item_id.lastIndexOf( '_' ) + 1 );
+
+        return addTemplateField( id, newposition );
+}
+
+/**
+ * Adds a new template field to the template using AJAX
+ */
+function addTemplateField( id, newposition ) {
+        if( newposition == null ) {
+                newposition = -1;
+        }
         var templateId = $('#templateSelect').val();
 
     // Update the field
     $.ajax({
-        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
-        data:       "template=" + templateId + "&" + formEl.serialize(),
-                dataType: 'json',
-        type:       "POST",
-        success:    function(data, textStatus, request) {
-            hideTemplateFieldForm( id );
-            addListItem( data.id, data.html );
-        },
-        error:      function() {
-            alert( "Could not add template field" );
-        }
-    });
-}
-
-/**
- * Updates the properties of a template field using AJAX
- */
-function updateTemplateField( id ) {
-    var formEl = $( '#templateField_' + id + '_form' );
-
-    // Update the field
-    $.ajax({
-        url:        baseUrl + '/templateEditor/' + formEl.attr( 'action' ),
-                dataType: 'json',
-        data:       formEl.serialize(),
-        type:       "POST",
-        success:    function(data, textStatus, request) {
-            hideTemplateFieldForm( id );
-            updateListItem( id, data.html );
-        },
-        error:      function() {
-            alert( "Could not update template field" );
-        }
-    });
+        url:        baseUrl + '/templateEditor/addField',
+        data:       "template=" + templateId + "&templateField=" + id + "&position=" + newposition,
+                dataType:       'json',
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+                        // Put the new HTML into the list item
+                        updateFieldListItem( id, data.html );
+
+                        showHideEmpty( '#selectedTemplateFields' );
+                        showHideEmpty( '#availableTemplateFields' );
+        },
+        error:      function( request ) {
+            alert( "Could not add template field: " + request.responseText );
+        }
+    });
+}
+
+
+/**
+ * Deletes a template field from a template  using AJAX
+ */
+function removeTemplateFieldEvent( event, ui ) {
+    var item_id = ui.item.context.id;
+    var id = item_id.substring( item_id.lastIndexOf( '_' ) + 1 );
+
+        // The field should only be removed when the study is not in use
+        // If field is used, the li has class 'inUse'
+        if( !ui.item.hasClass( 'inUse' ) ) {
+                return removeTemplateField( id );
+        } else {
+                alert( "Field can not be removed, because the template is in use." );
+                return false;
+        }
+}
+
+/**
+ * Removes a template field from a template using AJAX
+ */
+function removeTemplateField( id ) {
+        var templateId = $('#templateSelect').val();
+
+    // Update the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/removeField',
+        data:       'template=' + templateId + '&templateField=' + id,
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+                        // Put the new HTML into the list item
+                        updateFieldListItem( id, data.html );
+
+                        showHideEmpty( '#selectedTemplateFields' );
+                        showHideEmpty( '#availableTemplateFields' );
+
+        },
+        error:      function( request ) {
+            alert( "Could not delete template field: " + request.responseText );
+        }
+    });
+
+        return true;
 }
 
@@ -141 +387 @@
  */
 function deleteTemplateField( id ) {
-        var templateId = $('#templateSelect').val();
-
-    // Update the field
-    $.ajax({
-        url:        baseUrl + '/templateEditor/delete',
-        data:       'template=' + templateId + '&templateField=' + id,
-        type:       "POST",
-        success:    function(data, textStatus, request) {
-            hideTemplateFieldForm( id );
-            deleteListItem( id );
-        },
-        error:      function() {
-            alert( "Could not delete template field" );
-        }
-    });
-}
-
+    // Delete the field
+    $.ajax({
+        url:        baseUrl + '/templateEditor/deleteField',
+        data:       'templateField=' + id,
+        type:       "POST",
+        success:    function(data, textStatus, request) {
+                        // Put the new HTML into the list item
+                        deleteFieldListItem( id );
+
+                        showHideEmpty( '#availableTemplateFields' );
+        },
+        error:      function( request ) {
+            alert( "Could not delete template field: " + request.responseText );
+        }
+    });
+
+        return true;
+}
 
 // Adds a new listitem when a field has been added
-function addListItem( id, newHTML ) {
+function addFieldListItem( id, newHTML ) {
         // Create a new listitem
         var li = $( '<li></li>' );
@@ -170 +417 @@
 
         // Append the listitem to the list
-        $( '#templateFields li:last').after( li );
+        $( '#availableTemplateFields li:last').after( li );
 
         // Hide the 'empty' listitem
-        $( '#templateFields .empty' ).hide();
+        showHideEmpty( '#availableTemplateFields' );
 }
 
 // Updates the contents of the listitem when something has changed
-function updateListItem( id, newHTML ) {
+function updateFieldListItem( id, newHTML ) {
         var li = $( '#templateField_' + id );
         li.html( newHTML );
@@ -183 +430 @@
 
 // Removes a listitem when the template field has been deleted
-function deleteListItem( id ) {
+function deleteFieldListItem( id ) {
         var li = $( '#templateField_' + id );
         li.remove();
 
         // Show the 'empty' listitem if the last item is deleted
-        if( $( '#templateFields li:not(.empty)' ).length == 0 ) {
-                $( '#templateFields .empty' ).show();
-        }
-
-}
+        showHideEmpty( '#availableTemplateFields' );
+}
+
+// Moves a listitem from one list to another
+function moveFieldListItem( id, toSelector ) {
+        var li = $( '#templateField_' + id );
+        li.remove();
+
+        $( toSelector ).append( li );
+}
+
+/** 
+ * Shows or hides the list item, indicating that a list is empty
+ */
+function showHideEmpty( selector ) {
+        // Show the 'empty' listitem if the last item is deleted
+        if( $( selector + ' li:not(.empty)' ).length == 0 ) {
+                $( selector + ' .empty' ).show();
+        } else {
+                $( selector + ' .empty' ).hide();
+        }
+}