Keel 2.1RC2

Uses of Class
org.keel.services.model.ModelException

Packages that use ModelException
org.keel.apps.crud.models A Model that provides Create/Update/Delete/Remove functions for any persistant object. 
org.keel.apps.fileservices.model   
org.keel.apps.fileservices.model.example   
org.keel.apps.navigate.models A Model that provides navigation capability both within and between Keel applications 
org.keel.apps.poll.models Application logic classes of the Poll Application. 
org.keel.apps.register.models User registration, login and related models. 
org.keel.apps.security.models   
org.keel.clients This package contains the describing interface for all Keel clients - each individual client implementation allows a UI framework to access Keel models, running in the same or separate VM. 
org.keel.clients.axis   
org.keel.clients.cli Package containing the "wrapper" for the Command-Line Interface to Keel. 
org.keel.clients.cocoon This package contains the code that connects Keel to Cocoon. 
org.keel.clients.direct The client "connector" classes for direct (single-VM) connection to the Keel server. 
org.keel.clients.jms JMS Client for User Interface implementations. 
org.keel.clients.maverick   
org.keel.clients.quartz Client interface for connection to the Quartz scheduler. 
org.keel.clients.socket   
org.keel.clients.struts   
org.keel.clients.velocity.servlet   
org.keel.clients.webapp This package contains the describing interface for all Keel clients that are implemented as a servlet/webapp. 
org.keel.clients.webwork2   
org.keel.comm Model Implementation for Serialization and transport via JMS. 
org.keel.comm.jbossmq.clients   
org.keel.comm.openjms.clients   
org.keel.models.test Simple models designed to test basic functionality within Keel. 
org.keel.models.util General Utility and Test Models. 
org.keel.models.util.workflow   
org.keel.models.util.workflow.testmodels   
org.keel.red.workflow.engine   
org.keel.servers Server Applications - provide Keel Models and Services via various protocols. 
org.keel.servers.direct   
org.keel.servers.jms   
org.keel.servers.socket   
org.keel.services.authentication.config   
org.keel.services.authorization.defaultauth   
org.keel.services.event.jbossmq   
org.keel.services.event.openjms   
org.keel.services.mail.javamail.models   
org.keel.services.model Model Services - Application Logic Containers. 
org.keel.services.model.defaultmodel Default Model service implementation. 
org.keel.services.model.session Stateless session bean interface to ModelRequest. 
org.keel.services.model.session.test   
org.keel.services.persist Persistence Service - Storing objects in databases and other persistent stores. 
org.keel.services.persist.base   
org.keel.services.persist.hibernate.model   
org.keel.services.schedule.quartz This package implements the Keel schedule service using the open-source Quartz package as the underlying scheduler. 
org.keel.services.script.bsf.models   
org.keel.services.script.jelly.models   
org.keel.wireless.example.app.model   
 

Uses of ModelException in org.keel.apps.crud.models
 

Methods in org.keel.apps.crud.models that throw ModelException
protected  void UpdateBase.showKey(ModelRequest req, ModelResponse res, boolean withEditLink)
          Display a table showing the key fields of this object and their values.
 ModelResponse Prompt.execute(ModelRequest req)
          Prompt the user to choose a Schema
protected abstract  void GetBase.autoField(ModelRequest req, ModelResponse res, java.lang.String oneFieldName)
          implemented by subclass
private  void GetBase.autoForm(ModelRequest req, ModelResponse res)
          Show an "auto" form - a default form that just lists all of the fields on a Persistent for simple data entry
protected  void GetBase.showForm(ModelRequest req, ModelResponse res)
          Show the HTML form to the user - this form may be for add/update or search and may or may not be populated with data when presented to the user.
 ModelResponse Add.execute(ModelRequest req)
           
 ModelResponse CrudBase.execute(ModelRequest req)
          All of the sub-classes of this class extend the execute method to perform their functionality.
protected  void CrudBase.saveSettings(ModelRequest req)
           
protected  void CrudBase.showOptions(ModelRequest req, ModelResponse res)
          Display a small table of icons giving the user the option to proceed directly to a search, add, or list function from this form.
protected  void CrudBase.showUserName(ModelRequest req, ModelResponse res, java.lang.String theDescrip)
           
protected  Persistent CrudBase.getPersistent(ModelRequest req)
          Given a class name that contains a Persistent, instantiate an instance of the object & return it.
protected  int CrudBase.getPageNumber(ModelRequest req)
          Parse out the currently requested page number
protected  void CrudBase.showEditLink(ModelRequest req, ModelResponse res, java.lang.String fieldName, java.lang.String oneFieldValue, Persistent currentRecord, Output myElement)
          Write a hyperlink command that allows edit of the current key
 ModelResponse Update.execute(ModelRequest req)
           
