1 /* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to you under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /** 18 * @class 19 * @name Impl 20 * @memberOf myfaces._impl.core 21 * @description Implementation singleton which implements all interface method 22 * defined by our jsf.js API 23 * */ 24 _MF_SINGLTN(_PFX_CORE + "Impl", _MF_OBJECT, /** @lends myfaces._impl.core.Impl.prototype */ { 25 26 //third option myfaces._impl.xhrCoreAjax which will be the new core impl for now 27 _transport:myfaces._impl.core._Runtime.getGlobalConfig("transport", myfaces._impl.xhrCore._Transports), 28 29 /** 30 * external event listener queue! 31 */ 32 _evtListeners:new (myfaces._impl.core._Runtime.getGlobalConfig("eventListenerQueue", myfaces._impl._util._ListenerQueue))(), 33 34 /** 35 * external error listener queue! 36 */ 37 _errListeners:new (myfaces._impl.core._Runtime.getGlobalConfig("errorListenerQueue", myfaces._impl._util._ListenerQueue))(), 38 39 /*CONSTANTS*/ 40 41 /*internal identifiers for options*/ 42 IDENT_ALL:"@all", 43 IDENT_NONE:"@none", 44 IDENT_THIS:"@this", 45 IDENT_FORM:"@form", 46 47 /* 48 * [STATIC] constants 49 */ 50 51 P_PARTIAL_SOURCE:"javax.faces.source", 52 P_VIEWSTATE:"javax.faces.ViewState", 53 P_CLIENTWINDOW:"javax.faces.ClientWindow", 54 P_AJAX:"javax.faces.partial.ajax", 55 P_EXECUTE:"javax.faces.partial.execute", 56 P_RENDER:"javax.faces.partial.render", 57 P_EVT:"javax.faces.partial.event", 58 P_BEHAVIOR_EVENT:"javax.faces.behavior.event", 59 P_WINDOW_ID:"javax.faces.ClientWindow", 60 P_RESET_VALUES:"javax.faces.partial.resetValues", 61 62 //faces std values 63 STD_VALUES: [this.P_PARTIAL_SOURCE, this.P_VIEWSTATE, this.P_CLIENTWINDOW, this.P_AJAX, 64 this.P_EXECUTE, this.P_RENDER, this.P_EVT, this.P_BEHAVIOR_EVENT, this.P_WINDOW_ID, this.P_RESET_VALUES], 65 66 /* message types */ 67 ERROR:"error", 68 EVENT:"event", 69 70 /* event emitting stages */ 71 BEGIN:"begin", 72 COMPLETE:"complete", 73 SUCCESS:"success", 74 75 /*ajax errors spec 14.4.2*/ 76 HTTPERROR:"httpError", 77 EMPTY_RESPONSE:"emptyResponse", 78 MALFORMEDXML:"malformedXML", 79 SERVER_ERROR:"serverError", 80 CLIENT_ERROR:"clientError", 81 TIMEOUT_EVENT:"timeout", 82 83 /*error reporting threshold*/ 84 _threshold:"ERROR", 85 86 /*blockfilter for the passthrough filtering, the attributes given here 87 * will not be transmitted from the options into the passthrough*/ 88 _BLOCKFILTER:{onerror:1, onevent:1, render:1, execute:1, myfaces:1, delay:1, resetValues:1, params: 1}, 89 90 /** 91 * collect and encode data for a given form element (must be of type form) 92 * find the javax.faces.ViewState element and encode its value as well! 93 * return a concatenated string of the encoded values! 94 * 95 * @throws Error in case of the given element not being of type form! 96 * https://issues.apache.org/jira/browse/MYFACES-2110 97 */ 98 getViewState:function (form) { 99 /** 100 * typecheck assert!, we opt for strong typing here 101 * because it makes it easier to detect bugs 102 */ 103 if (form) { 104 form = this._Lang.byId(form); 105 } 106 107 if (!form 108 || !form.nodeName 109 || form.nodeName.toLowerCase() != "form") { 110 throw new Error(this._Lang.getMessage("ERR_VIEWSTATE")); 111 } 112 113 var ajaxUtils = myfaces._impl.xhrCore._AjaxUtils; 114 115 var ret = this._Lang.createFormDataDecorator([]); 116 ajaxUtils.encodeSubmittableFields(ret, form, null); 117 118 return ret.makeFinal(); 119 }, 120 121 /** 122 * this function has to send the ajax requests 123 * 124 * following request conditions must be met: 125 * <ul> 126 * <li> the request must be sent asynchronously! </li> 127 * <li> the request must be a POST!!! request </li> 128 * <li> the request url must be the form action attribute </li> 129 * <li> all requests must be queued with a client side request queue to ensure the request ordering!</li> 130 * </ul> 131 * 132 * @param {String|Node} elem any dom element no matter being it html or jsf, from which the event is emitted 133 * @param {|Event|} event any javascript event supported by that object 134 * @param {|Object|} options map of options being pushed into the ajax cycle 135 * 136 * 137 * a) transformArguments out of the function 138 * b) passThrough handling with a map copy with a filter map block map 139 */ 140 request:function (elem, event, options) { 141 if (this._delayTimeout) { 142 clearTimeout(this._delayTimeout); 143 delete this._delayTimeout; 144 } 145 /*namespace remap for our local function context we mix the entire function namespace into 146 *a local function variable so that we do not have to write the entire namespace 147 *all the time 148 **/ 149 var _Lang = this._Lang, 150 _Dom = this._Dom; 151 /*assert if the onerror is set and once if it is set it must be of type function*/ 152 _Lang.assertType(options.onerror, "function"); 153 /*assert if the onevent is set and once if it is set it must be of type function*/ 154 _Lang.assertType(options.onevent, "function"); 155 156 //options not set we define a default one with nothing 157 options = options || {}; 158 159 /** 160 * we cross reference statically hence the mapping here 161 * the entire mapping between the functions is stateless 162 */ 163 //null definitely means no event passed down so we skip the ie specific checks 164 if ('undefined' == typeof event) { 165 event = window.event || null; 166 } 167 168 //improve the error messages if an empty elem is passed 169 if (!elem) { 170 throw _Lang.makeException(new Error(), "ArgNotSet", null, this._nameSpace, "request", _Lang.getMessage("ERR_MUST_BE_PROVIDED1", "{0}: source must be provided", "jsf.ajax.request", "source element id")); 171 } 172 var oldElem = elem; 173 elem = _Dom.byIdOrName(elem); 174 if (!elem) { 175 throw _Lang.makeException(new Error(), "Notfound", null, this._nameSpace, "request", _Lang.getMessage("ERR_PPR_UNKNOWNCID", "{0}: Node with id {1} could not be found from source", this._nameSpace + ".request", oldElem)); 176 } 177 178 var elementId = _Dom.nodeIdOrName(elem); 179 180 /* 181 * We make a copy of our options because 182 * we should not touch the incoming params! 183 * this copy is also the pass through parameters 184 * which are sent down our request 185 */ 186 // this is legacy behavior which is faulty, will be removed if we decide to do it 187 // that way 188 var passThrgh = _Lang.mixMaps({}, options, true, this._BLOCKFILTER); 189 // jsdoc spec everything under params must be passed through 190 if(options.params) { 191 passThrgh = _Lang.mixMaps(passThrgh, options.params, true, {}); 192 } 193 194 if (event) { 195 passThrgh[this.P_EVT] = event.type; 196 } 197 198 199 200 /** 201 * ajax pass through context with the source 202 * onevent and onerror 203 */ 204 var context = { 205 source:elem, 206 onevent:options.onevent, 207 onerror:options.onerror, 208 viewId: "", 209 //TODO move the myfaces part into the _mfInternal part 210 myfaces:options.myfaces, 211 _mfInternal:{} 212 }; 213 //additional meta information to speed things up, note internal non jsf 214 //pass through options are stored under _mfInternal in the context 215 var mfInternal = context._mfInternal; 216 217 /** 218 * fetch the parent form 219 * 220 * note we also add an override possibility here 221 * so that people can use dummy forms and work 222 * with detached objects 223 */ 224 var form = (options.myfaces && options.myfaces.form) ? 225 _Lang.byId(options.myfaces.form) : 226 this._getForm(elem, event); 227 228 context.viewId = this.getViewId(form); 229 230 /** 231 * JSF2.2 client window must be part of the issuing form so it is encoded 232 * automatically in the request 233 */ 234 //we set the client window before encoding by a call to jsf.getClientWindow 235 var clientWindow = jsf.getClientWindow(form); 236 //in case someone decorates the getClientWindow we reset the value from 237 //what we are getting 238 if ('undefined' != typeof clientWindow && null != clientWindow) { 239 var formElem = _Dom.getNamedElementFromForm(form, this.P_CLIENTWINDOW); 240 if (formElem) { 241 //we store the value for later processing during the ajax phase 242 //job so that we do not get double values 243 context._mfInternal._clientWindow = jsf.getClientWindow(form); 244 } else { 245 passThrgh[this.P_CLIENTWINDOW] = jsf.getClientWindow(form); 246 } 247 } /* spec proposal 248 else { 249 var formElem = _Dom.getNamedElementFromForm(form, this.P_CLIENTWINDOW); 250 if (formElem) { 251 context._mfInternal._clientWindow = "undefined"; 252 } else { 253 passThrgh[this.P_CLIENTWINDOW] = "undefined"; 254 } 255 } 256 */ 257 258 /** 259 * binding contract the javax.faces.source must be set 260 */ 261 passThrgh[this.P_PARTIAL_SOURCE] = elementId; 262 263 /** 264 * javax.faces.partial.ajax must be set to true 265 */ 266 passThrgh[this.P_AJAX] = true; 267 268 /** 269 * if resetValues is set to true 270 * then we have to set javax.faces.resetValues as well 271 * as pass through parameter 272 * the value has to be explicitly true, according to 273 * the specs jsdoc 274 */ 275 if(options.resetValues === true) { 276 passThrgh[this.P_RESET_VALUES] = true; 277 } 278 279 if (options.execute) { 280 /*the options must be a blank delimited list of strings*/ 281 /*compliance with Mojarra which automatically adds @this to an execute 282 * the spec rev 2.0a however states, if none is issued nothing at all should be sent down 283 */ 284 options.execute = (options.execute.indexOf("@this") == -1) ? options.execute : options.execute; 285 286 this._transformList(passThrgh, this.P_EXECUTE, options.execute, form, elementId, context.viewId); 287 } else { 288 passThrgh[this.P_EXECUTE] = elementId; 289 } 290 291 if (options.render) { 292 this._transformList(passThrgh, this.P_RENDER, options.render, form, elementId, context.viewId); 293 } 294 295 /** 296 * multiple transports upcoming jsf 2.x feature currently allowed 297 * default (no value) xhrQueuedPost 298 * 299 * xhrQueuedPost 300 * xhrPost 301 * xhrGet 302 * xhrQueuedGet 303 * iframePost 304 * iframeQueuedPost 305 * 306 */ 307 var transportType = this._getTransportType(context, passThrgh, form); 308 309 mfInternal["_mfSourceFormId"] = form.id; 310 mfInternal["_mfSourceControlId"] = elementId; 311 mfInternal["_mfTransportType"] = transportType; 312 313 //mojarra compatibility, mojarra is sending the form id as well 314 //this is not documented behavior but can be determined by running 315 //mojarra under blackbox conditions 316 //i assume it does the same as our formId_submit=1 so leaving it out 317 //won´t hurt but for the sake of compatibility we are going to add it 318 passThrgh[form.id] = form.id; 319 320 /* jsf2.2 only: options.delay || */ 321 var delayTimeout = options.delay || this._RT.getLocalOrGlobalConfig(context, "delay", false); 322 323 if (!!delayTimeout) { 324 if(!(delayTimeout >= 0)) { 325 // abbreviation which covers all cases of non positive values, 326 // including NaN and non-numeric strings, no type equality is deliberate here, 327 throw new Error("Invalid delay value: " + delayTimeout); 328 } 329 if (this._delayTimeout) { 330 clearTimeout(this._delayTimeout); 331 } 332 this._delayTimeout = setTimeout(_Lang.hitch(this, function () { 333 this._transport[transportType](elem, form, context, passThrgh); 334 this._delayTimeout = null; 335 }), parseInt(delayTimeout)); 336 } else { 337 this._transport[transportType](elem, form, context, passThrgh); 338 } 339 }, 340 341 /** 342 * fetches the form in an unprecise manner depending 343 * on an element or event target 344 * 345 * @param elem 346 * @param event 347 */ 348 _getForm:function (elem, event) { 349 var _Dom = this._Dom; 350 var _Lang = this._Lang; 351 var form = _Dom.fuzzyFormDetection(elem); 352 353 if (!form && event) { 354 //in case of no form is given we retry over the issuing event 355 form = _Dom.fuzzyFormDetection(_Lang.getEventTarget(event)); 356 if (!form) { 357 throw _Lang.makeException(new Error(), null, null, this._nameSpace, "_getForm", _Lang.getMessage("ERR_FORM")); 358 } 359 } else if (!form) { 360 throw _Lang.makeException(new Error(), null, null, this._nameSpace, "_getForm", _Lang.getMessage("ERR_FORM")); 361 362 } 363 return form; 364 }, 365 366 /** 367 * determines the transport type to be called 368 * for the ajax call 369 * 370 * @param context the context 371 * @param passThrgh pass through values 372 * @param form the form which issues the request 373 */ 374 _getTransportType:function (context, passThrgh, form) { 375 /** 376 * if execute or render exist 377 * we have to pass them down as a blank delimited string representation 378 * of an array of ids! 379 */ 380 //for now we turn off the transport auto selection, to enable 2.0 backwards compatibility 381 //on protocol level, the file upload only can be turned on if the auto selection is set to true 382 var getConfig = this._RT.getLocalOrGlobalConfig, 383 _Lang = this._Lang, 384 _Dom = this._Dom; 385 386 var transportAutoSelection = getConfig(context, "transportAutoSelection", true); 387 /*var isMultipart = (transportAutoSelection && _Dom.getAttribute(form, "enctype") == "multipart/form-data") ? 388 _Dom.isMultipartCandidate((!getConfig(context, "pps",false))? form : passThrgh[this.P_EXECUTE]) : 389 false; 390 **/ 391 if (!transportAutoSelection) { 392 return getConfig(context, "transportType", "xhrQueuedPost"); 393 } 394 var multiPartCandidate = _Dom.isMultipartCandidate((!getConfig(context, "pps", false)) ? 395 form : passThrgh[this.P_EXECUTE]); 396 var multipartForm = (_Dom.getAttribute(form, "enctype") || "").toLowerCase() == "multipart/form-data"; 397 //spec section jsdoc, if we have a multipart candidate in our execute (aka fileupload) 398 //and the form is not multipart then we have to raise an error 399 if (multiPartCandidate && !multipartForm) { 400 throw _Lang.makeException(new Error(), null, null, this._nameSpace, "_getTransportType", _Lang.getMessage("ERR_NO_MULTIPART_FORM", "No Multipart form", form.id)); 401 } 402 var isMultipart = multiPartCandidate && multipartForm; 403 /** 404 * multiple transports upcoming jsf 2.2 feature currently allowed 405 * default (no value) xhrQueuedPost 406 * 407 * xhrQueuedPost 408 * xhrPost 409 * xhrGet 410 * xhrQueuedGet 411 * iframePost 412 * iframeQueuedPost 413 * 414 */ 415 var transportType = (!isMultipart) ? 416 getConfig(context, "transportType", "xhrQueuedPost") : 417 getConfig(context, "transportType", "multipartQueuedPost"); 418 if (!this._transport[transportType]) { 419 //throw new Error("Transport type " + transportType + " does not exist"); 420 throw new Error(_Lang.getMessage("ERR_TRANSPORT", null, transportType)); 421 } 422 return transportType; 423 424 }, 425 426 /** 427 * transforms the list to the expected one 428 * with the proper none all form and this handling 429 * (note we also could use a simple string replace but then 430 * we would have had double entries under some circumstances) 431 * 432 * @param passThrgh 433 * @param target 434 * @param srcStr 435 * @param form 436 * @param elementId 437 * @param namingContainerId the naming container namingContainerId 438 */ 439 _transformList:function (passThrgh, target, srcStr, form, elementId, namingContainerId) { 440 var _Lang = this._Lang; 441 //this is probably the fastest transformation method 442 //it uses an array and an index to position all elements correctly 443 //the offset variable is there to prevent 0 which results in a javascript 444 //false 445 srcStr = this._Lang.trim(srcStr); 446 var offset = 1, 447 vals = (srcStr) ? srcStr.split(/\s+/) : [], 448 idIdx = (vals.length) ? _Lang.arrToMap(vals, offset) : {}, 449 450 //helpers to improve speed and compression 451 none = idIdx[this.IDENT_NONE], 452 all = idIdx[this.IDENT_ALL], 453 theThis = idIdx[this.IDENT_THIS], 454 theForm = idIdx[this.IDENT_FORM]; 455 456 if (none) { 457 //in case of none nothing is returned 458 if ('undefined' != typeof passThrgh.target) { 459 delete passThrgh.target; 460 } 461 return passThrgh; 462 } 463 if (all) { 464 //in case of all only one value is returned 465 passThrgh[target] = this.IDENT_ALL; 466 return passThrgh; 467 } 468 469 if (theForm) { 470 //the form is replaced with the proper id but the other 471 //values are not touched 472 vals[theForm - offset] = form.id; 473 } 474 if (theThis && !idIdx[elementId]) { 475 //in case of this, the element id is set 476 vals[theThis - offset] = elementId; 477 } 478 479 //the final list must be blank separated 480 passThrgh[target] = this._remapNamingContainer(elementId, form, namingContainerId,vals).join(" "); 481 return passThrgh; 482 }, 483 484 /** 485 * in namespaced situations root naming containers must be resolved 486 * ":" absolute searches must be mapped accordingly, the same 487 * goes for absolut searches containing already the root naming container id 488 * 489 * @param issuingElementId the issuing element id 490 * @param form the hosting form of the issiung element id 491 * @param rootNamingContainerId the root naming container id 492 * @param elements a list of element client ids to be processed 493 * @returns {*} the mapped element client ids, which are resolved correctly to their naming containers 494 * @private 495 */ 496 _remapNamingContainer: function(issuingElementId, form, rootNamingContainerId, elements) { 497 var SEP = jsf.separatorchar; 498 function remapViewId(toTransform) { 499 var EMPTY_STR = ""; 500 var rootNamingContainerPrefix = (rootNamingContainerId.length) ? rootNamingContainerId+SEP : EMPTY_STR; 501 var formClientId = form.id; 502 // nearest parent naming container relative to the form 503 var nearestNamingContainer = formClientId.substring(0, formClientId.lastIndexOf(SEP)); 504 var nearestNamingContainerPrefix = (nearestNamingContainer.length) ? nearestNamingContainer + SEP : EMPTY_STR; 505 // absolut search expression, always starts with SEP or the name of the root naming container 506 var hasLeadingSep = toTransform.indexOf(SEP) === 0; 507 var isAbsolutSearchExpr = hasLeadingSep || (rootNamingContainerId.length 508 && toTransform.indexOf(rootNamingContainerPrefix) == 0); 509 if (isAbsolutSearchExpr) { 510 //we cut off the leading sep if there is one 511 toTransform = hasLeadingSep ? toTransform.substring(1) : toTransform; 512 toTransform = toTransform.indexOf(rootNamingContainerPrefix) == 0 ? toTransform.substring(rootNamingContainerPrefix.length) : toTransform; 513 //now we prepend either the prefix or "" from the cut-off string to get the final result 514 return [rootNamingContainerPrefix, toTransform].join(EMPTY_STR); 515 } else { //relative search according to the javadoc 516 //we cut off the root naming container id from the form 517 if (formClientId.indexOf(rootNamingContainerPrefix) == 0) { 518 formClientId = formClientId.substring(rootNamingContainerPrefix.length); 519 } 520 521 //If prependId = true, the outer form id must be present in the id if same form 522 var hasPrependId = toTransform.indexOf(formClientId) == 0; 523 524 return hasPrependId ? 525 [rootNamingContainerPrefix, toTransform].join(EMPTY_STR) : 526 [nearestNamingContainerPrefix, toTransform].join(EMPTY_STR); 527 } 528 } 529 530 for(var cnt = 0; cnt < elements.length; cnt++) { 531 elements[cnt] = remapViewId(this._Lang.trim(elements[cnt])); 532 } 533 534 return elements; 535 }, 536 537 addOnError:function (/*function*/errorListener) { 538 /*error handling already done in the assert of the queue*/ 539 this._errListeners.enqueue(errorListener); 540 }, 541 542 addOnEvent:function (/*function*/eventListener) { 543 /*error handling already done in the assert of the queue*/ 544 this._evtListeners.enqueue(eventListener); 545 }, 546 547 /** 548 * implementation triggering the error chain 549 * 550 * @param {Object} request the request object which comes from the xhr cycle 551 * @param {Object} context (Map) the context object being pushed over the xhr cycle keeping additional metadata 552 * @param {String} name the error name 553 * @param {String} errorName the server error name in case of a server error 554 * @param {String} errorMessage the server error message in case of a server error 555 * @param {String} caller optional caller reference for extended error messages 556 * @param {String} callFunc optional caller Function reference for extended error messages 557 * 558 * handles the errors, in case of an onError exists within the context the onError is called as local error handler 559 * the registered error handlers in the queue receiv an error message to be dealt with 560 * and if the projectStage is at development an alert box is displayed 561 * 562 * note: we have additional functionality here, via the global config myfaces.config.defaultErrorOutput a function can be provided 563 * which changes the default output behavior from alert to something else 564 * 565 * 566 */ 567 sendError:function sendError(/*Object*/request, /*Object*/ context, /*String*/ name, /*String*/ errorName, /*String*/ errorMessage, caller, callFunc) { 568 var _Lang = myfaces._impl._util._Lang; 569 var UNKNOWN = _Lang.getMessage("UNKNOWN"); 570 571 var eventData = {}; 572 //we keep this in a closure because we might reuse it for our errorMessage 573 var malFormedMessage = function () { 574 return (name && name === myfaces._impl.core.Impl.MALFORMEDXML) ? _Lang.getMessage("ERR_MALFORMEDXML") : ""; 575 }; 576 577 //by setting unknown values to unknown we can handle cases 578 //better where a simulated context is pushed into the system 579 eventData.type = this.ERROR; 580 581 eventData.status = name || UNKNOWN; 582 eventData.errorName = errorName || UNKNOWN; 583 eventData.errorMessage = errorMessage || UNKNOWN; 584 585 try { 586 eventData.source = context.source || UNKNOWN; 587 eventData.responseCode = request.status || UNKNOWN; 588 eventData.responseText = request.responseText || UNKNOWN; 589 eventData.responseXML = request.responseXML || UNKNOWN; 590 } catch (e) { 591 // silently ignore: user can find out by examining the event data 592 } 593 //extended error message only in dev mode 594 if (jsf.getProjectStage() === "Development") { 595 eventData.errorMessage = eventData.errorMessage || ""; 596 eventData.errorMessage = (caller) ? eventData.errorMessage + "\nCalling class: " + caller : eventData.errorMessage; 597 eventData.errorMessage = (callFunc) ? eventData.errorMessage + "\n Calling function: " + callFunc : eventData.errorMessage; 598 } 599 600 /**/ 601 if (context["onerror"]) { 602 context.onerror(eventData); 603 } 604 605 /*now we serve the queue as well*/ 606 this._errListeners.broadcastEvent(eventData); 607 608 if (jsf.getProjectStage() === "Development" && this._errListeners.length() == 0 && !context["onerror"]) { 609 var DIVIDER = "--------------------------------------------------------", 610 defaultErrorOutput = myfaces._impl.core._Runtime.getGlobalConfig("defaultErrorOutput", (console && console.error) ? console.error : alert), 611 finalMessage = [], 612 //we remap the function to achieve a better compressability 613 pushMsg = _Lang.hitch(finalMessage, finalMessage.push); 614 615 (errorMessage) ? pushMsg(_Lang.getMessage("MSG_ERROR_MESSAGE") + " " + errorMessage + "\n") : null; 616 617 pushMsg(DIVIDER); 618 619 (caller) ? pushMsg("Calling class:" + caller) : null; 620 (callFunc) ? pushMsg("Calling function:" + callFunc) : null; 621 (name) ? pushMsg(_Lang.getMessage("MSG_ERROR_NAME") + " " + name) : null; 622 (errorName && name != errorName) ? pushMsg("Server error name: " + errorName) : null; 623 624 pushMsg(malFormedMessage()); 625 pushMsg(DIVIDER); 626 pushMsg(_Lang.getMessage("MSG_DEV_MODE")); 627 defaultErrorOutput(finalMessage.join("\n")); 628 } 629 }, 630 631 /** 632 * sends an event 633 */ 634 sendEvent:function sendEvent(/*Object*/request, /*Object*/ context, /*event name*/ name) { 635 var _Lang = myfaces._impl._util._Lang; 636 var eventData = {}; 637 var UNKNOWN = _Lang.getMessage("UNKNOWN"); 638 639 eventData.type = this.EVENT; 640 641 eventData.status = name; 642 eventData.source = context.source; 643 644 if (name !== this.BEGIN) { 645 646 try { 647 //we bypass a problem with ie here, ie throws an exception if no status is given on the xhr object instead of just passing a value 648 var getValue = function (value, key) { 649 try { 650 return value[key] 651 } catch (e) { 652 return UNKNOWN; 653 } 654 }; 655 656 eventData.responseCode = getValue(request, "status"); 657 eventData.responseText = getValue(request, "responseText"); 658 eventData.responseXML = getValue(request, "responseXML"); 659 660 } catch (e) { 661 var impl = myfaces._impl.core._Runtime.getGlobalConfig("jsfAjaxImpl", myfaces._impl.core.Impl); 662 impl.sendError(request, context, this.CLIENT_ERROR, "ErrorRetrievingResponse", 663 _Lang.getMessage("ERR_CONSTRUCT", e.toString())); 664 665 //client errors are not swallowed 666 throw e; 667 } 668 669 } 670 671 /**/ 672 if (context.onevent) { 673 /*calling null to preserve the original scope*/ 674 context.onevent.call(null, eventData); 675 } 676 677 /*now we serve the queue as well*/ 678 this._evtListeners.broadcastEvent(eventData); 679 }, 680 681 /** 682 * Spec. 13.3.3 683 * Examining the response markup and updating the DOM tree 684 * @param {XMLHttpRequest} request - the ajax request 685 * @param {Object} context - the ajax context 686 */ 687 response:function (request, context) { 688 this._RT.getLocalOrGlobalConfig(context, "responseHandler", myfaces._impl.xhrCore._AjaxResponse).processResponse(request, context); 689 }, 690 691 /** 692 * fetches the separator char from the given script tags 693 * 694 * @return {char} the separator char for the given script tags 695 */ 696 getSeparatorChar:function () { 697 if (this._separator) { 698 return this.separatorchar; 699 } 700 var SEPARATOR_CHAR = "separatorchar", 701 found = false, 702 getConfig = myfaces._impl.core._Runtime.getGlobalConfig, 703 scriptTags = document.getElementsByTagName("script"); 704 for (var i = 0; i < scriptTags.length && !found; i++) { 705 if (scriptTags[i].src.search(/\/javax\.faces\.resource.*\/jsf\.js.*separator/) != -1) { 706 found = true; 707 var result = scriptTags[i].src.match(/separator=([^&;]*)/); 708 this._separator = decodeURIComponent(result[1]); 709 } 710 } 711 this._separator = getConfig(SEPARATOR_CHAR, this._separator || ":"); 712 return this._separator; 713 }, 714 715 /** 716 * @return the project stage also emitted by the server: 717 * it cannot be cached and must be delivered over the server 718 * The value for it comes from the request parameter of the jsf.js script called "stage". 719 */ 720 getProjectStage:function () { 721 //since impl is a singleton we only have to do it once at first access 722 723 if (!this._projectStage) { 724 var PRJ_STAGE = "projectStage", 725 STG_PROD = "Production", 726 727 scriptTags = document.getElementsByTagName("script"), 728 getConfig = myfaces._impl.core._Runtime.getGlobalConfig, 729 projectStage = null, 730 found = false, 731 allowedProjectStages = {STG_PROD:1, "Development":1, "SystemTest":1, "UnitTest":1}; 732 733 /* run through all script tags and try to find the one that includes jsf.js */ 734 for (var i = 0; i < scriptTags.length && !found; i++) { 735 if (scriptTags[i] && scriptTags[i].src && scriptTags[i].src.search(/\/javax\.faces\.resource\/jsf\.js.*ln=javax\.faces/) != -1) { 736 var result = scriptTags[i].src.match(/stage=([^&;]*)/); 737 found = true; 738 if (result) { 739 // we found stage=XXX 740 // return only valid values of ProjectStage 741 projectStage = (allowedProjectStages[result[1]]) ? result[1] : null; 742 743 } 744 else { 745 //we found the script, but there was no stage parameter -- Production 746 //(we also add an override here for testing purposes, the default, however is Production) 747 projectStage = getConfig(PRJ_STAGE, STG_PROD); 748 } 749 } 750 } 751 /* we could not find anything valid --> return the default value */ 752 this._projectStage = getConfig(PRJ_STAGE, projectStage || STG_PROD); 753 } 754 return this._projectStage; 755 }, 756 757 /** 758 * implementation of the external chain function 759 * moved into the impl 760 * 761 * @param {Object} source the source which also becomes 762 * the scope for the calling function (unspecified side behavior) 763 * the spec states here that the source can be any arbitrary code block. 764 * Which means it either is a javascript function directly passed or a code block 765 * which has to be evaluated separately. 766 * 767 * After revisiting the code additional testing against components showed that 768 * the this parameter is only targeted at the component triggering the eval 769 * (event) if a string code block is passed. This is behavior we have to resemble 770 * in our function here as well, I guess. 771 * 772 * @param {Event} event the event object being passed down into the the chain as event origin 773 * the spec is contradicting here, it on one hand defines event, and on the other 774 * it says it is optional, after asking, it meant that event must be passed down 775 * but can be undefined 776 */ 777 chain:function (source, event) { 778 var len = arguments.length; 779 var _Lang = this._Lang; 780 var throwErr = function (msgKey) { 781 throw Error("jsf.util.chain: " + _Lang.getMessage(msgKey)); 782 }; 783 /** 784 * generic error condition checker which raises 785 * an exception if the condition is met 786 * @param assertion 787 * @param message 788 */ 789 var errorCondition = function (assertion, message) { 790 if (assertion === true) throwErr(message); 791 }; 792 var FUNC = 'function'; 793 var ISSTR = _Lang.isString; 794 795 //the spec is contradicting here, it on one hand defines event, and on the other 796 //it says it is optional, I have cleared this up now 797 //the spec meant the param must be passed down, but can be 'undefined' 798 799 errorCondition(len < 2, "ERR_EV_OR_UNKNOWN"); 800 errorCondition(len < 3 && (FUNC == typeof event || ISSTR(event)), "ERR_EVT_PASS"); 801 if (len < 3) { 802 //nothing to be done here, move along 803 return true; 804 } 805 //now we fetch from what is given from the parameter list 806 //we cannot work with splice here in any performant way so we do it the hard way 807 //arguments only are give if not set to undefined even null values! 808 809 //assertions source either null or set as dom element: 810 errorCondition('undefined' == typeof source, "ERR_SOURCE_DEF_NULL"); 811 errorCondition(FUNC == typeof source, "ERR_SOURCE_FUNC"); 812 errorCondition(ISSTR(source), "ERR_SOURCE_NOSTR"); 813 814 //assertion if event is a function or a string we already are in our function elements 815 //since event either is undefined, null or a valid event object 816 errorCondition(FUNC == typeof event || ISSTR(event), "ERR_EV_OR_UNKNOWN"); 817 818 for (var cnt = 2; cnt < len; cnt++) { 819 //we do not change the scope of the incoming functions 820 //but we reuse the argument array capabilities of apply 821 var ret; 822 823 if (FUNC == typeof arguments[cnt]) { 824 ret = arguments[cnt].call(source, event); 825 } else { 826 //either a function or a string can be passed in case of a string we have to wrap it into another function 827 ret = new Function("event", arguments[cnt]).call(source, event); 828 } 829 //now if one function returns false in between we stop the execution of the cycle 830 //here, note we do a strong comparison here to avoid constructs like 'false' or null triggering 831 if (ret === false /*undefined check implicitly done here by using a strong compare*/) { 832 return false; 833 } 834 } 835 return true; 836 }, 837 838 /** 839 * error handler behavior called internally 840 * and only into the impl it takes care of the 841 * internal message transformation to a myfaces internal error 842 * and then uses the standard send error mechanisms 843 * also a double error logging prevention is done as well 844 * 845 * @param request the request currently being processed 846 * @param context the context affected by this error 847 * @param exception the exception being thrown 848 */ 849 stdErrorHandler:function (request, context, exception) { 850 //newer browsers do not allow to hold additional values on native objects like exceptions 851 //we hence capsule it into the request, which is gced automatically 852 //on ie as well, since the stdErrorHandler usually is called between requests 853 //this is a valid approach 854 if (this._threshold == "ERROR") { 855 var mfInternal = exception._mfInternal || {}; 856 857 var finalMsg = []; 858 finalMsg.push(exception.message); 859 this.sendError(request, context, 860 mfInternal.title || this.CLIENT_ERROR, mfInternal.name || exception.name, finalMsg.join("\n"), mfInternal.caller, mfInternal.callFunc); 861 } 862 }, 863 864 /** 865 * @return the client window id of the current window, if one is given 866 */ 867 getClientWindow:function (node) { 868 var fetchWindowIdFromForms = this._Lang.hitch(this, function (forms) { 869 var result_idx = {}; 870 var result; 871 var foundCnt = 0; 872 for (var cnt = forms.length - 1; cnt >= 0; cnt--) { 873 874 var currentForm = forms[cnt]; 875 var winIdElement = this._Dom.getNamedElementFromForm(currentForm, this.P_WINDOW_ID); 876 var windowId = (winIdElement) ? winIdElement.value : null; 877 878 if (windowId) { 879 if (foundCnt > 0 && "undefined" == typeof result_idx[windowId]) throw Error("Multiple different windowIds found in document"); 880 result = windowId; 881 result_idx[windowId] = true; 882 foundCnt++; 883 } 884 } 885 return result; 886 }); 887 888 var fetchWindowIdFromURL = function () { 889 var href = window.location.href, windowId = "jfwid"; 890 var regex = new RegExp("[\\?&]" + windowId + "=([^&#\\;]*)"); 891 var results = regex.exec(href); 892 //initial trial over the url and a regexp 893 if (results != null) return results[1]; 894 return null; 895 }; 896 897 //byId ($) 898 var finalNode = (node) ? this._Dom.byId(node) : document.body; 899 900 var forms = this._Dom.findByTagName(finalNode, "form"); 901 var result = fetchWindowIdFromForms(forms); 902 return (null != result) ? result : fetchWindowIdFromURL(); 903 }, 904 905 /** 906 * returns the view id from an incoming form 907 * crossport from new codebase 908 * @param form 909 */ 910 getViewId: function (form) { 911 var _t = this; 912 var foundViewStates = this._Dom.findAll(form, function(node) { 913 return node.tagName === "INPUT" && node.type === "hidden" && (node.name || "").indexOf(_t.P_VIEWSTATE) !== -1 914 }, true); 915 if(!foundViewStates.length) { 916 return ""; 917 } 918 var viewId = foundViewStates[0].id.split(jsf.separatorchar, 2)[0]; 919 var viewStateViewId = viewId.indexOf(this.P_VIEWSTATE) === -1 ? viewId : ""; 920 // myfaces specific, we in non portlet environments prepend the viewId 921 // even without being in a naming container, the other components ignore that 922 return form.id.indexOf(viewStateViewId) === 0 ? viewStateViewId : ""; 923 } 924 }); 925 926 927