2009/05/20 - Apache Shale has been retired.

   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to you under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.shale.examples.mailreaderjpa;
  
  import java.util.List;
  import java.util.Map;
  import org.apache.mailreaderjpa.Subscription;
  import org.apache.mailreaderjpa.User;
  import org.apache.shale.view.AbstractViewController;
  
  /***
   * <p>Backing bean for the <code>/master.jsp</code> view.</p>
   */
  public class Master extends AbstractViewController {
      
  
      // ------------------------------------------------------ Manifest Constants
  
  
      /***
       * <p>Cache key under which we save the current transaction mode.</p>
       */
      private static final String MODE_KEY = "mode";
  
  
      /***
       * <p>Cache key under which we save the <code>User</code> instance
       * we are creating or editing.</p>
       */
      private static final String USER_KEY = "user";
  
  
      // ------------------------------------------------------- Public Properties
  
  
      /***
       * <p>The business {@link Logic} for this application.  This value
       * will be injected, based on the managed bean configuration.</p>
       */
      private Logic logic = null;
  
  
      /***
       * <p>Return the business {@link Logic} for this application.</p>
       */
      public Logic getLogic() {
          return this.logic;
      }
  
  
      /***
       * <p>Set the business {@link Logic} for this application.</p>
       *
       * @param logic The new business logic instance
       */
      public void setLogic(Logic logic) {
          this.logic = logic;
      }
  
  
      /***
       * <p>The transaction mode for the current request (CREATE or EDIT).
       * Default mode is EDIT.</p>
       */
      private String mode = Constants.EDIT_MODE;
  
  
      /***
       * <p>Return the transaction mode (CREATE or EDIT) for this request.</p>
       */
      public String getMode() {
          return this.mode;
      }
  
  
      /***
       * <p>Set the transaction mode (CREATE or EDIT) for this request.</p>
       *
       * @param mode The new transaction mode
       */
      public void setMode(String mode) {
          this.mode = mode;
      }
  
 
     /***
      * <p>The per-user {@link State} instance we are associated with.  This
      * value will be injected, based on the managed bean configuration.</p>
      */
     private State state = null;
 
 
     /***
      * <p>Return the per-user {@link State} instance we are associated with.</p>
      */
     public State getState() {
         return this.state;
     }
 
 
     /***
      * <p>Set the per-user {@link State} instance we are associated with.</p>
      *
      * @param state The new State instance
      */
     public void setState(State state) {
         this.state = state;
     }
 
 
     /***
      * <p>The <code>User</code> instance being created or edited.</p>
      */
     private User user = null;
 
 
     /***
      * <p>Return the <code>User</code> instance we are creating or editing.</p>
      */
     public User getUser() {
         return this.user;
     }
 
 
     // -------------------------------------------------- Input Field Properties
 
 
     /***
      * <p>The specified password.</p>
      */
     private String password = null;
 
 
     /***
      * <p>Return the specified password.</p>
      */
     public String getPassword() {
         return this.password;
     }
 
 
     /***
      * <p>Set the specified password.</p>
      *
      * @param password The new specified password
      */
     public void setPassword(String password) {
         this.password = password;
     }
 
 
     /***
      * <p>The confirmation password.</p>
      */
     private String password2 = null;
 
 
     /***
      * <p>Return the confirmation password.</p>
      */
     public String getPassword2() {
         return this.password2;
     }
 
 
     /***
      * <p>Set the confirmation password.</p>
      *
      * @param password2 The new confirmation password
      */
     public void setPassword2(String password2) {
         this.password2 = password2;
     }
 
 
     // -------------------------------------------------------- Lifecycle Events
 
 
     /***
      * <p>Initialize transaction mode from the request URI, if specified.</p>
      */
     public void init() {
 
         log("Master.init(" + isPostBack() + ")");
 
         String mode = getRequestParameter("mode");
         if ((mode != null) && (mode.length() > 0)) {
             setMode(mode);
         }
 
     }
 
 
     /***
      * <p>Restore the <code>User</code> instance we are creating or editing,
      * creating a new one if necessary.</p>
      */
     public void preprocess() {
 
         log("Master.preprocess(" + isPostBack() + ")");
 
         String mode = (String) retrieveData(MODE_KEY);
         if (mode != null) {
             setMode(mode);
         }
 
         User user = (User) retrieveData(USER_KEY);
         if (user != null) {
             this.user = user;
         } else {
             setup();
         }
 
     }
 
 
     /***
      * <p>Cache the <code>User</code> instance we are creating or editing,
      * as well as the transaction model</p>
      */
     public void prerender() {
 
         log("Master.prerender(" + isPostBack() + ")");
 
         // Create a new user instance if necessary (i.e. we navigated
         // to this page directly, or we are in CREATE mode)
         if (getUser() == null) {
             setup();
         }
 
         // Cache the current transaction mode and user instance
         saveData(MODE_KEY, getMode());
         saveData(USER_KEY, getUser());
 
     }
 
 
     /***
      * <p>Release resources used during this request.</p>
      */
     public void destroy() {
 
         log("Master.destroy(" + isPostBack() + ")");
 
         ; // FIXME - destroy()
 
     }
 
 
     // ------------------------------------------------------------- View Events
 
 
     /***
      * <p>Cancel saving the updated user information.</p>
      */
     public String cancel() {
 
         // Navigate based on the current transaction mode
         if (Constants.CREATE_MODE.equals(getMode())) {
             return "welcome";
         } else {
             return "menu";
         }
     }
 
 
     /***
      * <p>Save away the updated user information.</p>
      */
     public String save() {
 
         // Special handling for unique username checking on a CREATE transaction
         if (Constants.CREATE_MODE.equals(getMode())) {
             try {
                 User existing = getLogic().findUserByUsername(getUser().getUsername());
                 if (existing != null) {
                     error("Username '" + getUser().getUsername() + "' is already in use, please try again");
                     return null;
                 }
             } catch (Exception e) {
                 error("Exception checking unique username: " + e);
                 log("Exception checking unique username", e);
                 return null;
             }
         }
 
         // Special handling for password and password2 values
         boolean ok = true;
         if (Constants.CREATE_MODE.equals(getMode())) {
             // In CREATE mode, both passwords are required and must match
             if ((getPassword() == null)
                 || (getPassword().length() == 0)) {
                 error("Password is required");
                 ok = false;
             }
             if ((getPassword2() == null)
                 || (getPassword2().length() == 0)) {
                 error("Password 2 is required");
                 ok = false;
             }
             if ((getPassword() != null)
                 && (getPassword2() != null)
                 && !getPassword().equals(getPassword2())) {
                 error("Password and Password 2 values do not match");
                 ok = false;
             }
         } else {
             // In EDIT mode, confirmation password is required and must
             // match, if specified password was entered
             if ((getPassword() != null)
                 && (getPassword().length() > 0)) {
                 if ((getPassword2() == null)
                     || (getPassword2().length() == 0)) {
                     error("Password 2 is required and must match Password");
                     ok = false;
                 } else if (!getPassword().equals(getPassword2())) {
                     error("Password 2 and Password values do not match");
                     ok = false;
                 }
             }
         }
         if (!ok) {
             return null;
         }
 
         // Copy the specified password if it was entered (which will always
         // be true in CREATE mode)
         if ((getPassword() != null)
             && (getPassword().length() > 0)) {
             user.setPassword(getPassword());
         }
 
         try {
 
             if (Constants.CREATE_MODE.equals(getMode())) {
                 getLogic().createUser(getUser());
             } else {
                 this.user = getLogic().updateUser(getUser());
             }
 
             // Implicitly log the user on (if creating), or
             // update the logged on user information (if editing)
             getState().setUser(user);
 
         } catch (Exception e) {
 
             error("Exception saving user information: " + e.getMessage());
             log("Exception saving user information", e);
             return null;
         }
 
         return "menu";
 
     }
 
 
     // --------------------------------------------------------- Support Methods
 
 
     /***
      * <p>Set up the <code>User</code> instance we are creating and editing,
      * by re-finding the currently logged on user (if any), or by creating
      * a new instance.</p>
      */
     private void setup() {
 
         User current = getState().getUser();
         if (current == null) {
             this.user = new User();
             return;
         } else {
             this.user = getLogic().findUserById(current.getId());
         }
 
     }
 
 
 }