protected  void PromptUpdate.autoField(ModelRequest req, ModelResponse res, java.lang.String oneFieldName)
           
 ModelResponse PromptUpdate.execute(ModelRequest req)
           
 ModelResponse Lookup.execute(ModelRequest req)
          All of the sub-classes of DynamicCmd extend the run method to perform their functionality.
 ModelResponse Delete.execute(ModelRequest req)
           
 ModelResponse List.execute(ModelRequest req)
           
private  long Query.listRecords(ModelRequest req, ModelResponse res, java.lang.String sortKey, Output myTable)
           
 ModelResponse Query.execute(ModelRequest req)
           
protected  void PromptAdd.autoField(ModelRequest req, ModelResponse res, java.lang.String oneFieldName)
          Automatically handle a single field on the form
 ModelResponse PromptAdd.execute(ModelRequest req)
          Prompt the user for a new record
protected  void PromptQuery.autoField(ModelRequest req, ModelResponse res, java.lang.String oneFieldName)
           
 ModelResponse PromptQuery.execute(ModelRequest req)
           
 ModelResponse SelectPersistent.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.apps.fileservices.model
 

Methods in org.keel.apps.fileservices.model that throw ModelException
 ModelResponse FileDownloadModel.execute(ModelRequest req)
           
 ModelResponse ListUploadedFiles.execute(ModelRequest req)
           
private  void ListUploadedFiles.processDir(ModelResponse res, Output uploadedFiles, java.io.File uploadFileDir, java.lang.String fileDir, java.io.FilenameFilter filter)
          Process the directory, and list the selected files in the Output.
private  ModelRequest ListUploadedFiles.setParamsFromConfig(ModelRequest req, Configuration modelConfig)
           
 ModelResponse FileUploadModel.execute(ModelRequest req)
           
private  boolean FileUploadModel.uploadFile(java.lang.String fileName, byte[] fileData, java.lang.String uploadDir)
           
private  ModelResponse FileUploadModel.prompt(ModelRequest req, java.lang.String max_file_size_filter)
           
private  ModelRequest FileUploadModel.setParamsFromConfig(ModelRequest req, Configuration modelConfig)
           
 ModelResponse FileManageModel.execute(ModelRequest request)
          Executes the FileManage Request
protected  File FileManageModel.getFileFromRequest(ModelRequest req, java.lang.String key, java.lang.String errorKey)
          Gets the File object at the requested key from the request object.
 

Uses of ModelException in org.keel.apps.fileservices.model.example
 

Methods in org.keel.apps.fileservices.model.example that throw ModelException
 ModelResponse FileUploadExample.execute(ModelRequest req)
           
private  ModelResponse FileUploadExample.process(ModelRequest req)
           
private  ModelRequest FileUploadExample.setParamsFromConfig(ModelRequest req, Configuration modelConfig)
           
 

Uses of ModelException in org.keel.apps.navigate.models
 

Methods in org.keel.apps.navigate.models that throw ModelException
 ModelResponse Navigate.execute(ModelRequest req)
           
private  void Navigate.doChildrenOf(Configuration conf, ModelRequest req, ModelResponse res, Output parent, int level, java.util.List selected)
          Process the children of a specific configuration entry for a menu - called recursively to handle nesting
 

Uses of ModelException in org.keel.apps.poll.models
 

Methods in org.keel.apps.poll.models that throw ModelException
 ModelResponse ListParticipants.execute(ModelRequest req)
           
 ModelResponse AddCategory.execute(ModelRequest req)
           
 ModelResponse PromptUser.execute(ModelRequest req)
           
 ModelResponse AddPoll.execute(ModelRequest req)
           
 ModelResponse DeleteCategory.execute(ModelRequest req)
           
 ModelResponse ListUsers.execute(ModelRequest req)
           
 ModelResponse DeletePoll.execute(ModelRequest req)
           
 ModelResponse QueryUser.execute(ModelRequest req)
           
 ModelResponse Results.execute(ModelRequest req)
           
 ModelResponse PromptUpdatePoll.execute(ModelRequest req)
           
 ModelResponse UpdateQuestion.execute(ModelRequest req)
           
 ModelResponse ListPolls.execute(ModelRequest req)
           
 ModelResponse PromptUpdateCategory.execute(ModelRequest req)
           
 ModelResponse PromptCategorySecurity.execute(ModelRequest req)
           
 ModelResponse PromptPollSecurity.execute(ModelRequest req)
           
 ModelResponse UpdateChoice.execute(ModelRequest req)
           
 ModelResponse UpdatePoll.execute(ModelRequest req)
           
 ModelResponse DeleteChoice.execute(ModelRequest req)
           
 ModelResponse PromptPoll.execute(ModelRequest req)
           
 ModelResponse ProcessCategory.execute(ModelRequest req)
           
 ModelResponse PromptUpdateChoice.execute(ModelRequest req)
           
 ModelResponse PromptQuestion.execute(ModelRequest req)
          This model creates all the elements to create a screen to add a new question to a given poll
 ModelResponse UpdateCategory.execute(ModelRequest req)
           
 ModelResponse PromptVote.execute(ModelRequest req)
           
 ModelResponse ListChoices.execute(ModelRequest req)
           
 ModelResponse PromptChoice.execute(ModelRequest req)
           
 ModelResponse ListCategories.execute(ModelRequest req)
           
 ModelResponse ListQuestions.execute(ModelRequest req)
           
 ModelResponse AddQuestion.execute(ModelRequest req)
           
 ModelResponse DeleteQuestion.execute(ModelRequest req)
           
 ModelResponse SubmitVote.execute(ModelRequest req)
           
 ModelResponse PollsTaken.execute(ModelRequest req)
           
 ModelResponse AddChoice.execute(ModelRequest req)
           
 ModelResponse ViewResponses.execute(ModelRequest req)
           
 ModelResponse ProcessPollSecurity.execute(ModelRequest req)
           
 ModelResponse PromptCategory.execute(ModelRequest req)
          This state creates all the elements to prompt for a screen to add a new category.
 ModelResponse PromptUpdateQuestion.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.apps.register.models
 

