Re: validator and dispatch action

[Mike Foody]

Agreed about it being mostly syntactical sugar. 

On the other hand I think defining multiple mappings for the same Action 
is extremely useful.  It allows you to group your functionality and 
easily access shared functionality, but also provide alternative 
validation and forwards without having work around it in the Action 
class.  It certainly isn't providing  anything you couldn't otherwise 
but from my perspective seems a cleaner solution.



Paul Barry wrote:

You could do this same thing in Strust 1.1, except that you would need 
the method parameter.  In struts 1.1, the links would be:

/createSubscription.do?method=create
/editSubscription.do?method=edit
...
And with MappingDispatchAction they would be

/createSubscription.do
/editSubscription.do
...
That's a litte bit nicer, but if you are going to go through the 
trouble of defining an action-mapping for each method, why not just 
skip the dispatch aciton altogether and have separate actions?  If you 
keep all related actions in a package together, is it any harder to 
manage?  I am talking about having a configuration like this:

<action path="/createSubscription"
          type="org.example.subscription.SubscriptionCreateAction">
      <forward name="success" path="/editSubscription.jsp"/>
  </action>
  <action path="/editSubscription"
          type="org.example.subscription.SubscriptionEditAction">
      <forward name="success" path="/editSubscription.jsp"/>
  </action>
  <action path="/saveSubscription"
          type="org.example.subscription.SubscriptionSaveAction"
          name="subscriptionForm"
          validate="true"
          input="/editSubscription.jsp"
          scope="request">
      <forward name="success" path="/savedSubscription.jsp"/>
  </action>
  <action path="/deleteSubscription"
          type="org.example.subscription.SubscriptionDeleteAction"
          name="subscriptionForm"
          scope="request"
          input="/subscription.jsp">
      <forward name="success" path="/deletedSubscription.jsp"/>
  </action>
  <action path="/listSubscriptions"
          type="org.example.subscription.SubscriptionListAction">
      <forward name="success" path="/subscriptionList.jsp"/>
  </action>
Mike Foody wrote:

If you're not opposed to using 1.2 the MappingDispatchAction will 
allow you to easily set up multiple action mappings, each capable of 
having their own ActionForm, validation, etc and then actually handle 
these all with a multiple methods in a single Action class. 
http://jakarta.apache.org/struts/api/index.html

Mike

Paul Barry wrote:

Hello Everyone,

I am using the validator and dispatch actions and I am wonder what 
the best way to do this is.  Consider that I have the following 
method in a dispatch action:

add    - populates collections for drop-down lists, forwards to jsp 
page
create - needs to do validation and store in database
edit   - needs to populate form with the data to edit, forward to 
jsp page
update - needs to do validation and update database
delete - needs to delete a record from the database

You can see how the validation would be different for these actions. 
Let's say this is a dispatch action related to administrating 
users.  So for add, there would be no validation, it just gets the 
data need to build the form.  For create, there might be a password 
and verify password field that need to be validated, but update 
wouldn't have those fields.  Edit and delete would have to have a 
parameter for the primary key of the record to edit or delete.

Now I found something related at this link:

http://nagoya.apache.org/wiki/apachewiki.cgi?ValidatorDispatchAction

Which says to set validate to false in the struts-config.xml and 
then call validate method within each method of the dispatch action, 
like this:

ActionErrors errors = new ActionErrors();
errors = form.validate(mapping, request);
// Report any errors we have discovered back to the original form
if (!errors.isEmpty()) {
    saveErrors(request, errors);
    return  new ActionForward(mapping.getInput());
}
This seems like a really good solution to me, but there is one 
problem.  How do you call a different set of validation rules, based 
on which method you are in?  Doesn't this need to be something like 
this:

edit() {
    ActionErrors errors = new ActionErrors();
    errors = form.validateEdit(mapping, request);
}
update() {
    ActionErrors errors = new ActionErrors();
    errors = form.validateUpdate(mapping, request);
}
Because the rules for validating edit and update are different.  You 
could define different action-mappings in your struts config for 
each dispatch method, and then a form in your validation.xml for 
each action-mapping, where the form name is the same as the path 
property of the action-mapping, but doesn't this defeat the purpose 
of the dispatch action?  Why not just have separate actions at that 
point?  I think the answer is to just not use the dispatch action 
with the validator, but I wanted to know if others had found a way 
to do it.

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]




---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]


---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]