Problem with jsp and controller

Question

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt"%>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring"%>
<%@ page import='com.uk.nhs.training.data.ActivityMatrix'%>
<SCRIPT language="JavaScript" type="text/javascript">
function bookActivity()
if (document.bookActivityController.activitySelect.selectedIndex == 0)
alert("Please Select Activity");
else if (document.bookActivityController.trainerId.selectedIndex == 0)
alert ( "Please Select Trainer");
else if(document.bookActivityController.fromDate.value=="")
alert("Please supply the Start Date of Activity")
else
validateForExistingCourses();
function validateForExistingCourses()
flag="wait";
var trainerId=document.getElementById("trainerId").value;
var fromDate=document.getElementById("fromDate").value;
var toDate=document.getElementById("toDate").value;
var activityId=document.getElementById("activitySelect").value;
url="ajaxList.htm?actionType=checkBookedCoursesActivities&trainerId="+trainerId+"&fromDate="+fromDate+"&toDate="+toDate+"&activitySelect="+activityId;
what = "checkForPreBookedCoursesActivities(req.responseXML)";
doCallback(null);
function checkForPreBookedCoursesActivities(theXmlResponse)
// alert("in here in checking prebookedCourses");
if(theXmlResponse != null)
     var isActivityExisting = theXmlResponse.getElementsByTagName('existingActivity')[0].text;
     var isCourseExisting = theXmlResponse.getElementsByTagName('existingbookedcourse')[0].text;     
          if(isActivityExisting=="Y")
          alert("Activity You are trying to book for Trainer already exists");
          return false;
          else if(isCourseExisting=="Y")
          if(confirm('Conflict Message. The dates choosen conflict with a current booking. Do you want to override'))
window.open("/training1.1/secure/prebookedEvents.htm","clientwindow",'StatusBar', 'toolbar=yes,resizable=yes,scrollbars=yes,width=500,height=400,left=0,top=0');
return false;
else
document.bookActivityController.action="/training1.1/secure/bookActivityTrainer.htm?actionType=submitForm";
document.bookActivityController.submit();
function goHomePage()
     window.location="/training1.1/secure/welcome.htm";
function showHideAmPm(divId)
if(document.bookActivityController.halfday.checked==true)
showDiv(divId);
else
hideDiv(divId);
function showDiv(divId)
var item = document.getElementById(divId);
alert("show item"+item);
if (item)
item.className='unhidden';
function hideDiv(divId)
var item = document.getElementById(divId);
alert("unhide item"+item);
if (item)
item.className='hidden';
function getActivitiesPm()
if(document.bookActivityController.am.checked==true)
document.bookActivityController.pm.checked=false;
flag="wait";
     url="ajaxList.htm?actionType=activities&keyword=PM";
     what = "setActivities(req.responseXML)";
     doCallback(null);
     document.bookActivityController.activityTimeSelect.value="halfday";
     document.bookActivityController.activityTimeSubType.value="pm";
     // alert("subType"+document.bookActivityController.activityTimeSubType.value);
function getActivitiesAm()
if(document.bookActivityController.pm.checked==true)
document.bookActivityController.am.checked=false;
flag="wait";
     url="ajaxList.htm?actionType=activities&keyword=AM";
     what = "setActivities(req.responseXML)";
     doCallback(null);
     document.bookActivityController.activityTimeSelect.value="halfday";
     document.bookActivityController.activityTimeSubType.value="pm";
function getSingleDayActivities()
if(document.bookActivityController.singleday.checked==true)
document.bookActivityController.moredays.checked=false;
document.bookActivityController.halfday.checked=false;
hideDiv('partofhalfday');
document.bookActivityController.activityTimeSelect.value="fullday";
flag="wait";
     url="ajaxList.htm?actionType=activities&keyword=FullDay";
     what = "setActivities(req.responseXML)";
     doCallback(null);