Methods in org.keel.apps.register.models that throw ModelException
 ModelResponse Register.execute(ModelRequest req)
           
 ModelResponse PromptChangePassword.execute(ModelRequest req)
           
 ModelResponse PromptSendPassword.execute(ModelRequest req)
           
 ModelResponse ChangePassword.execute(ModelRequest req)
           
 ModelResponse Login.execute(ModelRequest req)
           
 ModelResponse HeaderInfo.execute(ModelRequest req)
           
protected  java.lang.String LoginBase.decodeWithSeq(java.lang.String[] seq, java.lang.String original, ModelRequest req)
           
protected  java.lang.String LoginBase.encodeWithSeq(java.lang.String[] seq, java.lang.String original, ModelRequest req)
           
protected  ModelResponse LoginBase.createLoginInfoOutput(ModelRequest req, ModelResponse res)
           
 ModelResponse LogOff.execute(ModelRequest req)
           
 ModelResponse VerifyLogin.execute(ModelRequest req)
           
private  void VerifyLogin.addHeaders(ModelRequest req, ModelResponse res)
           
private  boolean VerifyLogin.alreadyLoggedIn(ModelRequest req, ModelResponse res)
           
private  boolean VerifyLogin.tryLoginViaCookie(ModelRequest req, ModelResponse res)
          See if we can log in via stored cookies passed from the user's browser
 ModelResponse SendPassword.execute(ModelRequest req)
           
 java.lang.String SendPassword.getRandomPassword(ModelRequest req)
           
 ModelResponse PromptLogin.execute(ModelRequest req)
           
 ModelResponse PromptRegistration.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.apps.security.models
 

Methods in org.keel.apps.security.models that throw ModelException
 ModelResponse ListComponents.execute(ModelRequest req)
           
 ModelResponse OperationDelete.execute(ModelRequest req)
           
private  long UserOperationList.listRecords(ModelRequest req, ModelResponse res, java.lang.String sortKey, Output myTable)
           
 ModelResponse UserOperationList.execute(ModelRequest req)
           
 ModelResponse CompDelete.execute(ModelRequest req)
           
 ModelResponse ComponentSecurity.execute(ModelRequest req)
           
private  ModelResponse ComponentSecurity.processCompAdd(ModelRequest req, ModelResponse res)
           
private  PersistentFactory ComponentSecurity.getPersistentFactory(ModelRequest req)
          Obtains the PersistentFactory
 ModelResponse UserOperationDelete.execute(ModelRequest req)
           
 ModelResponse OperationSecurity.execute(ModelRequest req)
           
private  ModelResponse OperationSecurity.processOperationAdd(ModelRequest req, ModelResponse res)
           
private  java.util.Map OperationSecurity.verifyUserInput(ModelRequest req)
           
private  PersistentFactory OperationSecurity.getPersistentFactory(ModelRequest req)
          Obtains the PersistentFactory
private  long OperationList.listRecords(ModelRequest req, ModelResponse res, java.lang.String sortKey, Output myTable)
           
 ModelResponse OperationList.execute(ModelRequest req)
           
 ModelResponse UserCompDelete.execute(ModelRequest req)
           
 ModelResponse UserComponentSecurity.execute(ModelRequest req)
           
private  ModelResponse UserComponentSecurity.processUserCompAdd(ModelRequest req, ModelResponse res)
           
private  PersistentFactory UserComponentSecurity.getPersistentFactory(ModelRequest req)
          Obtains the PersistentFactory
private  long CompList.listRecords(ModelRequest req, ModelResponse res, java.lang.String sortKey, Output myTable)
           
 ModelResponse CompList.execute(ModelRequest req)
           
 ModelResponse UserOperationSecurity.execute(ModelRequest req)
           
private  ModelResponse UserOperationSecurity.processOperationAdd(ModelRequest req, ModelResponse res)
           
private  java.util.Map UserOperationSecurity.verifyUserInput(ModelRequest req)
           
