root/trunk/grails-app/controllers/dbnp/studycapturing/TemplateController.groovy @ 1270

Revision 1270, 4.2 KB (checked in by robert@…, 3 years ago)

Bugfix in importing templates (ticket #76)

  • Property svn:keywords set to Author Date Rev
Line 
1/**
2 * TemplateController Controler
3 *
4 * An overview of
5 *
6 * @author  Kees van Bochove
7 * @since       20100726
8 * @package     dbnp.studycapturing
9 *
10 * Revision information:
11 * $Rev$
12 * $Author$
13 * $Date$
14 */
15package dbnp.studycapturing
16
17// Automatic marshalling of XML and JSON
18import grails.converters.*
19import grails.plugins.springsecurity.Secured
20import dbnp.authentication.AuthenticationService
21
22@Secured(['IS_AUTHENTICATED_REMEMBERED'])
23class TemplateController {
24        def authenticationService
25
26        /**
27         * Shows a form to pick a file to import templates
28         */
29        def importTemplate = {
30        }
31
32        /**
33         * Handles file import
34         */
35        def handleImportedFile = {
36                if( !request.getFile("file") ) {
37                        flash.message = "No file given.";
38                        redirect( action: 'importTemplate' );
39                        return;
40                }
41
42                // Parse XML
43                def xml
44               
45                try {
46                        xml = XML.parse( request.getFile("file").inputStream.text )
47                } catch( Exception e ) {
48                        // Error in parsing. Probably the file is not a XML file
49                        flash.message = "Imported file could not be read. Please specify an XML template file.";
50                        redirect( action: 'importTemplate' );
51                }
52               
53                def numTemplates = xml.@count;
54
55                if( !xml.template ) {
56                        flash.message = "No templates could be found in the imported file. Please specify an XML template file.";
57                        redirect( action: 'importTemplate' );
58                }
59
60                // Check whether the templates already exist
61                def templates = []
62                def id = 0;
63                xml.template.each { template ->
64                        try {
65                                def t = Template.parse( template, authenticationService.getLoggedInUser() );
66
67                                def templateData = [:]
68                                templateData.key = id++;
69                                templateData.template = t
70                                templateData.alternatives = []
71
72                                // If a template exists that equals this xml template , return it.
73                                for( def otherTemplate in Template.findAllByEntity( t.entity ) ) {
74                                        if( t.contentEquals( otherTemplate ) ) {
75                                                templateData.alternatives << otherTemplate;
76                                        }
77                                }
78
79                                templates << templateData
80                        } catch (Exception e) {
81                                templates << [ template: null, error: "Template " + ( template.name ?: " without name" ) + " could not be parsed: " + e ];
82                        }
83                }
84
85                // Save templates in session in order to have data available in the next (import) step
86                session.templates = templates
87               
88                [templates: templates]
89        }
90
91        /**
92         * Saves the imported templates that the user has chosen
93         */
94        def saveImportedTemplates = {
95                def ids = params.selectedTemplate
96                def templates = session.templates
97                def messages = []
98               
99                // Save all selected templates
100                ids.each { id ->
101                        def templateData = templates.find { template -> template.key == id.toLong() }
102                        def importTemplate = templateData?.template
103
104                        if( !importTemplate ) {
105                                messages << "Template with id " + id + " could not be found."
106                        } else {
107                                def originalName = importTemplate.name
108                                def newName = null
109
110                                // Check whether a new name has been given
111                                if( params[ 'templateNames_' + id ] && params[ 'templateNames_' + id ] != importTemplate.name ) {
112                                        importTemplate.name = params[ 'templateNames_' + id ]
113                                        newName = params[ 'templateNames_' + id ]
114                                }
115
116                                if( importTemplate.save() ) {
117                                        messages << "Template " + originalName + " saved" + ( newName ? " as " + newName : "" )
118                                } else {
119                                        messages << "Template " + originalName + " could not be saved"
120                                }
121                        }
122                }
123
124                // Remove templates from the session
125                session.templates = null
126
127                [messages: messages]
128        }
129
130        /**
131         * Shows a form to select templates for export
132         */
133        def export = {
134                // If the templates are already selected, export them
135                if( params.templates ) {
136                        if( !( params.templates instanceof String ) ) {
137                                params.templates = params.templates.join(",")
138                        }
139
140                        switch( params.type ) {
141                                case "xml":
142                                default:
143                                        xml();
144                                        return
145                        }
146                        return;
147                } else {
148                        [templates: Template.findAll()]
149                }
150        }
151
152        /**
153         * XML Export of given templates, or all templates if no templates are given
154         */
155        def xml = {
156                def templates
157                if( params.templates ) {
158                        def ids = [];
159                        params.templates.split(",").each { ids << it.toLong() }
160
161                        def c = Template.createCriteria()
162                        templates = c {
163                                'in'("id", ids)
164                        }
165                } else {
166                        templates = Template.findAll()
167                }
168               
169                response.setHeader "Content-disposition", "attachment; filename=templates.xml"
170
171                render(view: 'xml', contentType:"text/xml", model: [templates: templates])
172        }
173
174}
Note: See TracBrowser for help on using the browser.