else
hideDiv('activitySelect');
function getMoreDaysActivities()
alert();
if(document.bookActivityController.moredays.checked==true)
document.bookActivityController.singleday.checked=false;
document.bookActivityController.halfday.checked=false;
hideDiv('partofhalfday');
document.bookActivityController.activityTimeSelect.value="moredays";
flag="wait";
     url="ajaxList.htm?actionType=activities&keyword=FullDay";
     what = "setActivities(req.responseXML)";
     doCallback(null);
else
hideDiv('activitySelect');
showDiv('dateTo');
function setActivities(theXmlResponse)
          //start filling the Venues Select boxes now
          if(theXmlResponse != null)
               var coursesBox=document.getElementById("activitySelect");
               coursesBox.options.length=0;
               var activityElementsLength=theXmlResponse.getElementsByTagName('activity').length;     
               var activityElementsArray=theXmlResponse.getElementsByTagName('activity');
               //alert("length"+activityElementsLength+activityElementsArray);                              
          for(x = 0; x < activityElementsLength; x++)
                    //coursesBox.options[coursesBox.options.length] = new Option(coursesElementsArray[x].firstChild.text, coursesElementsArray[x].lastChild.text);
                    var optn = document.createElement("OPTION");
               optn.text = activityElementsArray[x].firstChild.text;
optn.value = activityElementsArray[x].lastChild.text;
coursesBox.options.add(optn);
     if (activityElementsLength>0)
               showDiv('activityTD');
          flag="release";
</script>
<div id="content"><!-- Top story -->
<div id="topstory" class="box">
<div id="topstory-img"></div>
<!-- /topstory-img -->
<div id="topstory-desc">
<div id="topstory-title"><strong>BOOK Activity</strong></div>
<!-- /topstory-title -->
<div id="topstory-desc-in"></div>
<!-- /topstory-desc-in --></div>
<!-- /topstory-desc --></div>
<!-- /topstory -->
<div id="bodycontent">
<% int errorCount=0; %>          
          <spring:bind path="bookactivityevent.*">
          <c:forEach items="${status.errorMessages}" var="error">
                    <B><font color="red">Error: <c:out value="${error}"/></font><B/>
                    <% errorCount++; %>
          </c:forEach>
          </spring:bind>
<form method="post" name="bookActivityController" action="<c:url value="/secure/bookActivityTrainer.htm"/>">
<table align="right" width="50%" border=0>
<input type="hidden" name="activityTimeSelect"/>
<input type="hidden" name="activityTimeSubType"/>
<tr>
<td align="left">
<INPUT TYPE="checkbox" NAME="halfday" onclick="showHideAmPm('partofhalfday')">Half Day    
<div align="left "id="partofhalfday" class="hidden">
<INPUT TYPE="RADIO" NAME="am" onClick="getActivitiesAm()" value="am">AM <INPUT TYPE="RADIO" NAME="pm" onClick="getActivitiesPm()">PM <BR>
</div>
</td>
</tr>
<tr><td><INPUT TYPE="checkbox" NAME="singleday" onClick="getSingleDayActivities()"> Single Day</td>
</tr>
<tr>
<td><INPUT TYPE="checkbox" NAME="moredays" onClick="getMoreDaysActivities()"> More Days</td>
</tr>
     <tr>
          <td align="left" id="activityTD">Activity :
          <c:set var="activityMap" value=${requestScope.activityMap}/>
     <c:choose>
                    <c:when test="${activityMap = null}"
     <spring:bind path="bookactivityevent.userSuppliedActivity.activity.activityId">
          <select name="activitySelect" id="activitySelect" size="1"
               STYLE="width: 150px">
               <option value="Choose Activity" default>Choose Activity</option>
          </select>
          </spring:bind>
          </c:when>
          <c:otherwise>      
          <spring:bind path="bookactivityevent.userSuppliedActivity.activity.activityId">
          <select name="activitySelect" id="activitySelect"
               size="1" STYLE="width: 150px">
               <option value="" default>Choose Activity</option>
               <c:forEach var="activity" items="${activityMap}" varStatus="a">
                    <c:choose>
                         <c:when
                              test="${(bookactivityevent !=null) && (bookactivityevent.userSuppliedActivity.activity.activityId == activity.activityId)}">
                              <option value="<c:out value="${activity.activityId}"/>" selected><c:out
                                   value="${activity.activityId}" /></option>
                         </c:when>
                         <c:otherwise>
                         <option value="<c:out value="${activity.activityId}"/>"><c:out
                                   value="${activity.activity}"/>
                         </c:otherwise>
                    </c:choose>
               </c:forEach>
          </select>
     </spring:bind>
     </c:otherwise>
     </c:choose>
     </td>