private  PersistentFactory UserOperationSecurity.getPersistentFactory(ModelRequest req)
          Obtains the PersistentFactory
private  long UserCompList.listRecords(ModelRequest req, ModelResponse res, java.lang.String sortKey, Output myTable)
           
 ModelResponse UserCompList.execute(ModelRequest req)
           
 ModelResponse AuthorizationModel.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.clients
 

Methods in org.keel.clients that throw ModelException
 KeelResponse KeelClient.execute(KeelRequest req)
          Run a business-process, using a request/response architecture
 KeelResponse ClientConnector.execute(KeelRequest req)
          Run the business-model using a request/response pair
 KeelResponse AbstractClientConnector.execute(KeelRequest kreq)
           
 

Uses of ModelException in org.keel.clients.axis
 

Methods in org.keel.clients.axis that throw ModelException
 KeelResponse AxisClient.execute(KeelRequest req)
          Pass on the request for a model to the configured web service.
 void AxisClient.open()
          Not used for this class
 void AxisClient.close()
          Not used for this class
 

Uses of ModelException in org.keel.clients.cli
 

Methods in org.keel.clients.cli that throw ModelException
private static KeelClient Keel.getClient()
           
 

Uses of ModelException in org.keel.clients.cocoon
 

Methods in org.keel.clients.cocoon that throw ModelException
 KeelResponse FacesCocoonClientConnector.execute()
          Basically cram everything into a CocoonKeelStruct, put that in the application map (where the various phase listeners and the renderers can get at it) and call the lifecycle.
 KeelResponse CocoonClientConnector.execute()
           
 

Uses of ModelException in org.keel.clients.direct
 

Methods in org.keel.clients.direct that throw ModelException
private  KeelStarter KeelClientDirect.getStarter()
           
 KeelResponse KeelClientDirect.execute(KeelRequest request)
           
 

Uses of ModelException in org.keel.clients.jms
 

Methods in org.keel.clients.jms that throw ModelException
 void KeelJmsClient.open()
          The user of this KeelJmsClient can call open explicitly, or it will be called automatically the first time a message is sent.
 void KeelJmsClient.close()
          The caller should always use "close()" to close out the KeelJmsClient when it's done with it.
 

Uses of ModelException in org.keel.clients.maverick
 

Methods in org.keel.clients.maverick that throw ModelException
 KeelResponse MaverickClientConnector.execute()
           
 

Uses of ModelException in org.keel.clients.quartz
 

Methods in org.keel.clients.quartz that throw ModelException
static KeelResponse QuartzDirectSchedule.execute(KeelRequest request)
          Deprecated.  
 

Uses of ModelException in org.keel.clients.socket
 

Methods in org.keel.clients.socket that throw ModelException
 KeelResponse KeelSocketClient.execute(KeelRequest req)
          Pass on the request for a model to the configured web service.
 

Uses of ModelException in org.keel.clients.struts
 

Methods in org.keel.clients.struts that throw ModelException
 KeelResponse StrutsClientConnector.execute()
           
static KeelClient KeelWebappSupport.getClient(HttpSession session)
          This method examines the current list of available KeelJmsClient obejcts, and returns the first one for use.
 

Uses of ModelException in org.keel.clients.velocity.servlet
 

Methods in org.keel.clients.velocity.servlet that throw ModelException
 Template KeelVelocityServlet.handleRequest(HttpServletRequest request, HttpServletResponse response, Context ctx)
           
 KeelResponse VelocityClientConnector.execute()
           
 

Uses of ModelException in org.keel.clients.webapp
 

Methods in org.keel.clients.webapp that throw ModelException
protected  KeelResponse AbstractWebappClientConnector.execute(WebappRequest wreq, WebappResponse wres, java.lang.String defaultModelName)
          This method is called after the webapp-specific request/response pair has been wrapped into a WebappRequest and WebappResponse pair.
 KeelResponse WebappClientConnector.execute()
          Run the business model, using a request/response pair The description sounds curious since the method doesn't take a request as an argument! This is because although most webapps use the HttpServletRequest/HttpServletResponse pair, some, particularly Cocoon, do not and use their own abstraction.
 

Uses of ModelException in org.keel.clients.webwork2
 

Methods in org.keel.clients.webwork2 that throw ModelException
 KeelResponse Webwork2ClientConnector.execute()
           
 

Uses of ModelException in org.keel.comm
 

