Example usage for org.apache.commons.validator GenericValidator maxLength

List of usage examples for org.apache.commons.validator GenericValidator maxLength

Introduction

In this page you can find the example usage for org.apache.commons.validator GenericValidator maxLength.

Prototype

public static boolean maxLength(String value, int max) 

Source Link

Document

Checks if the value's length is less than or equal to the max.

Usage

From source file:jp.primecloud.auto.api.util.ValidateUtil.java

/**
 *
 * ??//  www .  j  a  va 2  s. co m
 *
 * @param value ??
 * @param minLength ??
 * @param maxLength ?
 * @param code ??
 * @param params ??
 */
public static void lengthInRange(String value, int minLength, int maxLength, String code, Object[] params) {
    if (value != null) {
        if (GenericValidator.minLength(value, minLength) == false
                || GenericValidator.maxLength(value, maxLength) == false) {
            throw new AutoApplicationException(code, params);
        }
    }
}

From source file:com.primeleaf.krystal.web.action.console.NewBookmarkAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    String documentid = request.getParameter("documentid") != null ? request.getParameter("documentid") : "0";
    String revisionid = request.getParameter("revisionid") != null ? request.getParameter("revisionid") : "0";

    request.setAttribute("DOCUMENTID", documentid);
    request.setAttribute("REVISIONID", revisionid);

    if (request.getMethod().equalsIgnoreCase("POST")) {
        try {/*w w  w  . ja v  a  2  s.co  m*/
            String bookmarkName = request.getParameter("txtBookmarkName");
            int documentId = 0;
            try {
                documentId = Integer.parseInt(documentid);
                Double.parseDouble(revisionid);
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new AJAXResponseView(request, response));
            }
            if (!GenericValidator.maxLength(bookmarkName, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for bookmark name");
                return (new AJAXResponseView(request, response));
            }

            Document document = DocumentDAO.getInstance().readDocumentById(documentId);
            if (document == null) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new AJAXResponseView(request, response));
            }
            DocumentRevision documentRevision = DocumentRevisionDAO.getInstance()
                    .readDocumentRevisionById(documentId, revisionid);
            if (documentRevision == null) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid document");
                return (new AJAXResponseView(request, response));
            }

            Bookmark bookmark = new Bookmark();
            bookmark.setDocumentId(documentId);
            bookmark.setRevisionId(revisionid);
            bookmark.setBookmarkName(bookmarkName);
            bookmark.setUserName(loggedInUser.getUserName());
            BookmarkDAO.getInstance().addBookmark(bookmark);
            AuditLogManager.log(new AuditLogRecord(bookmark.getBookmarkId(), AuditLogRecord.OBJECT_BOOKMARK,
                    AuditLogRecord.ACTION_CREATED, loggedInUser.getUserName(), request.getRemoteAddr(),
                    AuditLogRecord.LEVEL_INFO, "", "Name : " + bookmarkName));
            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "Bookmark " + bookmarkName + " added successfully");
            return (new AJAXResponseView(request, response));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return (new HomeAction().execute(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.NewDocumentClassAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    if (request.getMethod().equalsIgnoreCase("POST")) {
        try {/*from ww w  .  j av  a  2s  . c  o m*/
            String className = request.getParameter("txtClassName") != null
                    ? request.getParameter("txtClassName")
                    : "";
            String classDescription = request.getParameter("txtClassDescription") != null
                    ? request.getParameter("txtClassDescription")
                    : "";
            String isRevCtl = request.getParameter("radRevisionControl") != null
                    ? request.getParameter("radRevisionControl")
                    : "N";
            String active = request.getParameter("radActive") != null ? request.getParameter("radActive") : "N";

            //24-Nov-2011 New fields added for controlling the file size and number of documents in the system
            int maximumFileSize = Integer.MAX_VALUE;

            int documentLimit = Integer.MAX_VALUE;

            //10-Sep-2012 New field added for controlling the expiry period of the doucment
            int expiryPeriod = 0;

            if (!GenericValidator.maxLength(className, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Document Class Name");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(classDescription, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR,
                        "Value too large for Document Class Description");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            try {
                expiryPeriod = request.getParameter("txtExpiryPeriod") != null
                        ? Integer.parseInt(request.getParameter("txtExpiryPeriod"))
                        : 0;
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            if (!GenericValidator.isInRange(expiryPeriod, 0, 9999)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }

            if (!"Y".equals(active)) {
                active = "N";
            }
            if (!"Y".equals(isRevCtl)) {
                isRevCtl = "N";
            }

            boolean isDocumentClassExist = DocumentClassDAO.getInstance().validateDocumentClass(className);

            if (isDocumentClassExist) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR,
                        "Document class " + className + " already exist");
                return (new ManageDocumentClassesAction().execute(request, response));
            }

            DocumentClass documentClass = new DocumentClass();
            documentClass.setClassName(className);
            documentClass.setClassDescription(classDescription);

            if (isRevCtl.equals("Y")) {
                documentClass.setRevisionControlEnabled(true);
            } else {
                documentClass.setRevisionControlEnabled(false);
            }
            if (active.equals("Y")) {
                documentClass.setVisible(true);
            } else {
                documentClass.setVisible(false);
            }
            documentClass.setIndexId(-1);

            documentClass.setIndexCount(0);

            //24-Nov-2011 New fields added for controlling the file size and number of documents in the system
            documentClass.setMaximumFileSize(maximumFileSize);
            documentClass.setDocumentLimit(documentLimit);
            documentClass.setIndexTableName("");

            documentClass.setCreatedBy(loggedInUser.getUserName());

            documentClass.setDataTableName("");

            documentClass.setExpiryPeriod(expiryPeriod); //10-Sep-2012 Rahul Kubadia
            documentClass.setExpiryNotificationPeriod(-1);//08-May-2014 Rahul Kubadia

            ArrayList<IndexDefinition> indexDefinitions = new ArrayList<IndexDefinition>();
            documentClass.setIndexDefinitions(indexDefinitions);
            DocumentClassDAO.getInstance().addDocumentClass(documentClass);

            AuditLogManager.log(new AuditLogRecord(documentClass.getClassId(),
                    AuditLogRecord.OBJECT_DOCUMENTCLASS, AuditLogRecord.ACTION_CREATED,
                    loggedInUser.getUserName(), request.getRemoteAddr(), AuditLogRecord.LEVEL_INFO,
                    "ID : " + documentClass.getClassId(), "Name : " + documentClass.getClassName()));
            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "Document class " + className + " added successfully");
            return (new ManageDocumentClassesAction().execute(request, response));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return (new NewDocumentClassView(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.NewUserAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    if (request.getMethod().equalsIgnoreCase("POST")) {

        String realName = request.getParameter("txtRealName") != null ? request.getParameter("txtRealName")
                : "";
        String userName = request.getParameter("txtUserName") != null ? request.getParameter("txtUserName")
                : "";
        String password = request.getParameter("txtPassWord") != null ? request.getParameter("txtPassWord")
                : "";
        String confirmPassword = request.getParameter("txtConfirmPassWord") != null
                ? request.getParameter("txtConfirmPassWord")
                : "";
        String userEmail = request.getParameter("txtUserEmail") != null ? request.getParameter("txtUserEmail")
                : "";
        String userDescription = request.getParameter("txtDescription") != null
                ? request.getParameter("txtDescription")
                : "";
        String userType = request.getParameter("radUserType") != null ? request.getParameter("radUserType")
                : "A";

        userName = userName.replace(' ', '_');

        try {//from  ww w.j  av  a  2 s.  c o  m
            if (!GenericValidator.matchRegexp(userName, HTTPConstants.ALPHA_REGEXP)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input for User Name");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(userName, 15)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for User Name");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(realName, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Real Name");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(password, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Password");
                return (new UsersAction().execute(request, response));
            }

            if (!GenericValidator.minLength(password, 8)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Password");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.matchRegexp(password, HTTPConstants.PASSWORD_PATTERN_REGEXP)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Password");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.minLength(confirmPassword, 8)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Password");
                return (new UsersAction().execute(request, response));
            }

            if (!GenericValidator.matchRegexp(confirmPassword, HTTPConstants.PASSWORD_PATTERN_REGEXP)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input for Password");
                return (new UsersAction().execute(request, response));
            }
            if (!password.equals(confirmPassword)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Password do not match");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.isEmail(userEmail)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Email ID");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(userEmail, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Email ID");
                return (new UsersAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(userDescription, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for User Description");
                return (new UsersAction().execute(request, response));
            }
            if (!User.USER_TYPE_ADMIN.equalsIgnoreCase(userType)) {
                userType = User.USER_TYPE_USER;
            }

            boolean userExist = UserDAO.getInstance().validateUser(userName);
            boolean emailExist = UserDAO.getInstance().validateUserEmail(userEmail);
            if (userExist) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "User with this username already exist");
                return (new UsersAction().execute(request, response));
            }
            if (emailExist) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "User with this email Id already exist");
                return (new UsersAction().execute(request, response));
            }

            User user = new User();
            user.setUserName(userName);
            user.setPassword(password);
            user.setUserDescription(userDescription);
            user.setUserEmail(userEmail);
            user.setRealName(realName);
            user.setActive(true);
            user.setUserType(userType);

            UserDAO.getInstance().addUser(user);

            user = UserDAO.getInstance().readUserByName(userName);

            PasswordHistory passwordHistory = new PasswordHistory();
            passwordHistory.setUserId(user.getUserId());
            passwordHistory.setPassword(password);
            PasswordHistoryDAO.getInstance().create(passwordHistory);

            AuditLogManager.log(new AuditLogRecord(user.getUserId(), AuditLogRecord.OBJECT_USER,
                    AuditLogRecord.ACTION_CREATED, loggedInUser.getUserName(), request.getRemoteAddr(),
                    AuditLogRecord.LEVEL_INFO, "ID :" + user.getUserId(), "Name : " + user.getUserName()));

            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "User " + userName.toUpperCase() + " added successfully");
            return (new UsersAction().execute(request, response));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    return (new NewUserView(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.EditUserAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    if (request.getMethod().equalsIgnoreCase("POST")) {
        short userId = 0;
        try {/*from  w  w w . j  a  v  a 2  s .c  o m*/
            userId = Short
                    .parseShort(request.getParameter("userid") != null ? request.getParameter("userid") : "0");
        } catch (Exception e) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
            return (new UsersAction().execute(request, response));
        }
        UserDAO.getInstance().setReadCompleteObject(true);
        User user = UserDAO.getInstance().readUserById(userId);

        if (user == null) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid User");
            return (new UsersAction().execute(request, response));
        }

        String userName = request.getParameter("txtUserName") != null ? request.getParameter("txtUserName")
                : "";
        String realName = request.getParameter("txtRealName") != null ? request.getParameter("txtRealName")
                : "";
        String userEmail = request.getParameter("txtUserEmail") != null ? request.getParameter("txtUserEmail")
                : "";
        String userDescription = request.getParameter("txtDescription") != null
                ? request.getParameter("txtDescription")
                : "";
        String active = request.getParameter("radActive") != null ? request.getParameter("radActive") : "Y";
        String userType = request.getParameter("radUserType") != null ? request.getParameter("radUserType")
                : "A";

        if (!GenericValidator.maxLength(userName, 15)) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for User Name");
            return (new UsersAction().execute(request, response));
        }
        if (!GenericValidator.maxLength(realName, 50)) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Real Name");
            return (new UsersAction().execute(request, response));
        }
        if (!GenericValidator.isEmail(userEmail)) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
            return (new UsersAction().execute(request, response));
        }
        if (!GenericValidator.maxLength(userEmail, 50)) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for User Email");
            return (new UsersAction().execute(request, response));
        }
        if (!GenericValidator.maxLength(userDescription, 50)) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for User Description");
            return (new UsersAction().execute(request, response));
        }
        if (!"Y".equalsIgnoreCase(active)) {
            active = "N";
        }
        if (!User.USER_TYPE_ADMIN.equalsIgnoreCase(userType)) {
            userType = User.USER_TYPE_USER;
        }

        //check if new email address is different then existing one
        if (!user.getUserEmail().equalsIgnoreCase(userEmail)) {
            //it is different so validate
            if (UserDAO.getInstance().validateUserEmail(userEmail)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "User with " + userEmail + " already exist");
                return (new UsersAction().execute(request, response));
            }
        }

        if (user.getUserName().equalsIgnoreCase(ServerConstants.SYSTEM_ADMIN_USER)) {
            active = "Y"; //Administrator user can never be in activated.
            userType = User.USER_TYPE_ADMIN;
        }
        try {
            user.setUserId(userId);
            user.setRealName(realName);
            user.setUserName(userName);
            user.setUserDescription(userDescription);
            user.setUserEmail(userEmail);

            if ("Y".equalsIgnoreCase(active)) {
                user.setActive(true);
            } else {
                user.setActive(false);
            }

            user.setUserType(userType);

            UserDAO.getInstance().updateUser(user, false);

            AuditLogManager.log(new AuditLogRecord(user.getUserId(), AuditLogRecord.OBJECT_USER,
                    AuditLogRecord.ACTION_EDITED, loggedInUser.getUserName(), request.getRemoteAddr(),
                    AuditLogRecord.LEVEL_INFO, "ID :" + user.getUserId(), "Name : " + user.getUserName()));
            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "User " + userName.toUpperCase() + " updated successfully");
            return (new UsersAction().execute(request, response));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else {
        int userId = 0;
        try {
            userId = Integer
                    .parseInt(request.getParameter("userid") != null ? request.getParameter("userid") : "0");
        } catch (Exception e) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
            return (new UsersAction().execute(request, response));
        }
        UserDAO.getInstance().setReadCompleteObject(true);
        User user = UserDAO.getInstance().readUserById(userId);
        UserDAO.getInstance().setReadCompleteObject(false);

        if (user == null) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid User");
            return (new UsersAction().execute(request, response));
        }

        request.setAttribute("USER", user);

    }
    return (new EditUserView(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.EditDocumentClassAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    if (request.getMethod().equalsIgnoreCase("POST")) {
        try {//  www .j a  v a 2s.c  om
            int documentClassId = 0;
            try {
                documentClassId = Integer.parseInt(
                        request.getParameter("classid") != null ? request.getParameter("classid") : "0");
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            String className = request.getParameter("txtClassName") != null
                    ? request.getParameter("txtClassName")
                    : "";
            String classDescription = request.getParameter("txtClassDescription") != null
                    ? request.getParameter("txtClassDescription")
                    : "";
            String visible = request.getParameter("radActive") != null ? request.getParameter("radActive")
                    : "N";
            String revisionControl = request.getParameter("radRevisionControl") != null
                    ? request.getParameter("radRevisionControl")
                    : "N";

            //24-Nov-2011 New fields added for controlling the file size and number of documents in the system
            int maximumFileSize = Integer.MAX_VALUE;
            int documentLimit = Integer.MAX_VALUE;

            //10-Sept-2012 New field added for controlling the expiry period
            int expiryPeriod = 0;

            //10-Nov-2012 New field added for controlling the accessibility of the class
            String accessType = request.getParameter("radAccessType") != null
                    ? request.getParameter("radAccessType")
                    : DocumentClass.ACCESS_TYPE_PUBLIC;

            if (!GenericValidator.maxLength(className, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Document Class Name");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            if (!GenericValidator.maxLength(classDescription, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR,
                        "Value too large for Document class description");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            if (!GenericValidator.isInRange(documentLimit, 10000, 2147483647)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            try {
                expiryPeriod = request.getParameter("txtExpiryPeriod") != null
                        ? Integer.parseInt(request.getParameter("txtExpiryPeriod"))
                        : 0;
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            if (!GenericValidator.isInRange(expiryPeriod, 0, 9999)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }

            if (!"Y".equals(visible)) {
                visible = "N";
            }
            if (!"Y".equals(revisionControl)) {
                revisionControl = "N";
            }
            if (!DocumentClass.ACCESS_TYPE_USER.equals(accessType)) {
                accessType = DocumentClass.ACCESS_TYPE_PUBLIC;
            }

            DocumentClass documentClass = DocumentClassDAO.getInstance().readDocumentClassById(documentClassId);

            if (documentClass == null) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR,
                        "Document class with same name already exist");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            //Validate document class name if a class name has changed then check if the similar named class already exist in the database
            if (!documentClass.getClassName().equalsIgnoreCase(className)) {
                boolean isDocumentClassExist = DocumentClassDAO.getInstance().validateDocumentClass(className);
                if (isDocumentClassExist) {
                    request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Document Class");
                    return (new ManageDocumentClassesAction().execute(request, response));
                }
            }

            documentClass.setClassId((short) documentClassId);
            documentClass.setClassName(className);
            documentClass.setClassDescription(classDescription);

            //24-Nov-2011 New fields added for controlling the file size and number of documents in the system
            documentClass.setMaximumFileSize(maximumFileSize);
            documentClass.setDocumentLimit(documentLimit);

            if ("Y".equals(visible)) {
                documentClass.setVisible(true);
            } else {
                documentClass.setVisible(false);
            }

            if ("Y".equals(revisionControl)) {
                documentClass.setRevisionControlEnabled(true);
            } else {
                documentClass.setRevisionControlEnabled(false);
            }

            documentClass.setExpiryPeriod(expiryPeriod); //10-Sep-2012 Rahul Kubadia
            documentClass.setExpiryNotificationPeriod(-1);//08-May-2014 Rahul Kubadia

            DocumentClassDAO.getInstance().updateDocumentClass(documentClass);

            AuditLogManager.log(new AuditLogRecord(documentClass.getClassId(),
                    AuditLogRecord.OBJECT_DOCUMENTCLASS, AuditLogRecord.ACTION_EDITED,
                    loggedInUser.getUserName(), request.getRemoteAddr(), AuditLogRecord.LEVEL_INFO,
                    "ID : " + documentClass.getClassId(), "Name : " + documentClass.getClassName()));
            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "Document class " + className + " updated successfully");
            return (new ManageDocumentClassesAction().execute(request, response));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else {
        int documentClassId = 0;
        try {
            documentClassId = Integer
                    .parseInt(request.getParameter("classid") != null ? request.getParameter("classid") : "0");
        } catch (Exception e) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
            return (new ManageDocumentClassesAction().execute(request, response));
        }
        DocumentClass documentClass = DocumentClassDAO.getInstance().readDocumentClassById(documentClassId);
        if (documentClass == null) {
            request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid Document Class");
            return (new ManageDocumentClassesAction().execute(request, response));
        }
        request.setAttribute("DOCUMENTCLASS", documentClass);
    }
    return (new EditDocumentClassView(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.NewClassIndexAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);
    if (request.getMethod().equalsIgnoreCase("POST")) {
        try {/*from w ww  .  jav a2 s.co  m*/
            int documentClassId = 0;
            try {
                documentClassId = Integer.parseInt(
                        request.getParameter("classid") != null ? request.getParameter("classid") : "0");
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            DocumentClass documentClass = DocumentClassDAO.getInstance().readDocumentClassById(documentClassId);
            if (documentClass == null) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid document class");
                return (new ManageDocumentClassesAction().execute(request, response));
            }

            String indexName = request.getParameter("txtIndexName") != null
                    ? request.getParameter("txtIndexName")
                    : "";
            String indexDisplayName = request.getParameter("txtIndexDisplayName") != null
                    ? request.getParameter("txtIndexDisplayName")
                    : "";
            String indexType = request.getParameter("cmbIndexType") != null
                    ? request.getParameter("cmbIndexType")
                    : IndexDefinition.INDEXTYPE_STRING;
            String indexLength = request.getParameter("txtIndexLength") != null
                    ? request.getParameter("txtIndexLength")
                    : "100";
            String mandatory = request.getParameter("radMandatory") != null
                    ? request.getParameter("radMandatory")
                    : "";
            String defaultValue = request.getParameter("txtDefaultValue") != null
                    ? request.getParameter("txtDefaultValue")
                    : "";

            int maximumIndexLength = Integer.parseInt(indexLength);

            if (!GenericValidator.maxLength(indexName, 50)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Index Name");
                return (new ClassIndexesAction().execute(request, response));
            }
            boolean isIndexDefinition = IndexDefinitionDAO.getInstance()
                    .validateIndexDefinition(documentClass.getIndexId(), indexName);
            if (isIndexDefinition) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Index " + indexName + " already exist");
                return (new ClassIndexesAction().execute(request, response));
            }
            if (defaultValue.trim().length() > 0) {
                if (IndexDefinition.INDEXTYPE_NUMBER.equalsIgnoreCase(indexType)) {
                    if (!GenericValidator.isDouble(defaultValue)) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR,
                                "Invalid input for Default Value : " + defaultValue);
                        return (new ClassIndexesAction().execute(request, response));
                    }
                }
                if (IndexDefinition.INDEXTYPE_DATE.equalsIgnoreCase(indexType)) {
                    if (!GenericValidator.isDate(defaultValue, "yyyy-MM-dd", true)) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR,
                                "Invalid input for Default Value : " + defaultValue);
                        return (new ClassIndexesAction().execute(request, response));
                    }
                }
            }
            if (!GenericValidator.maxLength(defaultValue, maximumIndexLength)) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR,
                        "Value too large for Default Value : " + defaultValue);
                return (new ClassIndexesAction().execute(request, response));
            }
            int i = documentClass.getIndexDefinitions().size();

            indexName = indexName.replace(' ', '_');
            IndexDefinition indexDefinition = new IndexDefinition();
            indexDefinition.setIndexColumnName(indexName);
            indexDefinition.setIndexDisplayName(indexDisplayName);
            indexDefinition.setDefaultValue(defaultValue);
            indexDefinition.setIndexMaxLength(maximumIndexLength);
            indexDefinition.setIndexType(indexType);
            indexDefinition.setDefaultFilter("");
            indexDefinition.setMandatory("Y".equalsIgnoreCase(mandatory));
            indexDefinition.setSequence((byte) (++i));

            int indexCount = documentClass.getIndexCount();
            if (indexCount == 0 && documentClass.getIndexId() == -1) {
                int indexId = IndexDefinitionDAO.getInstance().getNextIndexId();
                while (DocumentClassDAO.getInstance().readDocumentClasses(" INDEXID = " + indexId).size() > 0) {
                    indexId++;
                }
                documentClass.setIndexId(indexId);
            }
            indexDefinition.setIndexId(documentClass.getIndexId());

            IndexDefinitionDAO.getInstance().addIndexDefinition(indexDefinition);

            TableManager tableManager = new TableManager();
            tableManager.alterIndexTable(documentClass, indexDefinition);

            indexCount++;
            documentClass.setIndexCount(indexCount);
            DocumentClassDAO.getInstance().updateDocumentClass(documentClass);

            AuditLogManager.log(new AuditLogRecord(documentClass.getClassId(),
                    AuditLogRecord.OBJECT_DOCUMENTCLASS, AuditLogRecord.ACTION_EDITED,
                    loggedInUser.getUserName(), request.getRemoteAddr(), AuditLogRecord.LEVEL_INFO,
                    "Name : " + documentClass.getClassName(), "Index " + indexName + "  added"));

            request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                    "Index " + indexDefinition.getIndexDisplayName() + " added successfully");
            return (new ClassIndexesAction().execute(request, response));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    return (new ClassIndexesAction().execute(request, response));
}