</tr>
     <tr>
          <td align="left">Trainer:
          <spring:bind path="bookactivityevent.userSuppliedActivity.trainer.trainerId">
          <select name="trainerId" id="trainerId"
               size="1" STYLE="width: 150px">
               <option value="" default>Choose Trainer</option>
               <c:forEach var="trainer" items="${trainers}" varStatus="a">
                    <c:choose>
                         <c:when
                              test="${(bookactivityevent !=null) && (bookactivityevent.userSuppliedActivity.trainer.trainerId == trainer.trainerId)}">
                              <option value="<c:out value="${trainer.trainerId}"/>" selected>
                              <c:out value="${trainer.firstName}"/>&nbsp<c:out
                                   value="${trainer.surName}" /></option>
                         </c:when>
                         <c:otherwise>
                              <option value="<c:out value="${trainer.trainerId}"/>"><c:out
                                   value="${trainer.firstName}"/>&nbsp<c:out
                                   value="${trainer.surName}" /></option>
                         </c:otherwise>
                    </c:choose>
               </c:forEach>
          </select>
     </spring:bind>     
          </td>
     </tr>
     <tr>
          <td align="left" id="dateFrom">From Date
          <spring:bind path="bookactivityevent.userSuppliedActivity.dateFrom">
          <input type="text" name="dateFrom" value=""/>
          </spring:bind>
          <img
               src="../design/cal.gif" width="16" height="16" border="0"
               alt="Click Here to Pick up the date"></td>
     </tr>
     <tr>
          <td align="left" id="dateTo" class="hidden">To Date
          <spring:bind path="bookactivityevent.userSuppliedActivity.dateTo">
          <input type="text" name="dateTo" value=""/>
          </spring:bind>
          <img
               src="../design/cal.gif" width="16" height="16" border="0"
               alt="Click Here to Pick up the date"></td>
     </tr>
     <tr>
          <td align="left" colspan="2"><input type="submit" name="_target1" value="BookActivity"/></td>
               <c:if test="${(bookactivityevent != null) && (not empty bookactivityevent.conflictBookings)}">
<td align="left" colspan="2"><input type="submit" name="_target2" value="OverRideBookings"/></td>
</c:if>
          <td align="left" colspan="2"><input type="button" name="Cancel"
               value="Cancel" onClick="goHomePage();" /></td>
     </tr>
</table>
</form>
</div>
<hr class="noscreen"/>
<div class="content-padding"></div>
<script language="JavaScript">
     var cal1 = new calendar1(document.bookActivityController.elements['dateFrom']);
     cal1.year_scroll = true;
     cal1.time_comp = false;
var cal2 = new calendar1(document.bookActivityController.elements['dateTo']);
     cal2.year_scroll = true;
     cal2.time_comp = false;