Methods in org.keel.comm that throw ModelException
static KeelResponse ModelResponseDeserializer.deserialize(org.w3c.dom.Element root)
           
 void ModelResponseMessage.addOutput(java.lang.String name, java.lang.String content)
           
 void ModelResponseMessage.addOutput(java.lang.String content)
           
 Output ModelResponseMessage.createOutput(java.lang.String name)
           
 Output ModelResponseMessage.createOutput(java.lang.String name, java.lang.String content)
           
 Input ModelResponseMessage.createInput(java.lang.String name)
           
 void ModelResponseMessage.addInput(java.lang.String name, java.lang.String label)
           
 Command ModelResponseMessage.createCommand(java.lang.String model)
           
 Command ModelResponseMessage.createCommandRelativeSequence(int numberOfSteps)
           
 void ModelResponseMessage.addCommand(java.lang.String model, java.lang.String label)
           
 void ModelResponseMessage.add(ResponseElement re)
          The Model (only) uses the method below to add new response elements to this response.
 void ModelResponseMessage.copyFrom(ModelResponse res)
           
 ModelResponse CommandMessage.execute(ModelRequest req, ModelResponse res)
           
 ModelResponse CommandMessage.execute(ModelRequest req, ModelResponse res, boolean includeParams, boolean includeResponseElements)
           
 

Uses of ModelException in org.keel.comm.jbossmq.clients
 

Methods in org.keel.comm.jbossmq.clients that throw ModelException
 void KeelJmsClientJbossMQ.open()
          The user of this KeelJmsClient can call open explicitly, or it will be called automatically the first time a message is sent.
 KeelResponse KeelJmsClientJbossMQ.execute(KeelRequest req)
           
 void KeelJmsClientJbossMQ.close()
          The caller should always use "close()" to close out the KeelJmsClient when it's done with it.
 

Uses of ModelException in org.keel.comm.openjms.clients
 

Methods in org.keel.comm.openjms.clients that throw ModelException
 void KeelJmsClientOpenJMS.open()
          The user of this KeelJmsClient can call open explicitly, or it will be called automatically the first time a message is sent.
 KeelResponse KeelJmsClientOpenJMS.execute(KeelRequest req)
           
 void KeelJmsClientOpenJMS.close()
          The caller should always use "close()" to close out the KeelJmsClient when it's done with it.
 

Uses of ModelException in org.keel.models.test
 

Methods in org.keel.models.test that throw ModelException
 ModelResponse TestChart.execute(ModelRequest req)
           
 ModelResponse Test.execute(ModelRequest req)
           
 ModelResponse TestSecurityException.execute(ModelRequest req)
           
 ModelResponse TestInput.execute(ModelRequest req)
           
 ModelResponse TestCookies.execute(ModelRequest req)
           
 ModelResponse TestWriteContext.execute(ModelRequest req)
           
 ModelResponse TestValidations.execute(ModelRequest req)
           
 ModelResponse TestError.execute(ModelRequest req)
           
 ModelResponse TestTiming.execute(ModelRequest req)
           
 ModelResponse TestException.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.models.util
 

Methods in org.keel.models.util that throw ModelException
 ModelResponse CreateDBSchema.execute(ModelRequest req)
           
 ModelResponse CreateDB.execute(ModelRequest req)
           
static SequenceContext SequenceContext.getSequenceContext(ModelRequest req)
          Gets and returns the sequenceContext for the current sequence, using the ModelRequest req to look up the current sequenceContext from the Context.
static SequenceContext SequenceContext.getSequenceContext(Context context)
          Gets and returns the sequenceContext for the current sequence, using the context passed in to look up the current sequenceContext.
 void SequenceContext.setCurrentResponse(ModelResponse newResponse)
          Sets the currentResponse.
static ModelResponse SequenceContext.mergeResponse(ModelResponse base, ModelResponse layer)
           
 ModelResponse Sequence.execute(ModelRequest req)
           
private  ModelResponse Sequence.runSequence(Configuration myConf, ModelRequest req, boolean mergeDefaultForThisSequence)
           
private  SequenceContext Sequence.setNewSequenceContext(java.lang.String modelName, int seq, Configuration[] children, boolean mergeDefault, ModelRequest req, ModelResponse res)
           
private  void Sequence.clearSequence(ModelRequest req)
           
private  ModelResponse Sequence.runModel(Configuration modelConfig, ModelRequest req, ModelResponse existingResponse, int seqNumber, java.lang.String seqName, SequenceContext seqContext)
           
 ModelResponse Prompt.execute(ModelRequest req)
          Prepare a prompt response according to configuration
 ModelResponse Bean.execute(ModelRequest req)
          Run the specified Java class (or bean)
static SequenceInfo SequenceInfo.getSequenceInfo(Context context)
           
static SequenceInfo SequenceInfo.getSequenceInfo(ModelRequest req)
           
static Configuration SequenceInfo.getCurrentStep(ModelRequest req)
           
static Configuration SequenceInfo.getCurrentStep(Context context)
           
static Configuration[] SequenceInfo.getSequenceSteps(ModelRequest req)
           
static Configuration[] SequenceInfo.getSequenceSteps(Context context)
           
 Configuration[] SequenceInfo.getSequenceSteps()
           
 ModelResponse Log.execute(ModelRequest req)
          Don't affect the request or response, just log the current response
 ModelResponse DisplayConfig.execute(ModelRequest req)
           
