Roo/form/Action.js
[roojs1] / Roo / form / Action.js
1 /*
2  * Based on:
3  * Ext JS Library 1.1.1
4  * Copyright(c) 2006-2007, Ext JS, LLC.
5  *
6  * Originally Released Under LGPL - original licence link has changed is not relivant.
7  *
8  * Fork - LGPL
9  * <script type="text/javascript">
10  */
11  
12  /**
13  * @class Roo.form.Action
14  * Internal Class used to handle form actions
15  * @constructor
16  * @param {Roo.form.BasicForm} el The form element or its id
17  * @param {Object} config Configuration options
18  */
19  
20  
21 // define the action interface
22 Roo.form.Action = function(form, options){
23     this.form = form;
24     this.options = options || {};
25 };
26 /**
27  * Client Validation Failed
28  * @const 
29  */
30 Roo.form.Action.CLIENT_INVALID = 'client';
31 /**
32  * Server Validation Failed
33  * @const 
34  */
35  Roo.form.Action.SERVER_INVALID = 'server';
36  /**
37  * Connect to Server Failed
38  * @const 
39  */
40 Roo.form.Action.CONNECT_FAILURE = 'connect';
41 /**
42  * Reading Data from Server Failed
43  * @const 
44  */
45 Roo.form.Action.LOAD_FAILURE = 'load';
46
47 Roo.form.Action.prototype = {
48     type : 'default',
49     failureType : undefined,
50     response : undefined,
51     result : undefined,
52
53     // interface method
54     run : function(options){
55
56     },
57
58     // interface method
59     success : function(response){
60
61     },
62
63     // interface method
64     handleResponse : function(response){
65
66     },
67
68     // default connection failure
69     failure : function(response){
70         this.response = response;
71         this.failureType = Roo.form.Action.CONNECT_FAILURE;
72         this.form.afterAction(this, false);
73     },
74
75     processResponse : function(response){
76         this.response = response;
77         if(!response.responseText){
78             return true;
79         }
80         this.result = this.handleResponse(response);
81         return this.result;
82     },
83
84     // utility functions used internally
85     getUrl : function(appendParams){
86         var url = this.options.url || this.form.url || this.form.el.dom.action;
87         if(appendParams){
88             var p = this.getParams();
89             if(p){
90                 url += (url.indexOf('?') != -1 ? '&' : '?') + p;
91             }
92         }
93         return url;
94     },
95
96     getMethod : function(){
97         return (this.options.method || this.form.method || this.form.el.dom.method || 'POST').toUpperCase();
98     },
99
100     getParams : function(){
101         var bp = this.form.baseParams;
102         var p = this.options.params;
103         if(p){
104             if(typeof p == "object"){
105                 p = Roo.urlEncode(Roo.applyIf(p, bp));
106             }else if(typeof p == 'string' && bp){
107                 p += '&' + Roo.urlEncode(bp);
108             }
109         }else if(bp){
110             p = Roo.urlEncode(bp);
111         }
112         return p;
113     },
114
115     createCallback : function(){
116         return {
117             success: this.success,
118             failure: this.failure,
119             scope: this,
120             timeout: (this.form.timeout*1000),
121             upload: this.form.fileUpload ? this.success : undefined
122         };
123     }
124 };
125
126 Roo.form.Action.Submit = function(form, options){
127     Roo.form.Action.Submit.superclass.constructor.call(this, form, options);
128 };
129
130 Roo.extend(Roo.form.Action.Submit, Roo.form.Action, {
131     type : 'submit',
132
133     haveProgress : false,
134     uploadComplete : false,
135     
136     // uploadProgress indicator.
137     uploadProgress : function()
138     {
139         if (!this.form.progressUrl) {
140             return;
141         }
142         
143         if (!this.haveProgress) {
144             Roo.MessageBox.progress("Uploading", "Uploading");
145         }
146         if (this.uploadComplete) {
147            Roo.MessageBox.hide();
148            return;
149         }
150         
151         this.haveProgress = true;
152    
153         var uid = this.form.findField('UPLOAD_IDENTIFIER').getValue();
154         
155         var c = new Roo.data.Connection();
156         c.request({
157             url : this.form.progressUrl,
158             params: {
159                 id : uid
160             },
161             method: 'GET',
162             success : function(data){
163                //console.log(data);
164                 if (this.uploadComplete) {
165                    Roo.MessageBox.hide();
166                    return;
167                 }
168                    
169                 if (data){
170                     Roo.MessageBox.updateProgress(data.bytes_uploaded/data.bytes_total,
171                        Math.floor((data.bytes_total - data.bytes_uploaded)/1000) + 'k remaining'
172                     );
173                 }
174                 this.uploadProgress.defer(2000,this);
175             },
176        
177             failure: function(data) {
178                 Roo.log('progress url failed ');
179                 Roo.log(data);
180             },
181             scope : this
182         });
183            
184     },
185     
186     
187     run : function()
188     {
189         // run get Values on the form, so it syncs any secondary forms.
190         this.form.getValues();
191         
192         var o = this.options;
193         var method = this.getMethod();
194         var isPost = method == 'POST';
195         if(o.clientValidation === false || this.form.isValid()){
196             if (this.form.progressUrl) {
197            
198                 this.findField('UPLOAD_IDENTIFIER').setValue(
199                     (new Date() * 1) + '' + Math.random());
200                     
201             }
202             
203             
204             
205             Roo.Ajax.request(Roo.apply(this.createCallback(), {
206                 form:this.form.el.dom,
207                 url:this.getUrl(!isPost),
208                 method: method,
209                 params:isPost ? this.getParams() : null,
210                 isUpload: this.form.fileUpload
211             }));
212             
213             this.uploadProgress();
214
215         }else if (o.clientValidation !== false){ // client validation failed
216             this.failureType = Roo.form.Action.CLIENT_INVALID;
217             this.form.afterAction(this, false);
218         }
219     },
220
221     success : function(response)
222     {
223         this.uploadComplete= true;
224         if (this.haveProgress) {
225             Roo.MessageBox.hide();
226         }
227         
228         var result = this.processResponse(response);
229         if(result === true || result.success){
230             this.form.afterAction(this, true);
231             return;
232         }
233         if(result.errors){
234             this.form.markInvalid(result.errors);
235             this.failureType = Roo.form.Action.SERVER_INVALID;
236         }
237         this.form.afterAction(this, false);
238     },
239     failure : function(response)
240     {
241         this.uploadComplete= true;
242         if (this.haveProgress) {
243             Roo.MessageBox.hide();
244         }
245         
246         this.response = response;
247         this.failureType = Roo.form.Action.CONNECT_FAILURE;
248         this.form.afterAction(this, false);
249     },
250     
251     handleResponse : function(response){
252         if(this.form.errorReader){
253             var rs = this.form.errorReader.read(response);
254             var errors = [];
255             if(rs.records){
256                 for(var i = 0, len = rs.records.length; i < len; i++) {
257                     var r = rs.records[i];
258                     errors[i] = r.data;
259                 }
260             }
261             if(errors.length < 1){
262                 errors = null;
263             }
264             return {
265                 success : rs.success,
266                 errors : errors
267             };
268         }
269         var ret = false;
270         try {
271             ret = Roo.decode(response.responseText);
272         } catch (e) {
273             ret = {
274                 success: false,
275                 errorMsg: "Failed to read server message: " + (response ? response.responseText : ' - no message'),
276                 errors : []
277             };
278         }
279         return ret;
280         
281     }
282 });
283
284
285 Roo.form.Action.Load = function(form, options){
286     Roo.form.Action.Load.superclass.constructor.call(this, form, options);
287     this.reader = this.form.reader;
288 };
289
290 Roo.extend(Roo.form.Action.Load, Roo.form.Action, {
291     type : 'load',
292
293     run : function(){
294         Roo.Ajax.request(Roo.apply(
295                 this.createCallback(), {
296                     method:this.getMethod(),
297                     url:this.getUrl(false),
298                     params:this.getParams()
299         }));
300     },
301
302     success : function(response){
303         var result = this.processResponse(response);
304         if(result === true || !result.success || !result.data){
305             this.failureType = Roo.form.Action.LOAD_FAILURE;
306             this.form.afterAction(this, false);
307             return;
308         }
309         this.form.clearInvalid();
310         this.form.setValues(result.data);
311         this.form.afterAction(this, true);
312     },
313
314     handleResponse : function(response){
315         if(this.form.reader){
316             var rs = this.form.reader.read(response);
317             var data = rs.records && rs.records[0] ? rs.records[0].data : null;
318             return {
319                 success : rs.success,
320                 data : data
321             };
322         }
323         return Roo.decode(response.responseText);
324     }
325 });
326
327 Roo.form.Action.ACTION_TYPES = {
328     'load' : Roo.form.Action.Load,
329     'submit' : Roo.form.Action.Submit
330 };