From source file:com.primeleaf.krystal.web.action.cpanel.EditClassIndexesAction.java

public WebView execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpSession session = request.getSession();
    User loggedInUser = (User) session.getAttribute(HTTPConstants.SESSION_KRYSTAL);

    if (request.getMethod().equalsIgnoreCase("POST")) {
        try {//  w  w  w . java2  s  . c o  m
            String indexName = "";
            String indexDisplayName = "";
            String mandatory = "";
            String indexSequence = "";
            String defaultValue = "";
            short sequence = 0;

            int documentClassId = 0;
            try {
                documentClassId = Integer.parseInt(
                        request.getParameter("classid") != null ? request.getParameter("classid") : "0");
            } catch (Exception e) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                return (new ManageDocumentClassesAction().execute(request, response));
            }
            DocumentClass documentClass = DocumentClassDAO.getInstance().readDocumentClassById(documentClassId);
            if (documentClass == null) {
                request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid document class");
                return (new ManageDocumentClassesAction().execute(request, response));
            }

            int documentClassIndexCount = documentClass.getIndexCount();

            if (documentClassIndexCount > 0) {
                for (IndexDefinition indexDefinition : documentClass.getIndexDefinitions()) {
                    indexName = indexDefinition.getIndexColumnName();
                    indexDisplayName = request.getParameter(
                            "txtIndexDescription" + indexDefinition.getIndexColumnName() + "") != null
                                    ? request.getParameter(
                                            "txtIndexDescription" + indexDefinition.getIndexColumnName() + "")
                                    : "";
                    mandatory = request
                            .getParameter("" + indexDefinition.getIndexColumnName() + "radMandatory") != null
                                    ? request.getParameter(
                                            "" + indexDefinition.getIndexColumnName() + "radMandatory")
                                    : "";
                    indexSequence = request
                            .getParameter("" + indexDefinition.getIndexColumnName() + "sequence") != null
                                    ? request.getParameter(
                                            "" + indexDefinition.getIndexColumnName() + "sequence")
                                    : "";
                    defaultValue = request
                            .getParameter("txtDefaultValue" + indexDefinition.getIndexColumnName()) != null
                                    ? request.getParameter(
                                            "txtDefaultValue" + indexDefinition.getIndexColumnName())
                                    : "";

                    if (!GenericValidator.maxLength(indexDisplayName, 50)) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for Index");
                        return (new ClassIndexesAction().execute(request, response));
                    }
                    if (!GenericValidator.maxLength(defaultValue, 255)) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR, "Value too large for default value");
                        return (new ClassIndexesAction().execute(request, response));
                    }

                    try {
                        sequence = Short.parseShort(indexSequence);
                    } catch (Exception e) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input");
                        return (new ClassIndexesAction().execute(request, response));
                    }
                    if (sequence > documentClassIndexCount) {
                        request.setAttribute(HTTPConstants.REQUEST_ERROR, "Invalid input for Index Order");
                        return (new ClassIndexesAction().execute(request, response));
                    }

                    IndexDefinition newIndexDefinition = IndexDefinitionDAO.getInstance()
                            .readIndexDefinition(documentClass.getIndexId(), indexName);
                    newIndexDefinition.setMandatory("Y".equalsIgnoreCase(mandatory));
                    newIndexDefinition.setSequence(sequence);
                    newIndexDefinition.setIndexDisplayName(indexDisplayName);
                    newIndexDefinition.setDefaultValue(defaultValue);
                    IndexDefinitionDAO.getInstance().updateIndexDefinition(newIndexDefinition);
                }
                AuditLogManager.log(new AuditLogRecord(documentClass.getClassId(),
                        AuditLogRecord.OBJECT_DOCUMENTCLASS, AuditLogRecord.ACTION_EDITED,
                        loggedInUser.getUserName(), request.getRemoteAddr(), AuditLogRecord.LEVEL_INFO,
                        "Name : " + documentClass.getClassName(), "Indexes Updated"));
                request.setAttribute(HTTPConstants.REQUEST_MESSAGE,
                        "Document class indexes updated successfully");
                return (new ClassIndexesAction().execute(request, response));
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    return (new ClassIndexesAction().execute(request, response));
}