private  void DisplayConfig.addChildren(ModelResponse res, Output parent, Configuration conf)
           
 ModelResponse Validate.execute(ModelRequest req)
          Simply execute the model specified in configuration - all validation is done by the time this method begins.
 

Uses of ModelException in org.keel.models.util.workflow
 

Methods in org.keel.models.util.workflow that throw ModelException
protected  java.lang.String KeelWorkflow.getModelName(ModelRequest request)
           
private  RedMemory KeelWorkflow.getMemory(RedEngine engine)
           
protected  Configuration KeelWorkflow.getNextSequence(ModelRequest request, boolean advance)
           
private  void KeelWorkflow.rollBackWorkflow(ModelRequest request, int numToRollBack)
           
private  void KeelWorkflow.storeBackRefreshIndex(ModelRequest request)
           
private  void KeelWorkflow.addBackRefreshInfo(ModelRequest request, ModelResponse response)
           
 ModelResponse KeelWorkflow.execute(ModelRequest request)
           
private  ModelResponse KeelWorkflow.executeWorkflow(ModelRequest request)
           
private  void KeelWorkflow.addToMemoryHistory(ModelRequest request)
           
private  boolean KeelWorkflow.isFirstModel()
           
private  void KeelWorkflow.removeMemory()
           
protected  Configuration KeelWorkflow.getConfig()
           
private  void KeelWorkflow.putInContext(ModelRequest request, java.lang.Object key, java.lang.Object value)
          Store a key/value pair in the workflow context
private  java.lang.Object KeelWorkflow.getFromContext(ModelRequest request, java.lang.Object key)
          Get a parameter from thje workflow context
private  java.util.Map KeelWorkflow.getContext(ModelRequest request)
          This function returns the workflow context for this workflow.
 

Uses of ModelException in org.keel.models.util.workflow.testmodels
 

Methods in org.keel.models.util.workflow.testmodels that throw ModelException
 ModelResponse PromptVirginia.execute(ModelRequest request)
           
 ModelResponse PromptWhatQuestion.execute(ModelRequest request)
           
 ModelResponse InitialWorkflowPage.execute(ModelRequest request)
           
 ModelResponse GoHome.execute(ModelRequest request)
           
 ModelResponse PromptWhereToGo.execute(ModelRequest request)
           
 ModelResponse VABeach.execute(ModelRequest request)
           
 ModelResponse PromptBestFramework.execute(ModelRequest request)
           
 ModelResponse NothingReturned.execute(ModelRequest request)
           
 ModelResponse PromptGoodChoice.execute(ModelRequest request)
           
 ModelResponse ProcessWhereToGo.execute(ModelRequest request)
           
 ModelResponse SecondPage.execute(ModelRequest request)
           
 ModelResponse ProcessWhatQuestion.execute(ModelRequest request)
           
 ModelResponse DoNothing.execute(ModelRequest request)
           
 ModelResponse PromptCrazy.execute(ModelRequest request)
           
 ModelResponse Hawaii.execute(ModelRequest request)
           
 ModelResponse PromptHawaii.execute(ModelRequest request)
           
 ModelResponse ProcessBestFramework.execute(ModelRequest request)
           
 ModelResponse PromptGoodBye.execute(ModelRequest request)
           
 

Uses of ModelException in org.keel.red.workflow.engine
 

Methods in org.keel.red.workflow.engine that throw ModelException
 ModelResponse RedWorkflowFactory.execute(ModelRequest request)
           
 

Uses of ModelException in org.keel.servers
 

Fields in org.keel.servers declared as ModelException
private  ModelException KeelServerThread.myException
           
 

Methods in org.keel.servers that throw ModelException
 ModelResponse KeelServerThread.getResponse()
           
protected  Container KeelAbstractServer.getContainer()
           
protected  void KeelAbstractServer.initialize()
           
protected  void KeelAbstractServer.saveContext(ModelRequest req)
           
private  void KeelAbstractServer.postContext(java.lang.String sessionId, ComparableContext c)
           
 

Uses of ModelException in org.keel.servers.direct
 

Methods in org.keel.servers.direct that throw ModelException
 KeelResponse KeelDirectServer.execute(KeelRequest request)
           
 

Uses of ModelException in org.keel.servers.jms
 

Methods in org.keel.servers.jms that throw ModelException
protected  void KeelJmsServer.initialize()
           
 

Uses of ModelException in org.keel.servers.socket
 

Methods in org.keel.servers.socket that throw ModelException
protected  void KeelSocketServer.bootstrap()
          Need to configure, initialize, etc...but can't rely on the lifecycle interfaces used by typical components because the container is not yet available.
 KeelResponse KeelSocketServer.execute(KeelRequest request)
           
 

Uses of ModelException in org.keel.services.authentication.config
 

Methods in org.keel.services.authentication.config that throw ModelException
private  java.lang.String LoginHelper.encodeWithSeq(java.lang.String seq, java.lang.String original)
           
 

