source: trunk/grails-app/controllers/dbnp/studycapturing/TemplateEditorController.groovy @ 538

Last change on this file since 538 was 538, checked in by roberth, 11 years ago

Improved template editor. Moving fields and basic editing works already.

  • Property svn:keywords set to Date Author Rev
File size: 5.3 KB
Line 
1/**
2 * TemplateEditorController Controler
3 *
4 * Webflow driven template editor
5 *
6 * @author  Jeroen Wesbeek
7 * @since       20100415
8 * @package     studycapturing
9 *
10 * Revision information:
11 * $Rev: 538 $
12 * $Author: roberth $
13 * $Date: 2010-06-07 14:39:11 +0000 (ma, 07 jun 2010) $
14 */
15package dbnp.studycapturing
16import dbnp.data.*
17import dbnp.studycapturing.*
18import cr.co.arquetipos.crypto.Blowfish
19
20class TemplateEditorController {
21    def entityName;
22    def entity;
23
24    /**
25     * index closure
26     */
27    def index = {
28        // Check whether a right entity is given
29        _checkEntity();
30
31        // fetch all templates for this entity
32        def templates = Template.findAllByEntity(entity)
33
34        // Check whether a template is already selected
35        def selectedTemplate = params.template;
36        def template = null;
37
38        if( selectedTemplate ) {
39            template = Template.get( selectedTemplate );
40        }
41
42        return [
43            entity: entity,
44            templates: templates,
45            encryptedEntity: params.entity,
46            fieldTypes: TemplateFieldType.list(),
47           
48            template: template
49        ];
50    }
51
52    /**
53     * Updates a selected template field using a AJAX call
54     */
55    def update = {
56        // Search for the template field
57        def templateField = TemplateField.get( params.id );
58        if( !templateField ) {
59            response.status = 404;
60            render 'TemplateField not found';
61            return;
62        }
63
64        // Update the field if it is not updated in between
65        if (params.version) {
66            def version = params.version.toLong()
67            if (templateField.version > version) {
68                response.status = 500;
69                render 'TemplateField was updated while you were working on it. Please reload and try again.';
70                return
71            }
72        }
73        templateField.properties = params
74        if (!templateField.hasErrors() && templateField.save(flush: true)) {
75            render '';
76        } else {
77            response.status = 500;
78            render 'TemplateField was not updated because errors occurred.';
79            return
80        }
81    }
82
83    /**
84     * Shows an error page
85     *
86     * TODO: improve the error page
87     */
88    def error = {
89        render( 'view': 'error' );
90    }
91
92    /**
93     * Moves a template field using a AJAX call
94     *
95     *
96     */
97    def move = {
98        // Search for the template
99        def template = Template.get( params.template );
100
101        if( !template ) {
102            response.status = 404;
103            render 'Template not found';
104            return;
105        }
106
107        // Search for the template field
108        def  templateField = TemplateField.get( params.templateField );
109        if( !templateField ) {
110            response.status = 404;
111            render 'TemplateField not found';
112            return;
113        }
114
115        // The template field should exist within the template
116        if( !template.fields.contains( templateField ) ) {
117            response.status = 404;
118            render 'TemplateField not found within template';
119            return;
120        }
121
122        // Move the item
123        def currentIndex = template.fields.indexOf( templateField );
124        def moveField = template.fields.remove( currentIndex );
125        template.fields.add( Integer.parseInt( params.position ), moveField );
126
127        render "";
128    }
129
130    /**
131     * Checks whether a correct entity is given
132     */
133    def _checkEntity = {
134        // got a entity get parameter?
135        entityName = _parseEntityType();
136
137        if( !entityName ) {
138            error();
139            return;
140        }
141
142        // Create an object of this type
143        entity = _getEntity( entityName );
144
145        if( !entity ) {
146            error();
147            return;
148        }
149
150        return true;
151    }
152
153
154    /**
155     * Checks whether the entity type is given and can be parsed
156     */
157    def _parseEntityType() {
158        def entityName;
159        if (params.entity) {
160            // decode entity get parameter
161            if (grailsApplication.config.crypto) {
162                    // generate a Blowfish encrypted and Base64 encoded string.
163                    entityName = Blowfish.decryptBase64(
164                            params.entity,
165                            grailsApplication.config.crypto.shared.secret
166                    )
167            } else {
168                    // base64 only; this is INSECURE! Even though it is not
169                    // very likely, it is possible to exploit this and have
170                    // Grails dynamically instantiate whatever class you like.
171                    // If that constructor does something harmfull this could
172                    // be dangerous. Hence, use encryption (above) instead...
173                    entityName = new String(params.entity.toString().decodeBase64())
174            }
175
176            return entityName;
177        } else {
178            return false;
179        }
180    }
181
182    /**
183     * Creates an object of the given entity. Returns false is the entity
184     *   is not a subclass of TemplateEntity
185     */
186    def _getEntity( entityName ) {
187        // Find the templates
188        def entity = Class.forName(entityName, true, this.getClass().getClassLoader())
189
190        // succes, is entity an instance of TemplateEntity?
191        if (entity.superclass =~ /TemplateEntity$/) {
192            return entity;
193        } else {
194            return false;
195        }
196
197    }
198}
Note: See TracBrowser for help on using the repository browser.