From source file:it.eng.spagobi.profiling.services.ManageAttributesAction.java

@Override
public void doService() {
    logger.debug("IN");
    ISbiAttributeDAO attrDao;/*  w w  w .java 2  s. c om*/
    UserProfile profile = (UserProfile) this.getUserProfile();
    try {
        attrDao = DAOFactory.getSbiAttributeDAO();
        attrDao.setUserProfile(getUserProfile());
    } catch (EMFUserError e1) {
        logger.error(e1.getMessage(), e1);
        throw new SpagoBIServiceException(SERVICE_NAME, "Error occurred");
    }
    HttpServletRequest httpRequest = getHttpRequest();

    Locale locale = getLocale();

    String serviceType = this.getAttributeAsString(MESSAGE_DET);
    logger.debug("Service type " + serviceType);

    if (serviceType != null && serviceType.contains(ATTR_LIST)) {
        String name = null;
        String description = null;
        String idStr = null;

        try {
            BufferedReader b = httpRequest.getReader();
            if (b != null) {
                String respJsonObject = b.readLine();
                if (respJsonObject != null) {
                    JSONObject responseJSON = deserialize(respJsonObject);
                    JSONObject samples = responseJSON.getJSONObject(SAMPLES);
                    if (!samples.isNull(ID)) {
                        idStr = samples.getString(ID);
                    }

                    //checks if it is empty attribute to start insert
                    boolean isNewAttr = this.getAttributeAsBoolean(IS_NEW_ATTR);

                    if (!isNewAttr) {
                        if (!samples.isNull(NAME)) {

                            name = samples.getString(NAME);
                            HashMap<String, String> logParam = new HashMap();
                            logParam.put("NAME", name);
                            if (GenericValidator.isBlankOrNull(name)
                                    || !GenericValidator.matchRegexp(name, ALPHANUMERIC_STRING_REGEXP_NOSPACE)
                                    || !GenericValidator.maxLength(name, nameMaxLenght)) {
                                logger.error(
                                        "Either the field name is blank or it exceeds maxlength or it is not alfanumeric");
                                EMFValidationError e = new EMFValidationError(EMFErrorSeverity.ERROR,
                                        description, "9000", "");
                                getHttpResponse().setStatus(404);
                                JSONObject attributesResponseSuccessJSON = new JSONObject();
                                attributesResponseSuccessJSON.put("success", false);
                                attributesResponseSuccessJSON.put("message",
                                        "Either the field name is blank or it exceeds maxlength or it is not alfanumeric");
                                attributesResponseSuccessJSON.put("data", "[]");

                                writeBackToClient(new JSONSuccess(attributesResponseSuccessJSON));

                                AuditLogUtilities.updateAudit(getHttpRequest(), profile, "PROF_ATTRIBUTES.ADD",
                                        logParam, "OK");
                                return;

                            }
                        }
                        if (!samples.isNull(DESCRIPTION)) {
                            description = samples.getString(DESCRIPTION);

                            if (GenericValidator.isBlankOrNull(description)
                                    || !GenericValidator.matchRegexp(description,
                                            ALPHANUMERIC_STRING_REGEXP_NOSPACE)
                                    || !GenericValidator.maxLength(description, descriptionMaxLenght)) {
                                logger.error(
                                        "Either the field description is blank or it exceeds maxlength or it is not alfanumeric");

                                EMFValidationError e = new EMFValidationError(EMFErrorSeverity.ERROR,
                                        description, "9000", "");
                                getHttpResponse().setStatus(404);
                                JSONObject attributesResponseSuccessJSON = new JSONObject();
                                attributesResponseSuccessJSON.put("success", false);
                                attributesResponseSuccessJSON.put("message",
                                        "Either the field description is blank or it exceeds maxlength or it is not alfanumeric");
                                attributesResponseSuccessJSON.put("data", "[]");
                                writeBackToClient(new JSONSuccess(attributesResponseSuccessJSON));
                                HashMap<String, String> logParam = new HashMap();
                                logParam.put("NAME", name);
                                AuditLogUtilities.updateAudit(getHttpRequest(), profile, "PROF_ATTRIBUTES.ADD",
                                        logParam, "OK");
                                return;
                            }
                        }

                        SbiAttribute attribute = new SbiAttribute();
                        if (description != null) {
                            attribute.setDescription(description);
                        }
                        if (name != null) {
                            attribute.setAttributeName(name);
                        }
                        boolean isNewAttrForRes = true;
                        if (idStr != null && !idStr.equals("")) {
                            Integer attributeId = new Integer(idStr);
                            attribute.setAttributeId(attributeId.intValue());
                            isNewAttrForRes = false;
                        }
                        Integer attrID = attrDao.saveOrUpdateSbiAttribute(attribute);
                        logger.debug("Attribute updated");

                        ArrayList<SbiAttribute> attributes = new ArrayList<SbiAttribute>();
                        attribute.setAttributeId(attrID);
                        attributes.add(attribute);

                        getAttributesListAdded(locale, attributes, isNewAttrForRes, attrID);
                        HashMap<String, String> logParam = new HashMap();
                        logParam.put("NAME", attribute.getAttributeName());
                        AuditLogUtilities.updateAudit(getHttpRequest(), profile,
                                "PROF_ATTRIBUTES." + ((isNewAttrForRes) ? "ADD" : "MODIFY"), logParam, "OK");
                    }

                    //else the List of attributes will be sent to the client
                } else {
                    getAttributesList(locale, attrDao);
                }
            } else {
                getAttributesList(locale, attrDao);
            }

        } catch (Throwable e) {
            try {
                AuditLogUtilities.updateAudit(getHttpRequest(), profile, "PROF_ATTRIBUTES.ADD", null, "OK");
            } catch (Exception e3) {
                // TODO Auto-generated catch block
                e3.printStackTrace();
            }
            logger.error(e.getMessage(), e);
            getHttpResponse().setStatus(404);
            try {
                JSONObject attributesResponseSuccessJSON = new JSONObject();
                attributesResponseSuccessJSON.put("success", true);
                attributesResponseSuccessJSON.put("message", "Exception occurred while saving attribute");
                attributesResponseSuccessJSON.put("data", "[]");
                writeBackToClient(new JSONSuccess(attributesResponseSuccessJSON));
            } catch (IOException e1) {
                logger.error(e1.getMessage(), e1);
            } catch (JSONException e2) {
                logger.error(e2.getMessage(), e2);
            }
            throw new SpagoBIServiceException(SERVICE_NAME, "Exception occurred while retrieving attributes",
                    e);
        }
    } else if (serviceType != null && serviceType.equalsIgnoreCase(ATTR_DELETE)) {

        String idStr = null;
        try {
            BufferedReader b = httpRequest.getReader();
            if (b != null) {
                String respJsonObject = b.readLine();
                if (respJsonObject != null) {
                    JSONObject responseJSON = deserialize(respJsonObject);
                    idStr = responseJSON.getString(SAMPLES);
                }
            }

        } catch (IOException e1) {
            logger.error("IO Exception", e1);
            e1.printStackTrace();
        } catch (SerializationException e) {
            logger.error("Deserialization Exception", e);
            e.printStackTrace();
        } catch (JSONException e) {
            logger.error("JSONException", e);
            e.printStackTrace();
        }
        if (idStr != null && !idStr.equals("")) {
            HashMap<String, String> logParam = new HashMap();
            logParam.put("ATTRIBUTE ID", idStr);
            Integer id = new Integer(idStr);
            try {
                attrDao.deleteSbiAttributeById(id);
                logger.debug("Attribute deleted");
                JSONObject attributesResponseSuccessJSON = new JSONObject();
                attributesResponseSuccessJSON.put("success", true);
                attributesResponseSuccessJSON.put("message", "");
                attributesResponseSuccessJSON.put("data", "[]");
                writeBackToClient(new JSONSuccess(attributesResponseSuccessJSON));
                AuditLogUtilities.updateAudit(getHttpRequest(), profile, "PROF_ATTRIBUTES.DELETE", logParam,
                        "OK");
            } catch (Throwable e) {
                logger.error("Exception occurred while deleting attribute", e);
                getHttpResponse().setStatus(404);
                try {
                    JSONObject attributesResponseSuccessJSON = new JSONObject();
                    attributesResponseSuccessJSON.put("success", false);
                    attributesResponseSuccessJSON.put("message", "Exception occurred while deleting attribute");
                    attributesResponseSuccessJSON.put("data", "[]");
                    writeBackToClient(new JSONSuccess(attributesResponseSuccessJSON));
                    try {
                        AuditLogUtilities.updateAudit(getHttpRequest(), profile, "PROF_ATTRIBUTES.DELETE",
                                logParam, "KO");
                    } catch (Exception e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                } catch (IOException e1) {
                    logger.error(e1.getMessage(), e1);
                } catch (JSONException e2) {
                    // TODO Auto-generated catch block
                    logger.error(e2.getMessage(), e2);
                }
                /*               throw new SpagoBIServiceException(SERVICE_NAME,
                                     "Exception occurred while deleting attribute",
                                     e);*/
            }
        }
    }
    logger.debug("OUT");

}

From source file:com.jd.survey.domain.survey.QuestionAnswerValidator.java

@Override
public void validate(Object obj, Errors errors) {
    try {/*from   ww w.ja va 2s . c  om*/

        boolean isValid;
        String validationFieldName = "stringAnswerValue";
        QuestionAnswer questionAnswer = (QuestionAnswer) obj;
        Question question = questionAnswer.getQuestion();
        String valueToValidate;
        BigDecimalValidator bigDecimalValidator;
        int optionsCount;
        int rowCount;
        int columnCount;
        System.out.println("Question type: " + question.getType());
        if (question.getVisible()) {
            switch (question.getType()) {
            case YES_NO_DROPDOWN: //Yes No DropDown 
                break;
            case SHORT_TEXT_INPUT: //Short Text Input
                //validate isRequired
                valueToValidate = questionAnswer.getStringAnswerValue();
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //continue validation if value entered is not null or empty
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    //validate range
                    if (question.getIntegerMinimum() != null
                            && !GenericValidator.minLength(valueToValidate, question.getIntegerMinimum())) {
                        errors.rejectValue(validationFieldName, "field_length_min",
                                new Object[] { question.getIntegerMinimum() },
                                "The length of the text must exceed " + question.getIntegerMinimum());
                        break;
                    }
                    if (question.getIntegerMaximum() != null
                            && !GenericValidator.maxLength(valueToValidate, question.getIntegerMaximum())) {
                        errors.rejectValue(validationFieldName, "field_length_max",
                                new Object[] { question.getIntegerMaximum() },
                                "The length of the text must not exceed " + question.getIntegerMaximum());
                        break;
                    }

                    //validate regular expression 
                    if (question.getRegularExpression() != null
                            && !question.getRegularExpression().trim().isEmpty() && !GenericValidator
                                    .matchRegexp(valueToValidate, question.getRegularExpression())) {
                        errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid entry");
                        break;
                    }
                }
                break;
            case LONG_TEXT_INPUT: //Long Text Input
                //validate isRequired
                valueToValidate = questionAnswer.getStringAnswerValue();
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //continue validation if value entered is not null or empty
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    //validate range
                    if (question.getIntegerMinimum() != null
                            && !GenericValidator.minLength(valueToValidate, question.getIntegerMinimum())) {
                        errors.rejectValue(validationFieldName, "field_length_min",
                                new Object[] { question.getIntegerMinimum() },
                                "The length of the text must exceed " + question.getIntegerMinimum());
                        break;
                    }
                    if (question.getIntegerMaximum() != null
                            && !GenericValidator.maxLength(valueToValidate, question.getIntegerMaximum())) {
                        errors.rejectValue(validationFieldName, "field_length_max",
                                new Object[] { question.getIntegerMaximum() },
                                "The length of the text must not exceed " + question.getIntegerMaximum());
                        break;
                    }
                    //validate regular expression 
                    if (question.getRegularExpression() != null
                            && !question.getRegularExpression().trim().isEmpty() && !GenericValidator
                                    .matchRegexp(valueToValidate, question.getRegularExpression())) {
                        errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid entry");
                        break;
                    }
                }
                break;
            case HUGE_TEXT_INPUT: //Huge Text Input
                //validate isRequired
                valueToValidate = questionAnswer.getStringAnswerValue();
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //continue validation if value entered is not null or empty
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    //validate range   
                    if (question.getIntegerMinimum() != null
                            && !GenericValidator.minLength(valueToValidate, question.getIntegerMinimum())) {
                        errors.rejectValue(validationFieldName, "field_length_min",
                                new Object[] { question.getIntegerMinimum() },
                                "The length of the text must exceed " + question.getIntegerMinimum());
                        break;
                    }
                    if (question.getIntegerMaximum() != null
                            && !GenericValidator.maxLength(valueToValidate, question.getIntegerMaximum())) {
                        errors.rejectValue(validationFieldName, "field_length_max",
                                new Object[] { question.getIntegerMaximum() },
                                "The length of the text must not exceed " + question.getIntegerMaximum());
                        break;
                    }
                    //validate regular expression 
                    if (question.getRegularExpression() != null
                            && !question.getRegularExpression().trim().isEmpty() && !GenericValidator
                                    .matchRegexp(valueToValidate, question.getRegularExpression())) {
                        errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid entry");
                        break;
                    }
                }
                break;
            case INTEGER_INPUT: //Integer Input
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is invalid");
                    break;
                }
                //continue validation if value entered is not null or empty
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    if (!GenericValidator.isInt(valueToValidate)) {
                        errors.rejectValue(validationFieldName, "field_invalid_integer",
                                "This field is invalid");
                        break;
                    }

                    //validate range
                    if (question.getIntegerMinimum() != null
                            && !GenericValidator.minValue((int) Integer.parseInt(valueToValidate),
                                    (int) question.getIntegerMinimum())) {

                        errors.rejectValue(validationFieldName, "field_value_min",
                                new Object[] { question.getIntegerMinimum() },
                                "The value of this field must exceed " + question.getIntegerMinimum());
                        break;
                    }
                    if (question.getIntegerMaximum() != null
                            && !GenericValidator.maxValue((int) Integer.parseInt(valueToValidate),
                                    (int) question.getIntegerMaximum())) {
                        errors.rejectValue(validationFieldName, "field_value_max",
                                new Object[] { question.getIntegerMaximum() },
                                "The value of this field must not exceed " + question.getIntegerMaximum());
                        break;
                    }
                }
                questionAnswer.setLongAnswerValue(valueToValidate != null && valueToValidate.length() > 0
                        ? Long.parseLong(valueToValidate)
                        : null);
                break;
            case CURRENCY_INPUT: //Currency Input
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }

                //continue validation if value entered is not null or empty
                if (valueToValidate != null && !valueToValidate.isEmpty()) {

                    CurrencyValidator currencyValidator = new CurrencyValidator(true, true);
                    if (!currencyValidator.isValid(valueToValidate, LocaleContextHolder.getLocale())) {
                        errors.rejectValue(validationFieldName, "field_invalid_currency",
                                "Invalid Currency Entered");
                        break;
                    }

                    //removing all '$' and ',' from string prior to validating max and min
                    valueToValidate = valueToValidate.replaceAll("\\$", "");
                    valueToValidate = valueToValidate.replaceAll(",", "");

                    //validate range
                    if (question.getDecimalMinimum() != null
                            && !GenericValidator.minValue((double) Double.parseDouble(valueToValidate),
                                    question.getDecimalMinimum().doubleValue())) {
                        errors.rejectValue(validationFieldName, "field_value_min",
                                new Object[] { question.getDecimalMinimum() },
                                "The value of this field must exceed " + question.getDecimalMinimum());
                        break;
                    }
                    if (question.getDecimalMaximum() != null
                            && !GenericValidator.maxValue((double) Double.parseDouble(valueToValidate),
                                    question.getDecimalMaximum().doubleValue())) {
                        errors.rejectValue(validationFieldName, "field_value_max",
                                new Object[] { question.getDecimalMaximum() },
                                "The value of this field must not exceed " + question.getDecimalMaximum());
                        break;
                    }

                    questionAnswer.setBigDecimalAnswerValue(
                            currencyValidator.validate(valueToValidate, LocaleContextHolder.getLocale()));
                    questionAnswer.setStringAnswerValue(currencyValidator.format(
                            currencyValidator.validate(valueToValidate, LocaleContextHolder.getLocale()),
                            LocaleContextHolder.getLocale()));

                }
                break;

            case DECIMAL_INPUT: //Numeric Input (Decimal)
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //continue validation if value entered is not null or empty
                bigDecimalValidator = new BigDecimalValidator(true);
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    if (!bigDecimalValidator.isValid(valueToValidate, LocaleContextHolder.getLocale())) {
                        errors.rejectValue(validationFieldName, "field_invalid_decimal",
                                "Invalid Decimal Entered");
                        break;
                    } else {
                        questionAnswer.setStringAnswerValue(bigDecimalValidator.format(
                                bigDecimalValidator.validate(valueToValidate, LocaleContextHolder.getLocale()),
                                LocaleContextHolder.getLocale()));
                    }

                    //removing all commas from string prior to validating max and min
                    valueToValidate = valueToValidate.replaceAll(",", "");
                    //validate range
                    if (question.getDecimalMinimum() != null
                            && !GenericValidator.minValue((double) Double.parseDouble(valueToValidate),
                                    question.getDecimalMinimum().doubleValue())) {
                        errors.rejectValue(validationFieldName, "field_value_min",
                                new Object[] { question.getDecimalMinimum() },
                                "The value of this field must exceed " + question.getDecimalMinimum());
                        break;
                    }
                    if (question.getDecimalMaximum() != null
                            && !GenericValidator.maxValue((double) Double.parseDouble(valueToValidate),
                                    question.getDecimalMaximum().doubleValue())) {
                        errors.rejectValue(validationFieldName, "field_value_max",
                                new Object[] { question.getDecimalMaximum() },
                                "The value of this field must not exceed " + question.getDecimalMaximum());
                        break;
                    }
                }
                questionAnswer.setBigDecimalAnswerValue(valueToValidate.trim().length() > 0
                        ? bigDecimalValidator.validate(valueToValidate, LocaleContextHolder.getLocale())
                        : null);
                break;
            case DATE_INPUT: //Date Input
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired   
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }

                //validate type if value entered is not null
                if (valueToValidate != null && !valueToValidate.isEmpty()) {
                    if (!GenericValidator.isDate(valueToValidate, dateFormat, true)) {
                        errors.rejectValue(validationFieldName, "field_invalid_date", "Invalid Date");
                        break;
                    }
                    if (question.getDateMinimum() != null && (DateValidator.getInstance()
                            .validate(valueToValidate).compareTo(question.getDateMinimum()) <= 0)) {
                        errors.rejectValue(validationFieldName, "field_date_min",
                                new Object[] { question.getDateMinimum() },
                                "The date entered must be after " + question.getDateMinimum());
                        break;
                    }
                    if (question.getDateMaximum() != null && (DateValidator.getInstance()
                            .validate(valueToValidate).compareTo(question.getDateMaximum()) >= 0)) {
                        errors.rejectValue(validationFieldName, "field_date_max",
                                new Object[] { question.getDateMaximum() },
                                "The date entered must be before " + question.getDateMaximum());
                        break;
                    }
                }

                questionAnswer.setDateAnswerValue(valueToValidate.trim().length() > 0
                        ? DateValidator.getInstance().validate(valueToValidate)
                        : null);
                break;
            case SINGLE_CHOICE_DROP_DOWN: //Single choice Drop Down
                valueToValidate = questionAnswer.getStringAnswerValue();
                isValid = false;
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //verify that the value exists in the options
                for (QuestionOption option : question.getOptions()) {
                    if (option.getValue().equalsIgnoreCase(valueToValidate)) {
                        isValid = true;
                        break;
                    }
                }
                if (!isValid && !GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid Option");
                    break;
                }

                break;
            case MULTIPLE_CHOICE_CHECKBOXES: //Multiple Choice Checkboxes
                //validate isRequired
                isValid = false;
                optionsCount = questionAnswer.getQuestion().getOptions().size();
                if (question.getRequired()) {
                    for (int i = 0; i < questionAnswer.getIntegerAnswerValuesArray().length; i++) {
                        if (questionAnswer.getIntegerAnswerValuesArray()[i] != null
                                && questionAnswer.getIntegerAnswerValuesArray()[i] <= optionsCount) {
                            //one element was checked
                            isValid = true;
                            break;
                        }
                    }
                    if (!isValid) {
                        errors.rejectValue(validationFieldName, "field_required", "This field is required");
                        break;
                    }
                }

                isValid = true;
                //verify that the value exists in the options range
                for (int i = 0; i < questionAnswer.getIntegerAnswerValuesArray().length; i++) {
                    if (questionAnswer.getIntegerAnswerValuesArray()[i] != null
                            && questionAnswer.getIntegerAnswerValuesArray()[i] > optionsCount) {
                        //one element was checked
                        isValid = false;
                        break;
                    }
                }
                if (!isValid) {
                    errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid Option");
                    break;
                }

                break;
            case DATASET_DROP_DOWN: //Dataset DropDown
                valueToValidate = questionAnswer.getStringAnswerValue();
                isValid = false;
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                //verify that the value exists in the dataset

                for (DataSetItem dataSetItem : question.getDataSetItems()) {
                    if (dataSetItem.getValue().equalsIgnoreCase(valueToValidate)) {
                        isValid = true;
                        break;
                    }
                }
                if (!isValid && !GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid Option");
                    break;
                }

                break;

            case SINGLE_CHOICE_RADIO_BUTTONS: //Single Choice Radio Buttons 
                isValid = false;
                valueToValidate = questionAnswer.getStringAnswerValue();
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }

                //verify that the value exists in the options
                for (QuestionOption option : question.getOptions()) {
                    if (option.getValue().equalsIgnoreCase(valueToValidate)) {
                        isValid = true;
                        break;
                    }
                }
                if (!isValid && !GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid Option");
                    break;
                }

                break;

            case YES_NO_DROPDOWN_MATRIX://Yes No DropDown Matrix
                break;
            case SHORT_TEXT_INPUT_MATRIX://Short Text Input Matrix
                rowCount = questionAnswer.getQuestion().getRowLabels().size();
                columnCount = questionAnswer.getQuestion().getColumnLabels().size();
                for (int r = 1; r <= rowCount; r++) {
                    for (int c = 1; c <= columnCount; c++) {
                        valueToValidate = questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1];
                        validationFieldName = "stringAnswerValuesMatrix[" + (r - 1) + "][" + (c - 1) + "]";
                        //validate isRequired
                        if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                            errors.rejectValue(validationFieldName, "field_required", "This field is required");
                            continue;
                        }
                        //continue validation if value entered is not null or empty
                        if (valueToValidate != null && !valueToValidate.isEmpty()) {
                            //validate range
                            if (question.getIntegerMinimum() != null && !GenericValidator
                                    .minLength(valueToValidate, question.getIntegerMinimum())) {
                                errors.rejectValue(validationFieldName, "field_length_min",
                                        new Object[] { question.getIntegerMinimum() },
                                        "The length of the text must exceed " + question.getIntegerMinimum());
                                continue;
                            }
                            if (question.getIntegerMaximum() != null && !GenericValidator
                                    .maxLength(valueToValidate, question.getIntegerMaximum())) {
                                errors.rejectValue(validationFieldName, "field_length_max",
                                        new Object[] { question.getIntegerMaximum() },
                                        "The length of the text must not exceed "
                                                + question.getIntegerMaximum());
                                continue;
                            }

                            //validate regular expression 
                            if (question.getRegularExpression() != null
                                    && !question.getRegularExpression().trim().isEmpty() && !GenericValidator
                                            .matchRegexp(valueToValidate, question.getRegularExpression())) {
                                errors.rejectValue(validationFieldName, "field_invalid_type", "Invalid entry");
                                continue;
                            }
                        }
                    }
                }
                break;
            case INTEGER_INPUT_MATRIX://Integer Input Matrix
                rowCount = questionAnswer.getQuestion().getRowLabels().size();
                columnCount = questionAnswer.getQuestion().getColumnLabels().size();
                for (int r = 1; r <= rowCount; r++) {
                    for (int c = 1; c <= columnCount; c++) {
                        valueToValidate = questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1];
                        validationFieldName = "stringAnswerValuesMatrix[" + (r - 1) + "][" + (c - 1) + "]";

                        //validate isRequired
                        if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                            errors.rejectValue(validationFieldName, "field_required", "This field is invalid");
                            continue;
                        }

                        //continue validation if value entered is not null or empty
                        if (valueToValidate != null && !valueToValidate.isEmpty()) {
                            if (!GenericValidator.isInt(valueToValidate)) {
                                errors.rejectValue(validationFieldName, "field_invalid_integer",
                                        "This field is invalid");
                                continue;
                            }

                            //validate range
                            if (question.getIntegerMinimum() != null
                                    && !GenericValidator.minValue((int) Integer.parseInt(valueToValidate),
                                            (int) question.getIntegerMinimum())) {
                                errors.rejectValue(validationFieldName, "field_value_min",
                                        new Object[] { question.getIntegerMinimum() },
                                        "The value of this field must exceed " + question.getIntegerMinimum());
                                continue;
                            }
                            if (question.getIntegerMaximum() != null
                                    && !GenericValidator.maxValue((int) Integer.parseInt(valueToValidate),
                                            (int) question.getIntegerMaximum())) {
                                errors.rejectValue(validationFieldName, "field_value_max",
                                        new Object[] { question.getIntegerMaximum() },
                                        "The value of this field must not exceed "
                                                + question.getIntegerMaximum());
                                continue;
                            }
                        }
                        questionAnswer.getLongAnswerValuesMatrix()[r - 1][c - 1] = (valueToValidate != null
                                && valueToValidate.length() > 0 ? Long.parseLong(valueToValidate) : null);
                    }
                }
                break;
            case CURRENCY_INPUT_MATRIX://Currency Input Matrix  NEED TO ADD MAX MIN???????????????????????????????????????????????????
                rowCount = questionAnswer.getQuestion().getRowLabels().size();
                columnCount = questionAnswer.getQuestion().getColumnLabels().size();
                for (int r = 1; r <= rowCount; r++) {
                    for (int c = 1; c <= columnCount; c++) {
                        System.out.println("ROW: " + r + " / COL: " + c
                                + " -----------------------------------------------------------------------------------------");
                        valueToValidate = questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1];
                        validationFieldName = "stringAnswerValuesMatrix[" + (r - 1) + "][" + (c - 1) + "]";
                        //validate isRequired
                        if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                            errors.rejectValue(validationFieldName, "field_required", "This field is required");
                            continue;
                        }

                        //continue validation if value entered is not null or empty
                        if (valueToValidate != null && !valueToValidate.isEmpty()) {
                            CurrencyValidator currencyValidator = new CurrencyValidator(true, true);
                            if (!currencyValidator.isValid(valueToValidate, LocaleContextHolder.getLocale())) {
                                errors.rejectValue(validationFieldName, "field_invalid_type",
                                        "Invalid Currency Entered");
                                continue;
                            } else {
                                questionAnswer.getBigDecimalAnswerValuesMatrix()[r - 1][c
                                        - 1] = currencyValidator.validate(valueToValidate,
                                                LocaleContextHolder.getLocale());
                                questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1] = currencyValidator
                                        .format(currencyValidator.validate(valueToValidate,
                                                LocaleContextHolder.getLocale()),
                                                LocaleContextHolder.getLocale());
                            }
                            //removing all '$' and ',' from string prior to validating max and min
                            valueToValidate = valueToValidate.replaceAll("\\$", "");
                            valueToValidate = valueToValidate.replaceAll(",", "");

                            //Validating max and min
                            if (question.getDecimalMinimum() == null) {
                                System.out.println(
                                        "MIN IS NULL!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
                            }
                            if (question.getDecimalMinimum() != null
                                    && !GenericValidator.minValue((double) Double.parseDouble(valueToValidate),
                                            question.getDecimalMinimum().doubleValue())) {
                                System.out.println(validationFieldName
                                        + "MIN ##################################################################################");
                                errors.rejectValue(validationFieldName, "field_value_min",
                                        new Object[] { question.getDecimalMinimum() },
                                        "The value of this field must exceed " + question.getDecimalMinimum());
                                continue;
                            }
                            if (question.getDecimalMaximum() == null) {
                                System.out.println(
                                        "MAX IS NULL!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
                            }

                            if (question.getDecimalMaximum() != null
                                    && !GenericValidator.maxValue((double) Double.parseDouble(valueToValidate),
                                            question.getDecimalMaximum().doubleValue())) {
                                System.out.println(validationFieldName
                                        + "MAX ########################################################################################################");
                                errors.rejectValue(validationFieldName, "field_value_max",
                                        new Object[] { question.getDecimalMaximum() },
                                        "The value of this field must not exceed "
                                                + question.getDecimalMaximum());
                                continue;
                            }
                        }
                    }
                }
                break;

            case DECIMAL_INPUT_MATRIX://Decimal Input Matrix
                rowCount = questionAnswer.getQuestion().getRowLabels().size();
                columnCount = questionAnswer.getQuestion().getColumnLabels().size();
                for (int r = 1; r <= rowCount; r++) {
                    for (int c = 1; c <= columnCount; c++) {
                        valueToValidate = questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1];
                        validationFieldName = "stringAnswerValuesMatrix[" + (r - 1) + "][" + (c - 1) + "]";
                        //validate isRequired
                        if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                            errors.rejectValue(validationFieldName, "field_required", "This field is required");
                            continue;
                        }

                        //continue validation if value entered is not null or empty
                        bigDecimalValidator = new BigDecimalValidator(true);
                        if (valueToValidate != null && !valueToValidate.isEmpty()) {
                            if (!bigDecimalValidator.isValid(valueToValidate,
                                    LocaleContextHolder.getLocale())) {
                                errors.rejectValue(validationFieldName, "field_invalid_type",
                                        "Invalid Decimal Entered");
                                continue;
                            } else {
                                questionAnswer.setStringAnswerValue(bigDecimalValidator.format(
                                        bigDecimalValidator.validate(valueToValidate,
                                                LocaleContextHolder.getLocale()),
                                        LocaleContextHolder.getLocale()));
                            }

                            //validate range
                            if (question.getDecimalMinimum() != null
                                    && !GenericValidator.minValue((double) Double.parseDouble(valueToValidate),
                                            question.getDecimalMinimum().doubleValue())) {
                                errors.rejectValue(validationFieldName, "field_value_min",
                                        new Object[] { question.getDecimalMinimum() },
                                        "The value of this field must exceed " + question.getDecimalMinimum());
                                continue;
                            }
                            if (question.getDecimalMaximum() != null
                                    && !GenericValidator.maxValue((double) Double.parseDouble(valueToValidate),
                                            question.getDecimalMaximum().doubleValue())) {
                                errors.rejectValue(validationFieldName, "field_value_max",
                                        new Object[] { question.getDecimalMaximum() },
                                        "The value of this field must not exceed "
                                                + question.getDecimalMaximum());
                                continue;
                            }
                        }
                        questionAnswer.getBigDecimalAnswerValuesMatrix()[r - 1][c
                                - 1] = (valueToValidate.trim().length() > 0 ? bigDecimalValidator
                                        .validate(valueToValidate, LocaleContextHolder.getLocale()) : null);

                    }
                }
                break;
            case DATE_INPUT_MATRIX://Date Input Matrix
                rowCount = questionAnswer.getQuestion().getRowLabels().size();
                columnCount = questionAnswer.getQuestion().getColumnLabels().size();
                for (int r = 1; r <= rowCount; r++) {
                    for (int c = 1; c <= columnCount; c++) {
                        valueToValidate = questionAnswer.getStringAnswerValuesMatrix()[r - 1][c - 1];
                        validationFieldName = "stringAnswerValuesMatrix[" + (r - 1) + "][" + (c - 1) + "]";

                        //validate isRequired   
                        if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                            errors.rejectValue(validationFieldName, "field_required", "This field is required");
                            continue;
                        }

                        //validate type if value entered is not null
                        if (valueToValidate != null && !valueToValidate.isEmpty()) {
                            if (!GenericValidator.isDate(valueToValidate, dateFormat, true)) {
                                errors.rejectValue(validationFieldName, "field_invalid_date", "Invalid Date");
                                continue;
                            }
                            if (question.getDateMinimum() != null && (DateValidator.getInstance()
                                    .validate(valueToValidate).compareTo(question.getDateMinimum()) <= 0)) {
                                errors.rejectValue(validationFieldName, "field_date_min",
                                        new Object[] { question.getDateMinimum() },
                                        "The date entered must be after " + question.getDateMinimum());
                                continue;
                            }
                            if (question.getDateMaximum() != null && (DateValidator.getInstance()
                                    .validate(valueToValidate).compareTo(question.getDateMaximum()) >= 0)) {
                                errors.rejectValue(validationFieldName, "field_date_max",
                                        new Object[] { question.getDateMaximum() },
                                        "The date entered must be before " + question.getDateMaximum());
                                continue;
                            }
                        }
                        questionAnswer.getDateAnswerValuesMatrix()[r - 1][c
                                - 1] = (valueToValidate.trim().length() > 0
                                        ? DateValidator.getInstance().validate(valueToValidate)
                                        : null);
                    }
                }
                break;
            case STAR_RATING:
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                break;
            case SMILEY_FACES_RATING:
                valueToValidate = questionAnswer.getStringAnswerValue();
                //validate isRequired
                if (question.getRequired() && GenericValidator.isBlankOrNull(valueToValidate)) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }
                break;

            case IMAGE_DISPLAY:
                //no validation
                break;
            case VIDEO_DISPLAY:
                //no validation
                break;
            case FILE_UPLOAD:
                //validate that the file is not null
                if (question.getRequired() && (questionAnswer.getSurveyDocument() == null)
                        && !questionAnswer.getDocumentAlreadyUploded()) {
                    errors.rejectValue(validationFieldName, "field_required", "This field is required");
                    break;
                }

                //check the file type from the file extension    
                if (questionAnswer.getSurveyDocument() != null
                        && !validateFileType(questionAnswer.getSurveyDocument().getContentType())) {
                    errors.rejectValue(validationFieldName, invalidContentMessage, this.invalidContentMessage);
                    break;
                }

                //validate the size
                if (questionAnswer.getSurveyDocument() != null
                        && !((questionAnswer.getSurveyDocument().getContent().length) <= maximunFileSize
                                * ONE_BYTE)) {
                    errors.rejectValue(validationFieldName, invalidFileSizeMessage,
                            this.invalidFileSizeMessage);
                    break;
                }

                break;

            }

        }
    } catch (Exception e) {
        log.error(e.getMessage(), e);
        throw (new RuntimeException(e));
    }
}