Uses of ModelException in org.keel.services.authorization.defaultauth
 

Methods in org.keel.services.authorization.defaultauth that throw ModelException
 ModelResponse ListAuth.execute(ModelRequest req)
           
private  void ListAuth.listGroupAuth(ModelRequest req, ModelResponse res, java.lang.String selectedGroup, Output groupsOutput)
           
private  void ListAuth.listUserAuth(ModelRequest req, ModelResponse res, UserEnvironment user)
           
private  PersistentFactory ListAuth.getPersistentFactory(ModelRequest req)
           
 

Uses of ModelException in org.keel.services.event.jbossmq
 

Methods in org.keel.services.event.jbossmq that throw ModelException
 void JbossMQEventManager.ejbCreate()
          The user of this KeelJmsClient can call open explicitly, or it will be called automatically the first time a message is sent.
 

Uses of ModelException in org.keel.services.event.openjms
 

Methods in org.keel.services.event.openjms that throw ModelException
 void OpenJMSEventManager.initialize()
          The user of this KeelJmsClient can call open explicitly, or it will be called automatically the first time a message is sent.
 

Uses of ModelException in org.keel.services.mail.javamail.models
 

Methods in org.keel.services.mail.javamail.models that throw ModelException
 ModelResponse MailForm.execute(ModelRequest req)
          Send all request parameters according to configuration
 

Uses of ModelException in org.keel.services.model
 

Methods in org.keel.services.model that throw ModelException
 ModelResponse ThreadedLogEnabledModel.execute(ModelRequest request)
           
 Command ModelValidator.validate(ModelRequest req, Model theModel)
          Validate the request parameters about to be passed to the specified model.
 ModelResponse Command.execute(ModelRequest req, ModelResponse res)
          Convenience method, equivilant to execute(req, res, false, false)
 ModelResponse Command.execute(ModelRequest req, ModelResponse res, boolean includeParams, boolean includeResponseElements)
          Execute the model specified by this command and return the model response.
 ModelResponse Model.execute(ModelRequest request)
           
 void KeelResponse.remove(ResponseElement re)
           
 void KeelResponse.add(ResponseElement re)
          The Model (only) uses the method below to add new response elements to this response.
 void KeelResponse.addOutput(java.lang.String name, java.lang.String content)
          Convenience add method for creating a simple string output with a specific name
 void KeelResponse.addOutput(java.lang.String content)
          Convenience add method for creating a simple string output with a name assigned by the ModelResponse
 void KeelResponse.addInput(java.lang.String name, java.lang.String label)
          Convenience add method for creating a simple input.
 void KeelResponse.addCommand(java.lang.String model, java.lang.String label)
          Convenience add method for creating a simple command If you need to specify additional information about the command, such as parameters use createCommand, populate the object, then use add.
 Output KeelResponse.createOutput(java.lang.String name)
          Create an Output with the specified name
 Output KeelResponse.createOutput(java.lang.String name, java.lang.String content)
          Create an output with the specified name and content
 Input KeelResponse.createInput(java.lang.String name)
          Create an Input with the specified name
 Command KeelResponse.createCommand(java.lang.String model)
          Create a Command with the specified name
 Command KeelResponse.createCommandRelativeSequence(int numberOfSteps)
           
 ModelResponse ModelRequest.execute()
          Actually execute the requested model object's logic, returning the ModelResponse it creates
 ModelResponse ModelRequest.createResponse()
          Used by the model to generate the "empty" response object, which the model then populates with Inputs, Outputs and Commands
 Context ModelRequest.getContext()
          Get the Keel Context object indiciating the current context for this request.
 java.lang.Object ModelRequest.getDefaultService(java.lang.String role)
          This method is used by Model objects to get access to other services or services in the system.
 java.lang.Object ModelRequest.getService(java.lang.String role, java.lang.String hint)
          This method is used by a model when it wants to access a particular service (often a factory for another service) and specify the hint itself.
 java.lang.Object ModelRequest.getService(java.lang.String role, java.lang.String hint, Context ctx)
          This method is used by a model when it wants to access a particular service (often a factory for another service) and specify the hint itself.
 void ModelRequest.copyFrom(KeelRequest newRequest)
          Copy the values from another Keel Request into this one.
 

Uses of ModelException in org.keel.services.model.defaultmodel
 