</script></div>
<!-- /content -->
package com.uk.nhs.training.controller;
import java.beans.PropertyEditorSupport;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.swing.text.html.HTMLDocument;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindException;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractWizardFormController;
import org.springframework.web.servlet.view.RedirectView;
import com.uk.nhs.training.contractUtility.ContractHtmlReader;
import com.uk.nhs.training.data.Activity;
import com.uk.nhs.training.data.ActivityMatrix;
import com.uk.nhs.training.data.BookActivityEvent;
import com.uk.nhs.training.data.Booking;
import com.uk.nhs.training.data.BookingDetails;
import com.uk.nhs.training.data.Client;
import com.uk.nhs.training.data.Course;
import com.uk.nhs.training.data.Trainer;
import com.uk.nhs.training.data.Venue;
import com.uk.nhs.training.data.ActivityTimeConstants;
import com.uk.nhs.training.service.ActivityMatrixService;
import com.uk.nhs.training.service.ActivityService;
import com.uk.nhs.training.service.BookingDetailsService;
import com.uk.nhs.training.service.BookingService;
import com.uk.nhs.training.service.ClientService;
import com.uk.nhs.training.service.CourseService;
import com.uk.nhs.training.service.TrainersService;
import com.uk.nhs.training.service.VenueService;
public class BookActivityController extends AbstractWizardFormController {
     protected final Log logger = LogFactory.getLog(getClass());
     private BookingService bookingFacade;
     private BookingDetailsService bookingDetailsFacade;
     private CourseService courseFacade;
     private VenueService venueFacade;
     private ClientService clientFacade;
     private ActivityMatrixService activityMatrixFacade;
     private ActivityService activityFacade;
     private TrainersService trainersFacade;
     private SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
     public BookActivityController() {
          setCommandClass(BookActivityEvent.class);
     setCommandName("bookactivityevent");
     setBindOnNewForm(true);
     protected Object formBackingObject(HttpServletRequest request)
               throws Exception {
          BookActivityEvent bookActivityEvent = new BookActivityEvent();
          ActivityMatrix activityMatrix = new ActivityMatrix();
          activityMatrix.setActivity(new Activity());
          activityMatrix.setTrainer(new Trainer());
          List<Booking> bookingList = new ArrayList<Booking>();
          bookActivityEvent.setUserSuppliedActivity(activityMatrix);
          bookActivityEvent.setConflictBookings(bookingList);
          return bookActivityEvent;
     public Map referenceData(HttpServletRequest request, Object command, Errors errors, int Page)
          List trainers = trainersFacade.loadTrainers();
     Map trainersActivitiesMap = new HashMap();
          trainersActivitiesMap.put("trainers", trainers);          
          return trainersActivitiesMap;
     protected ModelAndView processFinish(HttpServletRequest request,
               HttpServletResponse response, Object command, BindException errors) {
          try {
               ActivityMatrix activity = (ActivityMatrix) command;
               activityMatrixFacade.saveActivityMatrix(activity);
               logger.info("Activity is successfully saved for the trainer");
          } catch (Exception e) {
               e.getClass();
               e.printStackTrace();
          return new ModelAndView("bookSuccess");
     @Override
     protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {
          dateFormat.setLenient(true);
          binder.registerCustomEditor(java.sql.Date.class, "dateFrom", new SqlDateEditor(true));
          binder.registerCustomEditor(java.sql.Date.class, "dateTo", new SqlDateEditor(false));
          binder.registerCustomEditor(java.sql.Date.class, null, new SqlDateEditor(true));
     protected ModelAndView handleInvalidSubmit(HttpServletRequest request,
               HttpServletResponse response) throws Exception {
          return new ModelAndView("bookInvalidSubmit");
     @Override
     protected ModelAndView processCancel(HttpServletRequest request,
               HttpServletResponse response, Object command, BindException errors)
               throws Exception {
          return new ModelAndView(new RedirectView("welcome.htm"));
     @Override
     protected void onBindAndValidate(HttpServletRequest request,
               Object command, BindException errors, int page) throws Exception {
          BookActivityEvent bookActivityEvent = (BookActivityEvent) command;
          System.out.println(" PAGE : " + page);
          try {
               switch (page) {
               case 0:
                    if (request.getParameter("_target1") != null) {
                         ActivityMatrix userActivityMatrix = bookActivityEvent.getUserSuppliedActivity();
                         buildActivityMatrix(request, bookActivityEvent);     
                         validateActivityMatrix(bookActivityEvent, errors);
                         if (errors.getErrorCount() == 0)
                              Trainer trainer = (Trainer) trainersFacade.loadTrainersById(userActivityMatrix.getTrainer().getTrainerId());
                              bookActivityEvent.getUserSuppliedActivity().setTrainer(trainer);
                              Activity activity= (Activity) activityFacade.loadActivitiesById(userActivityMatrix.getActivity().getActivityId());
                              bookActivityEvent.getUserSuppliedActivity().setActivity(activity);
                              boolean activityExists = checkForExistingActivities(userActivityMatrix, errors);
                              if(!activityExists)
                              boolean bookingsExist =      checkForBookedCourses(request, bookActivityEvent, errors);
                              if(bookingsExist)
                                   // inject an error code so that it can be used in GUI
                                   errors.rejectValue("dateFrom","invalid dates","Trainer has Bookings in conflict with the Supplied Activity Dates");
                              else
                                   errors.rejectValue("dateFrom","Activity Dates supplied already exist");
                    break;
               case 1:
                    if (request.getParameter("_target2") != null)
                         * Get the user supplied activitymatrix and try to get all the bookings which are in conflict for the trainer
                    List<Booking> conflictBookingsList = (List<Booking>)request.getSession().getAttribute("conflictBookingsList");
                    break;
               default:
          } catch (Exception e) {
               System.err.println("Exception :" + e.getMessage());
          super.onBindAndValidate(request, command, errors, page);
     * @param request
     * @param userActivity
     * @param bookActivityEvent TODO
     private ActivityMatrix buildActivityMatrix(HttpServletRequest request, BookActivityEvent bookActivityEvent) {
          ActivityMatrix userActivity = bookActivityEvent.getUserSuppliedActivity();
          userActivity.getTrainer().setTrainerId((String)(request.getParameter("trainerId")));
          userActivity.getActivity().setActivityId((String)(request.getParameter("activitySelect")));          
          String activityTime = (String)request.getParameter("activityTimeSelect");
          String activitySubType = (String)request.getParameter("activityTimeSubType");
          if("fullday".equals(activityTime))
               userActivity.getActivity().setTime(ActivityTimeConstants.FULLDAY.toString());
          else if("moredays".equals(activityTime))
               userActivity.getActivity().setTime(ActivityTimeConstants.MOREDAYS.toString());
          else if("halfday".equals(activityTime)&& "am".equals(activitySubType))
               userActivity.getActivity().setTime(ActivityTimeConstants.AM.toString());               
          else if("halfday".equals(activityTime)&& "pm".equals(activitySubType))
               userActivity.getActivity().setTime(ActivityTimeConstants.PM.toString());
          if(!("moredays".equals(activityTime)))
               userActivity.setDateTo(bookActivityEvent.getDateFrom());
          userActivity.setDateFrom(bookActivityEvent.getDateFrom());
          bookActivityEvent.setUserSuppliedActivity(userActivity);
          return userActivity;
     * Create an empty Booking details for client and course...
     * @param booking
     private void setInitialBookingDetails(Booking booking, BindException errors) {
          if (booking.getBookingType().equals("Client-Based")) {
               if (booking.getClient() == null
                         || booking.getClient().getClientId() == null) {
                    booking.setClient(new Client());
          } else if (booking.getBookingType().equals("Staff")) {
               booking.setClient(null);
          if (booking.getBookingDetails() == null) {
               List<BookingDetails> bkDetailsList = new ArrayList<BookingDetails>();
               BookingDetails bkDetails = new BookingDetails();
               bkDetails.setCourse(new Course());
               bkDetailsList.add(bkDetails);
               booking.setBookingDetails(bkDetailsList);
          } else {
               List bkDetList = booking.getBookingDetails();
               if (bkDetList.size() < 1
                         || (bkDetList.size() > 0 && !((bkDetList.get(0)) instanceof BookingDetails))) {
                    BookingDetails bkDetails = new BookingDetails();
                    bkDetails.setCourse(new Course());
                    bkDetList.add(0, bkDetails);
                    booking.setBookingDetails(bkDetList);
               } else if (((BookingDetails) bkDetList.get(0)).getCourse() == null
                         || ((BookingDetails) bkDetList.get(0)).getCourse()
                                   .getCourseId() == null) {
                    ((BookingDetails) bkDetList.get(0)).setCourse(new Course());
     @Override
     protected void validatePage(Object command, Errors errors, int page,
               boolean finish) {
          BookActivityEvent activityEvent = (BookActivityEvent) command;
          if (finish) {
          super.validatePage(command, errors, page);
     * Validate client
     * @param booking
     * @param err
     private boolean checkForExistingActivities(ActivityMatrix userSuppliedActivity, Errors err)
          boolean exist = false;          
          List<ActivityMatrix> trainerActivityMatrixList =      activityMatrixFacade.getActivityMatrixBetweenDateRange(userSuppliedActivity.getTrainer().getTrainerId(),
                    userSuppliedActivity.getDateFrom(), userSuppliedActivity.getDateTo());
          if(ActivityTimeConstants.MOREDAYS.equals(userSuppliedActivity.getActivity().getTime()))
               //checkForDates(trainerActivityMatrixList,);
          else if(ActivityTimeConstants.FULLDAY.equals(userSuppliedActivity.getActivity().getTime()))
               // checkForDates(trainerActivityMatrixList,);
          else if(ActivityTimeConstants.AM.equals(userSuppliedActivity.getActivity().getTime()) ||
                    ActivityTimeConstants.PM.equals(userSuppliedActivity.getActivity().getTime()))
               // checkForDates(trainerActivityMatrixList,);
     return exist;          
          * Check for existing bookings for a trainer and sets them on event object
          * @param request request.
          * @param event event.
          * @param err err.
          * @return true- bookings exist else false.
private boolean checkForBookedCourses(HttpServletRequest request, BookActivityEvent event, Errors err)
     List<Booking> conflictBookingsList =      bookingFacade.loadBookingsByTrainerIdDateRange(event.getUserSuppliedActivity().getTrainer().getTrainerId(),
               event.getUserSuppliedActivity().getDateFrom(),
               event.getUserSuppliedActivity().getDateTo());
request.getSession().setAttribute("conflictBookingsList",conflictBookingsList);     
               if(conflictBookingsList!=null && conflictBookingsList.size()!=0)
               event.setConflictBookings(conflictBookingsList);
               return true;
               else
                    return false;
     * Validate client
     * @param booking
     * @param err
     private void validateActivityMatrix(final BookActivityEvent activity, Errors err) {
//          ValidationUtils.rejectIfEmptyOrWhitespace(err, "trainer.trainerId",
//                    "required.trainer.trainerId", "Valid trainer needs to be selected.");
////          ValidationUtils.rejectIfEmptyOrWhitespace(err, "activity.activityId",
////                    "required.activity.activityId", "Valid activity needs to be selected.");
//          if (err.getErrorCount() < 1)
//                    if (activity.getDateFrom() == null) {
//                         err.rejectValue("dateFrom", "required.dateFrom",
//                                   "Valid Activity Start Date is required");
//                    try
//                         if (activity.getDateFrom() != null && activity.getDateTo() != null
//                                   && (activity.getDateTo().before(activity.getDateFrom())))
//                              err.rejectValue("dateTo", "required.dateTo",
//                                        "Activity End Date Should be after start date.");
//                    } catch (Exception ex) {
//                         err.rejectValue("dateFrom",
//                                   "dateFrom",
//                                   "Improper dates, please provide valid dates.");
     * Validate Trainer
     * @param booking
     * @param e
     private void validateTrainer(final Booking booking, Errors e) {
          ValidationUtils.rejectIfEmptyOrWhitespace(e,
                    "bookingDetails[0].startDate",
                    "required.bookingDetails[0].startDate",
                    "Valid Booking Details startDate required.");
          ValidationUtils.rejectIfEmptyOrWhitespace(e,
                    "bookingDetails[0].trainer.trainerId",
                    "required.bookingDetails[0].trainer.trainerId",
                    "Valid Booking Details Trainer required.");
          if (e.getErrorCount() < 1)
               for (BookingDetails bd : booking.getBookingDetails()) {
                    if (bd.getStartDate() == null) {
                         e.rejectValue("startDate", "required.bbb0",
                                   "Valid Booking details Start Date is required");
                    try {
                         if (bd.getStartDate() != null && bd.getEndDate() != null
                                   && (bd.getEndDate().before(bd.getStartDate())))
                              e.rejectValue("endDate", "required.bbb0",
                                        "End Date Should be after starting date.");
                    } catch (Exception ex) {
                         e.rejectValue("bookingDetails[0].startDate",
                                   "before.bookingDetails[0].startDate",
                                   "Improper dates, please provide valid dates.");
                    if (bd.getTrainer() != null) {
                         e.rejectValue("trianerId", "required.trianerId",
                                   "Valid Trainer details required.");
     public BookingService getBookingFacade() {
          return bookingFacade;
     public void setBookingFacade(BookingService bookingFacade) {
          this.bookingFacade = bookingFacade;
     public CourseService getCourseFacade() {
          return courseFacade;
     public void setCourseFacade(CourseService courseFacade) {
          this.courseFacade = courseFacade;
     public VenueService getVenueFacade() {
          return venueFacade;
     public void setVenueFacade(VenueService venueFacade) {
          this.venueFacade = venueFacade;
     public ClientService getClientFacade() {
          return clientFacade;
     public void setClientFacade(ClientService clientFacade) {
          this.clientFacade = clientFacade;
     public TrainersService getTrainersFacade() {
          return trainersFacade;
     public void setTrainersFacade(TrainersService trainersFacade) {
          this.trainersFacade = trainersFacade;
     * getter method for activityFacade.
     * @return Returns the activityFacade.
     public ActivityService getActivityFacade() {
          return activityFacade;
     * setter method for activityFacade.
     * @param activityFacade The activityFacade to set.
     public void setActivityFacade(ActivityService activityFacade) {
          this.activityFacade = activityFacade;
     * getter method for activityMatrixFacade.
     * @return Returns the activityMatrixFacade.
     public ActivityMatrixService getActivityMatrixFacade() {
          return activityMatrixFacade;
     * setter method for activityMatrixFacade.
     * @param activityMatrixFacade The activityMatrixFacade to set.
     public void setActivityMatrixFacade(ActivityMatrixService activityMatrixFacade) {
          this.activityMatrixFacade = activityMatrixFacade;
     * getter method for bookingDetailsFacade.
     * @return Returns the bookingDetailsFacade.
     public BookingDetailsService getBookingDetailsFacade() {
          return bookingDetailsFacade;
     * setter method for bookingDetailsFacade.
     * @param bookingDetailsFacade The bookingDetailsFacade to set.
     public void setBookingDetailsFacade(BookingDetailsService bookingDetailsFacade) {
          this.bookingDetailsFacade = bookingDetailsFacade;
     class SqlDateEditor extends PropertyEditorSupport {
          private boolean isRequired = false;
          SqlDateEditor(boolean isRequired) {
               this.isRequired = isRequired;
          public void setAsText(String text) throws IllegalArgumentException {
               java.util.Date d = null;
               if (!this.isRequired && !StringUtils.hasText(text)) {
                    setValue(null);
               else
                    try {
                         d = dateFormat.parse(text);
                         setValue(new java.sql.Date(d.getTime()));
                    } catch (ParseException ex) {
                         throw new IllegalArgumentException("Could not parse date: " + ex.getMessage());
          public String getAsText() {
               Date value = (java.sql.Date)getValue();
               if (value != null) {
                    java.util.Date d = new java.util.Date(value.getTime());
                    return dateFormat.fo

Answer 1

This topic is hopeless. Too much unnecessary code. Unformatted code. No question. No requirements. No step-by-step explanation how to reproduce problem. No expectations. No unexpectations/errors.
Please read this how to get better help.