telosys
(root)/trunk/js/ScreenActions_class.js @ 13 - Rev 13
Blame | Last modification | View Log | RSS feed
//------------------------------------------------------------------------------
// ScreenActions_class.js ( client stub to invoke server actions )
// Telosys framework
// Author : Laurent Guérin
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// CLASS DEFINITION
//------------------------------------------------------------------------------
function ScreenActions( paramScreen, paramAsyncFlag )
{
//==============================================================================
// PRIVATE CONSTANTS
//==============================================================================
var RETRIEVE_NOTHING = 0 ;
var RETRIEVE_ALL = 1 ;
var NOT_SET = 0 ;
var ASYNC = 1 ;
var SYNC = 2 ;
//==============================================================================
// PRIVATE ATTRIBUTES
//==============================================================================
var _bTrace = false ;
var _oScreen = null ;
var _iDefaultMode = SYNC ;
var _iMode = NOT_SET ;
var _oRequester = new ScreenActionsXHR(); // The AJAX requester
var _fPermanentCallback = null ; // Permanent external callback function, set to be used each time an action is called
var _fTemporaryCallback = null ; // Temporary external callback function, set to be used only one time
var _sFlagClear = null ; // Request Flag "clear"
var _sFlagSet = null ; // Request Flag "set"
var _sFlagGet = null ; // Request Flag "get"
var _oParameters = new Map(); // The parameters to send in the action request
var _oElements = new Map() ; // The elements to retrieve
var _oViews = new Map() ; // The views to retrieve
var _bUpdateScreen = true ;
var _bClearScreen = true ;
var _sLastRequestURL = null ;
var _sLastRequestXML = null ;
var _sLastResponseXML = null ;
var _fInternalResponseProcessor = null ;
//==============================================================================
// PSEUDO CONSTRUCTOR
//==============================================================================
if ( paramScreen != null )
{
_oScreen = paramScreen ;
}
else
{
alert ( "ERROR in ScreenActions constructor : no screen parameter !" );
}
if ( paramAsyncFlag != null )
{
_iDefaultMode = ( paramAsyncFlag == true ? ASYNC : SYNC ) ;
}
else
{
_iDefaultMode = SYNC ;
}
//==============================================================================
// PRIVATE METHODS
//==============================================================================
function _trace ( sMsg )
{
if ( _bTrace ) alert ( "TRACE [ScreenActions] :\n\n" + sMsg ) ;
}
//------------------------------------------------------------------------------
function _error ( sMsg )
{
alert ( "ERROR [ScreenActions] :\n\n" + sMsg ) ;
}
//------------------------------------------------------------------------------
// Returns a request with the given action and the parameters to send
//------------------------------------------------------------------------------
this.getRequest = function ( sAction )
{
//--- Create a new request
var request = new ScreenRequest();
//--- Init the request
request.setScreenName( _oScreen.getScreenName() );
request.setScreenId ( _oScreen.getScreenId() );
//--- Set the action name ( "get", "set", "load", .. )
if ( sAction )
{
request.setAction(sAction);
}
//--- Set the action FLAGS in the request
if ( _sFlagClear != null ) { request.setFlagClear(_sFlagClear) } ;
if ( _sFlagSet != null ) { request.setFlagSet (_sFlagSet) } ;
if ( _sFlagGet != null ) { request.setFlagGet (_sFlagGet) } ;
//--- Set the action PARAMETERS in the request
if ( _oParameters.size() > 0 )
{
var name = null ;
var names = _oParameters.keysArray();
var n = names.length ;
// for ( i in names ) // for .. in cannot be used with "prototype.js"
for ( var i = 0 ; i < n ; i++ )
{
name = names[i] ;
request.setParameter(name, _oParameters.get(name) );
}
//--- Clear the action parameters
_oParameters.clear();
}
return request ;
}
//------------------------------------------------------------------------------
function _beforeSend()
{
// Clear Flags
_sFlagClear = null ;
_sFlagSet = null ;
_sFlagGet = null ;
// Clear Parameters, Elements and Views
_oParameters.clear();
_oElements.clear();
_oViews.clear();
}
//------------------------------------------------------------------------------
// Response processing used by SYNCHRONOUS and ASYNCHRONOUS calls
//------------------------------------------------------------------------------
function _processResponse(response)
{
_trace("_processResponse(response)...");
var bResponseProcessed = false ;
//--- 1) Keep last response for debug window
_sLastResponseXML = response.getResponseText();
//--- 2) Process the response for screen impacts ( using the internal processing if any )
if ( _fInternalResponseProcessor != null )
{
_fInternalResponseProcessor(response); // call _updateScreen or _clearScreen or _updateScreenAfterDelete
_fInternalResponseProcessor = null ; // Just "for once" => unset after use
}
//--- 3) Call the screen "developer callback function" if any ( supposed to process response errors )
if ( _fTemporaryCallback != null )
{
// There's a specific external temporary callback function => use it
_fTemporaryCallback(response) ;
_fTemporaryCallback = null ; // Temporary => Just "for once" => unset after use
}
else
{
if ( _fPermanentCallback != null ) // see setPermanentCallback(..)
{
// There's a specific external permanent callback function (for all actions) => use it
_fPermanentCallback(response) ;
}
else
{
// No application callback => Default response error processing
if ( response.reportsErrors() )
{
if ( typeof window.onTelosysActionError == "function" )
{
// call the application error handler (if any)
window.onTelosysActionError(response);
}
else
{
// by default show all the error messages
response.showAllErrors();
}
}
}
}
}
//------------------------------------------------------------------------------
// The callback function called by the XHR object when the response has been
// received after an ASYNCHRONOUS call
//------------------------------------------------------------------------------
function _ajaxAsynchronousCallback(response)
{
//--- 1) Hide the "WAIT" SYMBOL
// TODO : HIDE "WAIT"
//--- 2) Process the response
_processResponse(response);
}
//------------------------------------------------------------------------------
function _sendRequest(req, applicationCallerFunction, responseProcessor )
{
_beforeSend();
if ( _oRequester == null )
{
throw new Error( "ScreenActions._sendRequest() : The AJAX requester is null ! ");
}
if ( _oScreen == null )
{
throw new Error( "ScreenActions._sendRequest() : The SCREEN object is null ! ");
}
_sLastRequestURL = _oScreen.getRequestURL() ;
_sLastRequestXML = req.getXmlRequest();
// Set the hidden internal response processor to use ( can be null if none )
_fInternalResponseProcessor = responseProcessor ; // _updateScreen, _clearScreen, _updateScreenAfterDelete or null
/***
_bUpdateScreen = false ;
if ( bUpdateScreen == null || bUpdateScreen == true )
{
_bUpdateScreen = true ;
}
***/
//--- Call mode : SYNC or ASYNC ?
var iCallMode = _iDefaultMode ;
if ( _iMode != NOT_SET )
{
iCallMode = _iMode ;
_iMode = NOT_SET ; // Reset for next call
}
//--- Use a callback function for post processing ( for SYNC and ASYNC modes )
if ( _fTemporaryCallback == null ) // not set => use "applicationCallerFunction.callback" if any
{
_fTemporaryCallback = ( applicationCallerFunction != null ? applicationCallerFunction.callback : null ) ;
}
if ( iCallMode == ASYNC )
{
//--- Send the request with an ASYNCHRONOUS call
_oRequester.postAsync ( _sLastRequestXML, _ajaxAsynchronousCallback, _sLastRequestURL );
//--- The request is sent => Display the "WAIT SYMBOL"
// TODO : DISPLAY "WAIT"
return null ; // ASYNCHRONOUS => No response to return ( just wait the callback processing )
}
else
{
//--- No callback function => SYNCHRONOUS call
_oRequester.postSync ( _sLastRequestXML, _sLastRequestURL ); // SYNC => wait the response
//--- The responce is here
var response = _oRequester.getResponse();
_processResponse(response);
return response ; // SYNCHRONOUS => Return the response ( for backward compatibility )
}
}
//------------------------------------------------------------------------------
// Set request elements
//------------------------------------------------------------------------------
function _setElements(request, elements)
{
// alert("_setElements");
if ( elements != null )
{
if ( elements.length == 0 )
{
//--- No elements => get all the elements of the screen
request.setElements(_oScreen.getElementsString());
}
else
{
//--- Build the elements list
var sElementsList = "" ;
var iNbElements = 0 ;
for ( i=0 ; i < elements.length ; i++ )
{
if ( typeof elements[i] == "string" )
{
if ( iNbElements > 0 )
{
sElementsList += ",";
}
sElementsList += elements[i];
iNbElements++;
}
}
//--- Set the given elements list in the request
request.setElements(sElementsList);
}
}
}
//------------------------------------------------------------------------------
// Set a view in the request (with renderer if any)
//------------------------------------------------------------------------------
/***
function _setView(request, psViewName, psRenderer )
{
var oScreenView = _searchView( psViewName ) ;
if ( oScreenView != null )
{
if ( psRenderer != null )
{
request.setView( oScreenView.getName(), psRenderer );
}
else
{
request.setView( oScreenView.getName(), oScreenView.getRenderer() );
}
}
}
***/
function _setView(request, psViewName, psRenderer ) // v 1.1.0
{
if ( request == null ) _error ( "_setView : request parameter is null" ) ;
if ( psViewName == null ) _error ( "_setView : view name parameter is null" ) ;
if ( psRenderer != null )
{
// A specific renderer is given => just use it
request.setView( psViewName, psRenderer );
}
else
{
// No renderer => get the renderer associated with the view ( supposed to be a registered view )
var oScreenView = _searchView( psViewName ) ;
if ( oScreenView != null )
{
request.setView( oScreenView.getName(), oScreenView.getRenderer() );
}
}
}
//------------------------------------------------------------------------------
// Set the given views in the request
//------------------------------------------------------------------------------
function _setViews(request, views)
{
if ( views != null )
{
if ( views.length == 0 )
{
//--- No views => set all the views of the screen in the request
_setAllViews(request);
}
else
{
//--- Set the given views in the request
for ( i=0 ; i < views.length ; i++ )
{
if ( typeof views[i] != "string" )
{
_error( "_setViews() : argument[" + i + "] is not a String ! type = " + typeof views[i] );
}
else
{
var oScreenView = _searchView( views[i] ) ;
if ( oScreenView != null )
{
request.setView( oScreenView.getName(), oScreenView.getRenderer() );
}
}
}
}
}
}
//------------------------------------------------------------------------------
// Set all the views of the screen in the request
//------------------------------------------------------------------------------
function _setAllViews(request)
{
//--- Set views names if any
var views = _oScreen.getViews();
if ( views != null )
{
var oScreenView = null ;
//--- For each view registered in this screen
for ( var i = 0 ; i < views.length ; i++ )
{
oScreenView = views[i] ;
if ( oScreenView != null )
{
request.setView( oScreenView.getName(), oScreenView.getRenderer() );
}
else
{
_error( "_setAllViews() : ScreenViews ["+i+"] is null ! " );
}
}
}
}
//------------------------------------------------------------------------------
// Set the elements to retrieve in the request according with the elements list
// defined by "setElementToRetrieve()"
//------------------------------------------------------------------------------
function _setWhatToRetrieve(request, defaultFlag )
{
if ( _oElements == null )
{
_error( "_setWhatToRetrieve() : _oElements is null" );
return;
}
if ( _oViews == null )
{
_error( "_setWhatToRetrieve() : _oViews is null" );
return;
}
if ( _oElements.size() == 0 && _oViews.size() == 0 )
{
//--- Nothing specified => Retrieve ALL or NOTHING ( cf Flag )
if ( defaultFlag == RETRIEVE_ALL )
{
//--- Retrieve ALL ( everything : elements + views )
request.setElements( _oScreen.getElementsString() );
_setAllViews(request);
}
else
{
//--- Retrieve NOTHING
request.setElements( "" ); // No elements
// No views
}
}
else
{
_setElementsToRetrieve(request);
_setViewsToRetrieve(request);
}
}
//------------------------------------------------------------------------------
// Set the elements to retrieve in the request according with the elements list
// defined by "setElementToRetrieve()"
//------------------------------------------------------------------------------
function _setElementsToRetrieve(request)
{
var sElementsList = null ;
if ( _oElements.size() > 0 )
{
//--- Elements specified
sElementsList = _oElements.keysString();
}
else
{
////--- No elements => get all the elements of the screen
//sElementsList = _oScreen.getElementsString() ;
//--- No elements => Do not get elements
sElementsList = "" ;
}
request.setElements(sElementsList);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Set the views to retrieve in the request according with the views list
// defined by "setViewToRetrieve()"
//------------------------------------------------------------------------------
function _setViewsToRetrieve(request)
{
//--- Set the views to retrieve
if ( _oViews.size() > 0 )
{
var names = _oViews.keysArray();
var n = names.length ;
var name = null ;
var renderer = null ;
for ( var i = 0 ; i < n ; i++ )
{
name = names[i] ;
renderer = _oViews.get(name); // Specific renderer or null for standard renderer
_setView(request, name, renderer ) ;
}
}
/** DO NOT GET VIEWS
else
{
_setAllViews(request);
}
**/
}
//------------------------------------------------------------------------------
// Search a view (by name) in the views list of the screen
//------------------------------------------------------------------------------
function _searchView(psViewName)
{
var views = _oScreen.getViews();
if ( views != null )
{
var oScreenView = null ;
//--- For each view registered in this screen
for ( var i = 0 ; i < views.length ; i++ )
{
oScreenView = views[i] ;
if ( oScreenView != null )
{
if ( oScreenView.getName() == psViewName )
{
return oScreenView ;
}
}
else
{
_error( "_searchView() : ScreenViews ["+i+"] is null ! " );
}
}
_error( "_searchView() : unknown view '" + psViewName + "' ! " );
}
else
{
_error( "_searchView() : no views in this screen ! " );
}
return null;
}
//------------------------------------------------------------------------------
// Internal response processors
//------------------------------------------------------------------------------
function _updateScreen ( response )
{
_trace ( "_updateScreen : flag = " + _bUpdateScreen );
if ( response.isOK() && _bUpdateScreen )
{
//--- Populate the screen fields and views with XML data recieved
_oScreen.XmlToScreen(response);
}
}
//------------------------------------------------------------------------------
function _clearScreen ( response )
{
_trace ( "_clearScreen : flag = " + _bUpdateScreen );
if ( response.isOK() && _bUpdateScreen )
{
//--- Clear the screen
_oScreen.clear();
}
}
//------------------------------------------------------------------------------
function _updateScreenAfterDelete ( response )
{
_trace ( "_updateScreenAfterDelete : _bClearScreen = " + _bClearScreen + " _bUpdateScreen = " + _bUpdateScreen );
if ( response.isOK() )
{
if ( _bClearScreen )
{
//--- Clear the screen
_oScreen.clear();
}
if ( _bUpdateScreen )
{
//--- Populate FIELDS and VIEWS
_oScreen.XmlToScreen(response);
}
}
}
//==============================================================================
// PUBLIC / PRIVILEGED METHODS
//==============================================================================
/**
* Retuns the Screen instance
* @return Object the Screen instance
*/
this.getScreen = function ()
{
return _oScreen ;
}
//------------------------------------------------------------------------------
// FLAGS
//------------------------------------------------------------------------------
this.setTrace = function ( p )
{
_bTrace = p ;
_oRequester.setTrace(p);
}
//------------------------------------------------------------------------------
this.doNotClearContextData = function ()
{
_sFlagClear = "false" ;
}
//------------------------------------------------------------------------------
this.doNotSetContextData = function ()
{
_sFlagSet = "false" ;
}
//------------------------------------------------------------------------------
this.doNotGetContextData = function ()
{
_sFlagGet = "false" ;
}
//------------------------------------------------------------------------------
this.setModeAsync = function ()
{
_iMode = ASYNC ;
}
this.setModeSync = function ()
{
_iMode = SYNC ;
}
//------------------------------------------------------------------------------
this.setDefaultModeAsync = function ()
{
_iDefaultMode = ASYNC ;
}
this.setDefaultModeSync = function ()
{
_iDefaultMode = SYNC ;
}
//------------------------------------------------------------------------------
this.setPermanentCallback = function ( p ) // v 1.0.5 (replace setDefaultCallback)
{
_fPermanentCallback = p ;
}
//------------------------------------------------------------------------------
this.setTemporaryCallback = function ( p ) // v 1.0.5 (replace setCallback)
{
_fTemporaryCallback = p ;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// PARAMETERS
//------------------------------------------------------------------------------
this.setParameter = function (sName, sValue)
{
if ( sName == null )
{
_error ( "setParameter(name,value) : name is null" ) ;
}
if ( sValue == null )
{
_error ( "setParameter(name,value) : value is null" ) ;
}
_oParameters.put(sName, sValue) ;
}
//------------------------------------------------------------------------------
this.clearParameters = function ()
{
_oParameters.clear() ;
}
//------------------------------------------------------------------------------
this.showParameters = function ()
{
_oParameters.show() ;
}
//------------------------------------------------------------------------------
this.numberOfParameters = function () // v 1.1.0
{
return _oParameters.size() ;
}
//------------------------------------------------------------------------------
// ELEMENTS TO RETRIEVE
//------------------------------------------------------------------------------
this.setElementToRetrieve = function (sElementName)
{
if ( sElementName == null )
{
_error ( "setElementToRetrieve(element_name) : element name is null" ) ;
}
_oElements.put(sElementName, null) ;
}
//------------------------------------------------------------------------------
this.setElementsToRetrieve = function ()
{
if ( arguments.length > 0 )
{
for ( var i=0 ; i<arguments.length ; i++ )
{
_oElements.put(arguments[i], null ) ;
}
}
else
{
_error ( "setElementsToRetrieve(..) : argument(s) expected !" ) ;
}
}
//------------------------------------------------------------------------------
this.clearElementsToRetrieve = function ()
{
_oElements.clear() ;
}
//------------------------------------------------------------------------------
this.showElementsToRetrieve = function ()
{
_oElements.show() ;
}
//------------------------------------------------------------------------------
// VIEWS TO RETRIEVE
//------------------------------------------------------------------------------
this.setViewToRetrieve = function (sViewName, sRenderer)
{
if ( sViewName == null )
{
_error ( "setViewToRetrieve(name,renderer) : view name is null" ) ;
}
_oViews.put(sViewName, sRenderer) ; // sRenderer can be null ( = default renderer )
/*
if ( sRenderer != null )
{
_oViews.put(sViewName, sRenderer) ;
}
else
{
_oViews.put(sViewName, "") ;
//_error ( "setViewToRetrieve(name,renderer) : renderer is null" ) ;
}
*/
}
//------------------------------------------------------------------------------
this.setViewsToRetrieve = function ()
{
if ( arguments.length > 0 )
{
for ( var i=0 ; i<arguments.length ; i++ )
{
_oElements.put(arguments[i], null ) ; // default renderer
}
}
else
{
_error ( "setViewsToRetrieve(..) : arguments expected !" ) ;
}
}
//------------------------------------------------------------------------------
this.clearViewsToRetrieve = function ()
{
_oViews.clear() ;
}
//------------------------------------------------------------------------------
this.showViewsToRetrieve = function ()
{
_oViews.show() ;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// A C T I O N S
//------------------------------------------------------------------------------
this.doOpen = function ()
{
_trace("doOpen()");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("open") ;
//--- Send the request
response = _sendRequest(request, arguments.callee.caller );
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doClose = function ()
{
_trace("doClose()");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("close") ;
//--- Send the request
response = _sendRequest(request, arguments.callee.caller );
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doGetViews = function ()
{
_trace("doGetViews()");
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("get") ;
//--- Don't want elements => set "elements" to void list
request.setElements("");
//--- Set views and renderer
_setViews(request, arguments);
//--- Send the request
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doGetView = function ( psViewName, psRenderer )
{
_trace("doGetView(" + psViewName + "," + psRenderer + ")" );
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("get") ;
//--- Don't want elements => set "elements" to void list
request.setElements("");
//--- Set the given view
_setView(request, psViewName, psRenderer ) ;
//--- Send the request
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/**
* Invokes the standard "GET" action with an elements list
* @param Variable list of arguments ( 0 .. N )
* if the last argument is a boolean it is considered as the update screen flag
* @return Object the server response object
*/
this.doGetElements = function ()
{
_trace("doGetElements()");
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("get") ;
_setElements(request, arguments);
//var bUpdateScreen =_getUpdateScreenFlag(arguments, true);
//--- Send the request
// response = _sendRequest(request, arguments.callee.caller, _afterGet, bUpdateScreen );
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/***
response = _sendRequest(request);
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
***/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/**
* Invokes the standard "GET" action to get data from the server
* Get all the Screen Context elements and all the views
* @param boolean true = update the screen, false = no screen update
* @return Object the server response object
*/
this.doGet = function ( bUpdateScreen )
{
_trace("doGet(" + bUpdateScreen + ")");
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("get") ;
//--- Set what to retrieve : elements and/or views ( RETRIEVE_ALL by default )
_setWhatToRetrieve(request, RETRIEVE_ALL);
//--- Send the request
// response = _sendRequest(request, arguments.callee.caller, _afterGet, bUpdateScreen );
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/**
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/**
* Invokes the standard "SET" action to update data on the server
* Set all the Screen Context elements
* @return Object the server response object
*/
this.doSet = function ( bUpdateScreen )
{
_trace("doSet(" + bUpdateScreen + ")");
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : false ) ; // default FALSE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("set") ;
var sXmlData = _oScreen.ScreenToXml();
request.setData(sXmlData);
//--- Send the request
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/**
* Invokes the standard "CLEAR" action to clear the Screen Context on the server
* @param boolean true = clear the screen fields, false = do not clear the screen fields
* @return Object the server response object
*/
this.doClear = function ( bUpdateScreen )
{
_trace("doClear(" + bUpdateScreen +")" );
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("clear") ;
//--- Send the request
// response = _sendRequest(request, arguments.callee.caller, _afterClear, bUpdateScreen );
response = _sendRequest(request, arguments.callee.caller, _clearScreen );
/**
response = _sendRequest(request);
if ( response.isOK() )
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Clear the screen
_oScreen.clear();
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
// LOAD ACTIONS
//------------------------------------------------------------------------------
this.doLoadViews = function ()
{
_trace("doLoadViews()");
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("load") ;
//--- Don't want elements => set "elements" to void list
request.setElements("");
//--- Set views and renderer
_setViews(request, arguments);
//--- Send the request
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/**
response = _sendRequest(request);
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
_oScreen.XmlToScreen(response);
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doLoadView = function ( psViewName, psRenderer )
{
_trace("doLoadView(" + psViewName + "," + psRenderer + ")");
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("load") ;
//--- Don't want elements => set "elements" to void list
request.setElements("");
//--- Set the given view
_setView(request, psViewName, psRenderer ) ;
//--- Send the request ( retrieve the response )
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/***
response = _sendRequest(request);
//--- Use the response ( View => allways update screen )
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
_oScreen.XmlToScreen(response);
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doLoadElements = function ()
{
_trace("doLoadElements(...)");
_bUpdateScreen = true ; // always TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("load") ;
//--- Elements to get after the load
_setElements(request, arguments);
//--- Flag to update (or not) the screen fields
//var bUpdateScreen =_getUpdateScreenFlag(arguments, true);
//--- Send the request ( retrieve the response )
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/**
response = _sendRequest(request);
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doLoad = function ( bUpdateScreen )
{
_trace("doLoad("+bUpdateScreen+")");
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("load") ;
//--- Set what to retrieve : elements and/or views ( RETRIEVE_ALL by default )
_setWhatToRetrieve(request, RETRIEVE_ALL);
//--- Send the request
response = _sendRequest(request, arguments.callee.caller, _updateScreen );
/**
response = _sendRequest(request);
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
**/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/***
function _afterLoad ( response )
{
alert ( "_afterLoad" );
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
if ( _bUpdateScreen )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
}
***/
//------------------------------------------------------------------------------
this.populateFields = function (response)
{
if ( response.isOK() )
{
if ( response.dataNotFound() != true ) // Data Found
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
else
{
//alert("ERROR : cannot populate fields ( response status is not OK ) !");
_error("populateFields(response) : cannot populate fields ( response status is not OK ) !");
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// param Action : "save", "insert", "update"
//------------------------------------------------------------------------------
this.sendScreenData = function ( sAction, applicationCallerFunction, bUpdateScreen )
{
_trace("sendScreenData : Action = '" + sAction + "'" );
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest(sAction) ;
//--- Set what to retrieve : elements and/or views ( RETRIEVE_NOTHING by default )
_setWhatToRetrieve(request, RETRIEVE_NOTHING);
//--- Build the XML tree from screen fields
var sXmlData = _oScreen.ScreenToXml();
request.setData(sXmlData);
//--- Send the request ( retrieve the response )
//response = _sendRequest(request, applicationCallerFunction, _afterSavInsUpd, bUpdateScreen );
response = _sendRequest(request, applicationCallerFunction, _updateScreen );
/***
response = _sendRequest(request);
if ( bUpdateScreen == true )
{
if ( response.isOK() )
{
//--- Populate FIELDS and VIEWS
_oScreen.XmlToScreen(response);
}
}
***/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
/***
function _afterSavInsUpd ( response )
{
alert ( "_afterSavInsUpd" );
if ( response.isOK() )
{
if ( _bUpdateScreen )
{
//--- Populate FIELDS and VIEWS
_oScreen.XmlToScreen(response);
}
}
}
***/
//------------------------------------------------------------------------------
this.doSave = function ( bUpdateScreen )
{
_trace("doSave("+bUpdateScreen+")");
return this.sendScreenData("save", arguments.callee.caller, bUpdateScreen );
}
//------------------------------------------------------------------------------
this.doInsert = function ( bUpdateScreen )
{
_trace("doInsert("+bUpdateScreen+")");
return this.sendScreenData("insert", arguments.callee.caller, bUpdateScreen );
}
//------------------------------------------------------------------------------
this.doUpdate = function ( bUpdateScreen )
{
_trace("doUpdate("+bUpdateScreen+")");
return this.sendScreenData("update", arguments.callee.caller, bUpdateScreen );
}
//------------------------------------------------------------------------------
this.doDelete = function ( bClearScreen, bUpdateScreen )
{
_trace("doDelete( " + bClearScreen + ", " + bUpdateScreen + " )" );
_bClearScreen = ( bClearScreen != null ? bClearScreen : true ) ; // default TRUE
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
try {
//--- Build the request
var request = this.getRequest("delete") ;
//--- Set what to retrieve : elements and/or views ( RETRIEVE_NOTHING by default )
_setWhatToRetrieve(request, RETRIEVE_NOTHING);
//--- Send the request ( retrieve the response )
//response = _sendRequest(request, arguments.callee.caller);
response = _sendRequest(request, arguments.callee.caller, _updateScreenAfterDelete);
/***
if ( response.isOK() )
{
if ( bClearScreen == null || bClearScreen == true )
{
//--- Clear the screen
_oScreen.clear();
}
if ( bUpdateScreen != null && bUpdateScreen == true )
{
//--- Populate FIELDS and VIEWS
_oScreen.XmlToScreen(response);
}
}
***/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
// ACTIONS FOR LIST MANAGEMENT
//------------------------------------------------------------------------------
this.doListSelect = function ( sListName, sItemName, iOldIndex, iIndex, bUpdateScreen )
{
_trace("Action : SelectListElement");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_select") ;
request.setParameter( "list", sListName );
request.setParameter( "item", sItemName );
request.setParameter( "old-index", iOldIndex );
request.setParameter( "new-index", iIndex );
//request.setData( _oScreen.ScreenToXml() );
request.setData( _oScreen.ScreenToXml(sItemName) ); // NEW
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doListInsert = function ( sListName, sItemName, iOldIndex, iIndex, bUpdateScreen )
{
_trace("Action : ListInsert");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_insert") ;
request.setParameter( "list", sListName );
request.setParameter( "item", sItemName );
request.setParameter( "new-index", iIndex );
request.setParameter( "old-index", iOldIndex );
//request.setData( _oScreen.ScreenToXml() );
request.setData( _oScreen.ScreenToXml(sItemName) ); // NEW
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doListAdd = function ( sListName, sItemName, iOldIndex, bUpdateScreen )
{
_trace("Action : ListAdd");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_add") ;
request.setParameter( "list", sListName );
request.setParameter( "item", sItemName );
//request.setParameter( "new-index", iIndex );
request.setParameter( "old-index", iOldIndex );
//request.setData( _oScreen.ScreenToXml() );
request.setData( _oScreen.ScreenToXml(sItemName) ); // NEW
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doListRemove = function ( sListName, sItemName, iOldIndex, iIndex, bUpdateScreen )
{
_trace("Action : ListRemove");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_remove") ;
request.setParameter( "list", sListName );
request.setParameter( "item", sItemName );
request.setParameter( "new-index", iIndex );
request.setParameter( "old-index", iOldIndex );
//request.setData( _oScreen.ScreenToXml() );
request.setData( _oScreen.ScreenToXml(sItemName) ); // NEW
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
if ( response.isOK() )
{
if ( response.dataVoid() != true ) // Data is not void
{
if ( bUpdateScreen == null || bUpdateScreen == true )
{
//--- Populate the screen fields with XML data recieved
_oScreen.XmlToScreen(response);
}
}
}
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doListClear = function ( sListName, sItemName, iOldIndex )
{
_trace("Action : ListClear");
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_clear") ;
request.setParameter( "list", sListName );
//request.setParameter( "item", sItemName );
//request.setParameter( "new-index", iIndex );
request.setParameter( "old-index", iOldIndex );
//request.setData( _oScreen.ScreenToXml(sItemName) );
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.doListSort = function ( sListName, sItemName, iOldIndex, sFieldName, sOrder )
{
_trace("Action : ListSort");
if ( arguments.length < 4 )
{
_error ( "doListSort() : 4 or 5 arguments expected ( " + arguments.length + " arguments )" ) ;
return ;
}
var response = null ;
try {
//--- Build the request
var request = this.getRequest("list_sort") ;
//--- Set what to retrieve : elements and/or views ( RETRIEVE_NOTHING by default )
_setWhatToRetrieve(request, RETRIEVE_NOTHING);
request.setParameter( "list", sListName );
//--- Sort parameters
request.setParameter( "column", sFieldName );
if ( sOrder != null ) // order parameter is optional
{
request.setParameter( "order", sOrder );
}
//--- Update current item before sort ?
if ( sItemName != null && iOldIndex != null )
{
request.setParameter( "item", sItemName );
request.setParameter( "old-index", iOldIndex );
request.setData( _oScreen.ScreenToXml(sItemName) ); // NEW
}
else
{
request.setParameter( "item", "" ); // No item to update
request.setParameter( "old-index", "-1" ); // No item index
}
//--- Send the request
response = _sendRequest(request, arguments.callee.caller);
if ( response.isOK() )
{
//--- Populate the screen fields with list view recieved
_oScreen.XmlToScreen(response);
}
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
this.doExec = function (sProcName, bUpdateScreen)
{
_trace("doExec( "+sProcName+", "+bUpdateScreen+" )");
_bUpdateScreen = ( bUpdateScreen != null ? bUpdateScreen : true ) ; // default TRUE
var response = null ;
if ( sProcName == null )
{
_error ( "doExec() : No procedure name (argument is null) " );
}
try {
//--- Build the request
var request = this.getRequest("exec") ;
//--- Set the procedure name
request.setProcedure(sProcName);
//--- Set what to retrieve : elements and/or views
//_setWhatToRetrieve(request, RETRIEVE_ALL);
_setWhatToRetrieve(request, RETRIEVE_NOTHING); // RETRIEVE_NOTHING by default
//--- Send the request ( retrieve the response )
response = _sendRequest(request, arguments.callee.caller, _updateScreen);
/*** OLD
if ( response.isOK() )
{
//--- Call external method ????
this.afterExec(request,response);
}
***/
}
catch (ex) {
_error ( ex.message );
}
return response ;
}
//------------------------------------------------------------------------------
this.setParametersFromFields = function ( argElementName ) // v 1.1.0
{
_oScreen.setParametersFromFields( _oParameters, argElementName);
}
//----------------------------------------------------------------------------------------------------
this.openWindowLastAction = function(sURL, sRequest, sResponse )
{
var sHtml =
"<html><head><title>Last screen action</title></head>" +
"<body style='margin:4px; background-color: #D4D0C8;'>" +
"<table style='width:100%;height:100%;' >" +
"<tr style='height:26px;' ><td style='width:70px;' >URL : </td>" +
"<td><input style='width:100%;' type='text' value='" + sURL + "' />" +
"</td></tr>" +
"<tr style='height:40%;' ><td style='width:70px; vertical-align: top;' >Request : </td>" +
"<td><textarea id='requestArea' style='width:100%;height:100%;overflow: scroll;' readonly='readonly' >" +
"</textarea>" +
"</td></tr>" +
"<tr style='height:60%;' ><td style='width:70px; vertical-align: top;' >Response : </td>" +
"<td><textarea id='responseArea' style='width:100%;height:100%;overflow: scroll;' readonly='readonly' >" +
"</textarea>" +
"</td></tr>" +
"</table>" +
"</body></html>" ;
var sParams = 'status=no,resizable=yes,toolbars=no,menubar=no,titlebar=no,statusbar=no,hotkeys=no' ;
sParams=sParams + ',screenX=80,screenY=80' ; // NETSCAPE
sParams=sParams + ',left=80,top=80' ; // IE
var win = window.open( "", "LastAction", sParams ) ; // open ( "URL", "name", "parameters" );
win.document.write ( sHtml ) ;
win.document.close();
var requestArea = win.document.getElementById('requestArea');
if ( requestArea != null )
{
requestArea.value = sRequest ;
}
else
{
alert ("ERROR : Cannot found element for id 'requestArea' ");
}
var responseArea = win.document.getElementById('responseArea');
if ( responseArea != null )
{
responseArea.value = sResponse ;
}
else
{
alert ("ERROR : Cannot found element for id 'responseArea' ");
}
win.focus();
}
//------------------------------------------------------------------------------
this.showLastAction = function ()
{
this.openWindowLastAction(_sLastRequestURL, _sLastRequestXML, _sLastResponseXML);
}
}
//------------------------------------------------------------------------------
// F I N
//------------------------------------------------------------------------------
Generated by GNU enscript 1.6.4.