Methods in org.keel.services.model.defaultmodel that throw ModelException
 ModelResponse DefaultModel.execute(ModelRequest request)
           
 ModelResponse DefaultCommand.execute(ModelRequest req, ModelResponse res)
           
 ModelResponse DefaultCommand.execute(ModelRequest req, ModelResponse res, boolean includeParams, boolean includeResponseElements)
           
 void DefaultModelResponse.addOutput(java.lang.String name, java.lang.String content)
           
 void DefaultModelResponse.addOutput(java.lang.String content)
           
 Output DefaultModelResponse.createOutput(java.lang.String name)
           
 Output DefaultModelResponse.createOutput(java.lang.String name, java.lang.String content)
           
 Input DefaultModelResponse.createInput(java.lang.String name)
           
 void DefaultModelResponse.addInput(java.lang.String name, java.lang.String label)
           
 Command DefaultModelResponse.createCommandRelativeSequence(int numberOfSteps)
          This will create a new Command object relative to the current sequence.
 Command DefaultModelResponse.createCommand(java.lang.String model)
          This will create a new Command object for the specified model.
 void DefaultModelResponse.addCommand(java.lang.String model, java.lang.String label)
           
 void DefaultModelResponse.add(ResponseElement re)
          The Model (only) uses the method below to add new response elements to this response.
 Command DefaultModelValidator.validate(ModelRequest req, Model newModel)
          Examine the Model's configuration and see if there are any "parameter" elements, which may provide certain validation information about each parameter.
 ModelResponse DefaultModelRequest.execute()
           
 ModelResponse DefaultModelRequest.createResponse()
           
protected  ModelResponse DefaultModelRequest.afterExecute(ModelResponse res, Configuration modelConfig)
           
 java.lang.Object DefaultModelRequest.getService(java.lang.String role, java.lang.String hint)
          This method first checks if the current model is securable.
 void DefaultModelRequest.copyFrom(KeelRequest newRequest)
           
 java.lang.Object DefaultModelRequest.getDefaultService(java.lang.String role)
           
 java.lang.Object DefaultModelRequest.getService(java.lang.String role, java.lang.String hint, Context ctx)
           
private  Command DefaultModelRequest.validate(Model newModel)
           
 

Uses of ModelException in org.keel.services.model.session
 

Methods in org.keel.services.model.session that throw ModelException
 ModelResponse ModelHome.execute(ModelRequest request)
           
 ModelResponse SessionBeanModel.execute(ModelRequest request)
           
 

Uses of ModelException in org.keel.services.model.session.test
 

Methods in org.keel.services.model.session.test that throw ModelException
 ModelResponse Test.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.services.persist
 

Methods in org.keel.services.persist that throw ModelException
 void PersistentFactory.addInputs(ModelResponse res, Persistent p)
          Convenience method to add an Input ResponseElement to the specified ModelResponse for every field in the supplied Persistent.
 void PersistentFactory.addOutputs(ModelResponse res, Persistent p)
          Convenience method to add an Output ResponseElement to the specified ModelResponse for every field in the supplied Persistent.
 void PersistentFactory.addQuery(ModelResponse res, Persistent p, java.lang.String outputName)
          Convenience method to add a List of nested Output ResponseElements to the specified ModelRepsonse.
 void PersistentFactory.addQuery(ModelResponse res, Persistent p, java.lang.String outputName, java.lang.String[] fieldNames)
          Convenience method to add a List of nested Output ResponseElements to the specified ModelRepsonse.
 

Uses of ModelException in org.keel.services.persist.base
 

Methods in org.keel.services.persist.base that throw ModelException
 void AbstractPersistentFactory.addInputs(ModelResponse res, Persistent p)
           
 void AbstractPersistentFactory.addOutputs(ModelResponse res, Persistent p)
           
 void AbstractPersistentFactory.addQuery(ModelResponse res, Persistent p, java.lang.String outputName)
          Add an entire set of Persistents to a model reponse as Outputs, not just one.
 void AbstractPersistentFactory.addQuery(ModelResponse res, Persistent p, java.lang.String outputName, java.lang.String[] fieldNames)
          Convenience method to add a List of nested Output ResponseElements to the specified ModelRepsonse.
protected  void AbstractPersistentFactory.addPersistentToOutput(java.lang.String[] fields, Persistent p, Output o, ModelResponse response)
          Adds the requested values of the Persistent to the given Output.
 

Uses of ModelException in org.keel.services.persist.hibernate.model
 

Methods in org.keel.services.persist.hibernate.model that throw ModelException
 ModelResponse ReverseEngineer.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.services.schedule.quartz
 

Methods in org.keel.services.schedule.quartz that throw ModelException
 ModelResponse QuartzJobScheduleModel.execute(ModelRequest req)
           
 ModelResponse ModelBatchJob.execute(ModelRequest req)
           
 

Uses of ModelException in org.keel.services.script.bsf.models
 

Methods in org.keel.services.script.bsf.models that throw ModelException
 ModelResponse ScriptRunner.execute(ModelRequest request)
           
 

Uses of ModelException in org.keel.services.script.jelly.models
 

Methods in org.keel.services.script.jelly.models that throw ModelException
 ModelResponse ScriptRunner.execute(ModelRequest request)
           
 

Uses of ModelException in org.keel.wireless.example.app.model
 

Methods in org.keel.wireless.example.app.model that throw ModelException
 ModelResponse SearchContactsRDBMSModel.execute(ModelRequest req)
           
 


Keel 2.1RC2

Please see keelframework.org for information about new Keel releases.