Examples with Validator org.akaza.openclinica.control.form.Validator used on opensource projects

Example 21 with Validator

use of org.akaza.openclinica.control.form.Validator in project OpenClinica by OpenClinica.

the class CreateSubjectGroupClassServlet method confirmGroup.

/**
     * Validates the first section of study inputs and save it into study bean
     *
     * @param request
     * @param response
     * @throws Exception
     */
private void confirmGroup() throws Exception {
    Validator v = new Validator(request);
    FormProcessor fp = new FormProcessor(request);
    v.addValidation("name", Validator.NO_BLANKS);
    v.addValidation("subjectAssignment", Validator.NO_BLANKS);
    v.addValidation("name", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 30);
    v.addValidation("subjectAssignment", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 30);
    ArrayList studyGroups = new ArrayList();
    for (int i = 0; i < 10; i++) {
        String name = fp.getString("studyGroup" + i);
        String description = fp.getString("studyGroupDescription" + i);
        if (!StringUtil.isBlank(name)) {
            StudyGroupBean group = new StudyGroupBean();
            group.setName(name);
            group.setDescription(description);
            studyGroups.add(group);
            if (name.length() > 255) {
                request.setAttribute("studyGroupError", respage.getString("group_name_cannot_be_more_255"));
                break;
            }
            if (description.length() > 1000) {
                request.setAttribute("studyGroupError", respage.getString("group_description_cannot_be_more_100"));
                break;
            }
        }
    }
    errors = v.validate();
    if (fp.getInt("groupClassTypeId") == 0) {
        Validator.addError(errors, "groupClassTypeId", resexception.getString("group_class_type_is_required"));
    }
    StudyGroupClassBean group = new StudyGroupClassBean();
    group.setName(fp.getString("name"));
    group.setGroupClassTypeId(fp.getInt("groupClassTypeId"));
    group.setSubjectAssignment(fp.getString("subjectAssignment"));
    session.setAttribute("group", group);
    session.setAttribute("studyGroups", studyGroups);
    if (errors.isEmpty()) {
        logger.info("no errors in the first section");
        group.setGroupClassTypeName(GroupClassType.get(group.getGroupClassTypeId()).getName());
        forwardPage(Page.CREATE_SUBJECT_GROUP_CLASS_CONFIRM);
    } else {
        logger.info("has validation errors in the first section");
        request.setAttribute("formMessages", errors);
        request.setAttribute("groupTypes", GroupClassType.toArrayList());
        forwardPage(Page.CREATE_SUBJECT_GROUP_CLASS);
    }
}

Example 22 with Validator

use of org.akaza.openclinica.control.form.Validator in project OpenClinica by OpenClinica.

the class TestRuleServlet method processRequest.

@Override
public void processRequest() throws Exception {
    FormProcessor fp = new FormProcessor(request);
    String action = request.getParameter("action");
    Validator v = new Validator(request);
    if (StringUtil.isBlank(action)) {
        request.setAttribute("result", resword.getString("test_rule_default_result"));
        Integer ruleSetRuleId = fp.getInt("ruleSetRuleId");
        if (ruleSetRuleId != 0) {
            // If testing an existing ruleSetRule
            RuleSetRuleBean rsr = getRuleSetRuleDao().findById(ruleSetRuleId);
            rsr.getActions().size();
            HashMap presetValues = new HashMap();
            presetValues.put(TARGET, rsr.getRuleSetBean().getTarget().getValue());
            presetValues.put(RULE, rsr.getRuleBean().getExpression().getValue());
            presetValues.put(RULE_SET_RULE_ID, String.valueOf(ruleSetRuleId));
            fp.setPresetValues(presetValues);
            setPresetValues(presetValues);
            session.setAttribute("testRuleActions", rsr.getActions());
            session.setAttribute("testRulesTarget", rsr.getRuleSetBean().getTarget().getValue());
            request.setAttribute("ruleSetRuleId", ruleSetRuleId);
            request.setAttribute("ruleSetId", rsr.getRuleSetBean().getId());
            ItemBean item = getExpressionService().getItemBeanFromExpression(rsr.getRuleSetBean().getTarget().getValue());
            if (item != null) {
                request.setAttribute("itemName", item.getName());
                request.setAttribute("itemDefinition", item.getDescription());
            } else {
                StudyEventDefinitionBean studyEventDef = getExpressionService().getStudyEventDefinitionFromExpressionForEvents(rsr.getRuleSetBean().getTarget().getValue(), this.currentStudy);
                request.setAttribute("itemName", studyEventDef.getName());
                request.setAttribute("itemDefinition", studyEventDef.getDescription());
            }
            request.setAttribute("ruleSetRuleAvailable", true);
        } else {
            // free form testing
            putDummyActionInSession();
        }
        session.removeAttribute("testValues");
        request.setAttribute("action", "validate");
        forwardPage(Page.TEST_RULES);
    } else if (action.equals("validate")) {
        HashMap<String, String> result = validate(v);
        if (result.get("ruleValidation").equals("rule_valid")) {
            addPageMessage(resword.getString("test_rules_message_valid"));
        } else {
            addPageMessage(resword.getString("test_rules_message_invalid"));
        }
        request.setAttribute("ruleValidation", result.get("ruleValidation"));
        request.setAttribute("validate", "on");
        request.setAttribute("ruleEvaluatesTo", resword.getString("test_rules_validate_message"));
        request.setAttribute("ruleValidationFailMessage", result.get("ruleValidationFailMessage"));
        request.setAttribute("action", result.get("ruleValidation").equals("rule_valid") ? "test" : "validate");
        result.remove("result");
        result.remove("ruleValidation");
        result.remove("ruleEvaluatesTo");
        result.remove("ruleValidationFailMessage");
        populateTooltip(result);
        session.setAttribute("testValues", result);
        populteFormFields(fp);
        forwardPage(Page.TEST_RULES);
    } else if (action.equals("test")) {
        HashMap<String, String> result = validate(v);
        HashMap errors = v.validate();
        if (!errors.isEmpty()) {
            setInputMessages(errors);
            if (result.get("ruleValidation").equals("rule_valid")) {
                addPageMessage(resword.getString("test_rules_message_valid"));
            } else {
                addPageMessage(resword.getString("test_rules_message_invalid"));
            }
            request.setAttribute("ruleValidation", result.get("ruleValidation"));
            request.setAttribute("validate", "on");
            request.setAttribute("ruleEvaluatesTo", resword.getString("test_rules_rule_fail_invalid_data_type") + " " + resword.getString("test_rules_rule_fail_invalid_data_type_desc"));
            request.setAttribute("ruleValidationFailMessage", result.get("ruleValidationFailMessage"));
            request.setAttribute("action", "test");
        } else {
            if (result.get("ruleValidation").equals("rule_valid")) {
                addPageMessage(resword.getString("test_rules_message_valid"));
            } else {
                addPageMessage(resword.getString("test_rules_message_invalid"));
            }
            request.setAttribute("action", result.get("ruleValidation").equals("rule_valid") ? "test" : "validate");
            request.setAttribute("ruleValidation", result.get("ruleValidation"));
            request.setAttribute("ruleEvaluatesTo", result.get("ruleEvaluatesTo"));
            request.setAttribute("ruleValidationFailMessage", result.get("ruleValidationFailMessage"));
        }
        if (result.get("ruleValidation").equals("rule_invalid")) {
            session.setAttribute("testValues", new HashMap<String, String>());
        } else {
            session.setAttribute("testValues", result);
        }
        result.remove("result");
        result.remove("ruleValidation");
        result.remove("ruleEvaluatesTo");
        result.remove("ruleValidationFailMessage");
        populateTooltip(result);
        populteFormFields(fp);
        forwardPage(Page.TEST_RULES);
    }
}

Example 23 with Validator

use of org.akaza.openclinica.control.form.Validator in project OpenClinica by OpenClinica.

the class StudyController method createNewStudy.

/**
	 * @api {post} /pages/auth/api/v1/studies/ Create a study
	 * @apiName createNewStudy
	 * @apiPermission Authenticate using api-key. admin
	 * @apiVersion 3.8.0
	 * @apiParam {String} uniqueProtococlId Study unique protocol ID.
	 * @apiParam {String} briefTitle Brief Title .
	 * @apiParam {String} principalInvestigator Principal Investigator Name.
	 * @apiParam {Integer} expectedTotalEnrollment Expected Total Enrollment number
	 * @apiParam {String} sponsor Sponsor name.
	 * @apiParam {String} protocolType 'Interventional' or ' Observational'
	 * @apiParam {String} status 'Available' or 'Design'
	 * @apiParam {String} briefSummary Study Summary
	 * @apiParam {Date} startDate Start date
	 * @apiParam {Array} assignUserRoles Assign Users to Roles for this Study.
	 * @apiGroup Study
	 * @apiHeader {String} api_key Users unique access-key.
	 * @apiDescription This API is to create a New Study in OC.
	 *                 All the fields are required fields and can't be left blank.
	 *                 You need to provide your Api-key to be connected.
	 * @apiParamExample {json} Request-Example:
	 *                  {
	 *                  "briefTitle": "Study Protocol ID Name",
	 *                  "principalInvestigator": "Principal Investigator Name",
	 *                  "expectedTotalEnrollment": "10",
	 *                  "sponsor": "Sponsor Name",
	 *                  "protocolType": "Interventional",
	 *                  "status": "available",
	 *                  "assignUserRoles": [
	 *                  { "username": "usera", "role": "Data Manager" },
	 *                  { "username": "userb", "role": "Study Director" },
	 *                  { "username": "userc", "role": "Data Specialist" },
	 *                  { "username": "userd", "role": "Monitor" },
	 *                  { "username": "usere", "role": "Data Entry Person" }
	 *                  ],
	 *                  "uniqueProtocolID": "Study Protocol ID",
	 *                  "briefSummary": "Study Summary",
	 *                  "startDate": "2011-11-11"
	 *                  }
	 * @apiErrorExample {json} Error-Response:
	 *                  HTTP/1.1 400 Bad Request
	 *                  {
	 *                  "message": "VALIDATION FAILED",
	 *                  "status": "available",
	 *                  "principalInvestigator": "Principal Investigator Name",
	 *                  "expectedTotalEnrollment": "10",
	 *                  "sponsor": "Sponsor Name",
	 *                  "protocolType": "Interventional",
	 *                  "errors": [
	 *                  {"field": "UniqueProtocolId","resource": "Study Object","code": "Unique Protocol Id exist in the System"}
	 *                  ],
	 *                  "startDate": "2011-11-11",
	 *                  "assignUserRoles": [
	 *                  {"username": "usera","role": "Data Manager"},
	 *                  {"username": "userb","role": "Study Director"},
	 *                  {"username": "userc","role": "Data Specialist"}
	 *                  ],
	 *                  "uniqueProtocolID": "Study Protocol ID",
	 *                  "briefTitle": "Study Protocol ID",
	 *                  "briefSummary": "Study Summary",
	 *                  "studyOid": null
	 *                  }
	 * @apiSuccessExample {json} Success-Response:
	 *                    HTTP/1.1 200 OK
	 *                    {
	 *                    "message": "SUCCESS",
	 *                    "uniqueProtocolID": "Study Protocol ID",
	 *                    "studyOid": "S_STUDYPRO",
	 *                    }
	 */
@RequestMapping(value = "/", method = RequestMethod.POST)
public ResponseEntity<Object> createNewStudy(HttpServletRequest request, @RequestBody HashMap<String, Object> map) throws Exception {
    ArrayList<ErrorObject> errorObjects = new ArrayList();
    StudyBean studyBean = null;
    System.out.println("I'm in Create Study");
    ResponseEntity<Object> response = null;
    String validation_failed_message = "VALIDATION FAILED";
    String validation_passed_message = "SUCCESS";
    String uniqueProtocolID = (String) map.get("uniqueProtocolID");
    String name = (String) map.get("briefTitle");
    String principalInvestigator = (String) map.get("principalInvestigator");
    String briefSummary = (String) map.get("briefSummary");
    String sponsor = (String) map.get("sponsor");
    String protocolType = (String) map.get("protocolType");
    String startDate = (String) map.get("startDate");
    String expectedTotalEnrollment = (String) map.get("expectedTotalEnrollment");
    String status = (String) map.get("status");
    ArrayList<UserRole> assignUserRoles = (ArrayList<UserRole>) map.get("assignUserRoles");
    ArrayList<UserRole> userList = new ArrayList<>();
    if (assignUserRoles != null) {
        for (Object userRole : assignUserRoles) {
            UserRole uRole = new UserRole();
            uRole.setUsername((String) ((HashMap<String, Object>) userRole).get("username"));
            uRole.setRole((String) ((HashMap<String, Object>) userRole).get("role"));
            udao = new UserAccountDAO(dataSource);
            UserAccountBean assignedUserBean = (UserAccountBean) udao.findByUserName(uRole.getUsername());
            if (assignedUserBean == null || !assignedUserBean.isActive()) {
                ErrorObject errorOBject = createErrorObject("Study Object", "The Assigned Username " + uRole.getUsername() + " is not a Valid User", "Assigned User");
                errorObjects.add(errorOBject);
            }
            ResourceBundle resterm = org.akaza.openclinica.i18n.util.ResourceBundleProvider.getTermsBundle();
            if (getStudyRole(uRole.getRole(), resterm) == null) {
                ErrorObject errorOBject = createErrorObject("Study Object", "Assigned Role for " + uRole.getUsername() + " is not a Valid Study Role", "Assigned Role");
                errorObjects.add(errorOBject);
            }
            userList.add(uRole);
        }
    }
    StudyDTO studyDTO = buildStudyDTO(uniqueProtocolID, name, briefSummary, principalInvestigator, sponsor, expectedTotalEnrollment, protocolType, status, startDate, userList);
    if (uniqueProtocolID == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "UniqueProtocolID");
        errorObjects.add(errorOBject);
    } else {
        uniqueProtocolID = uniqueProtocolID.trim();
    }
    if (name == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "BriefTitle");
        errorObjects.add(errorOBject);
    } else {
        name = name.trim();
    }
    if (principalInvestigator == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "PrincipalInvestigator");
        errorObjects.add(errorOBject);
    } else {
        principalInvestigator = principalInvestigator.trim();
    }
    if (briefSummary == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "BriefSummary");
        errorObjects.add(errorOBject);
    } else {
        briefSummary = briefSummary.trim();
    }
    if (sponsor == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "Sponsor");
        errorObjects.add(errorOBject);
    } else {
        sponsor = sponsor.trim();
    }
    if (protocolType == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "ProtocolType");
        errorObjects.add(errorOBject);
    } else {
        protocolType = protocolType.trim();
    }
    if (startDate == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "StartDate");
        errorObjects.add(errorOBject);
    } else {
        startDate = startDate.trim();
    }
    if (expectedTotalEnrollment == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "ExpectedTotalEnrollment");
        errorObjects.add(errorOBject);
    } else {
        expectedTotalEnrollment = expectedTotalEnrollment.trim();
    }
    if (status == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "Status");
        errorObjects.add(errorOBject);
    } else {
        status = status.trim();
    }
    if (assignUserRoles == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Missing Field", "AssignUserRoles");
        errorObjects.add(errorOBject);
    }
    if (status != null && !status.equalsIgnoreCase("available") && !status.equalsIgnoreCase("design") && !status.equals("")) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Status Field Should have 'Available' or 'Design' Status only, If left empty , will default to 'Design' Mode", "Status");
        errorObjects.add(errorOBject);
    }
    request.setAttribute("uniqueProId", uniqueProtocolID);
    // Brief Title
    request.setAttribute("name", name);
    request.setAttribute("prinInvestigator", principalInvestigator);
    request.setAttribute("description", briefSummary);
    request.setAttribute("sponsor", sponsor);
    request.setAttribute("startDate", startDate);
    request.setAttribute("expectedTotalEnrollment", expectedTotalEnrollment);
    request.setAttribute("status", status);
    String format = "yyyy-MM-dd";
    SimpleDateFormat formatter = null;
    Date formattedDate = null;
    if (startDate != "" && startDate != null) {
        try {
            formatter = new SimpleDateFormat(format);
            formattedDate = formatter.parse(startDate);
        } catch (ParseException e) {
            ErrorObject errorOBject = createErrorObject("Study Object", "The StartDate format is not a valid 'yyyy-MM-dd' format", "StartDate");
            errorObjects.add(errorOBject);
        }
        if (formattedDate != null) {
            if (!startDate.equals(formatter.format(formattedDate))) {
                ErrorObject errorOBject = createErrorObject("Study Object", "The StartDate format is not a valid 'yyyy-MM-dd' format", "StartDate");
                errorObjects.add(errorOBject);
            }
        }
    }
    UserAccountBean ownerUserAccount = getStudyOwnerAccount(request);
    if (ownerUserAccount == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "The Owner User Account is not Valid Account or Does not have Admin user type", "Owner Account");
        errorObjects.add(errorOBject);
    }
    Validator v0 = new Validator(request);
    v0.addValidation("name", Validator.NO_BLANKS);
    HashMap vError0 = v0.validate();
    if (!vError0.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "BriefTitle");
        errorObjects.add(errorOBject);
    }
    Validator v1 = new Validator(request);
    v1.addValidation("uniqueProId", Validator.NO_BLANKS);
    HashMap vError1 = v1.validate();
    if (!vError1.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "UniqueProtocolId");
        errorObjects.add(errorOBject);
    }
    Validator v2 = new Validator(request);
    v2.addValidation("description", Validator.NO_BLANKS);
    HashMap vError2 = v2.validate();
    if (!vError2.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "BriefSummary");
        errorObjects.add(errorOBject);
    }
    Validator v3 = new Validator(request);
    v3.addValidation("prinInvestigator", Validator.NO_BLANKS);
    HashMap vError3 = v3.validate();
    if (!vError3.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "PrincipleInvestigator");
        errorObjects.add(errorOBject);
    }
    Validator v4 = new Validator(request);
    v4.addValidation("sponsor", Validator.NO_BLANKS);
    HashMap vError4 = v4.validate();
    if (!vError4.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "Sponsor");
        errorObjects.add(errorOBject);
    }
    Validator v5 = new Validator(request);
    v5.addValidation("startDate", Validator.NO_BLANKS);
    HashMap vError5 = v5.validate();
    if (!vError5.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "StartDate");
        errorObjects.add(errorOBject);
    }
    Validator v6 = new Validator(request);
    HashMap vError6 = v6.validate();
    if (uniqueProtocolID != null)
        validateUniqueProId(request, vError6);
    if (!vError6.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Unique Protocol Id exist in the System", "UniqueProtocolId");
        errorObjects.add(errorOBject);
    }
    Validator v7 = new Validator(request);
    v7.addValidation("expectedTotalEnrollment", Validator.NO_BLANKS);
    HashMap vError7 = v7.validate();
    if (!vError7.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Study Object", "This field cannot be blank.", "ExpectedTotalEnrollment");
        errorObjects.add(errorOBject);
    }
    if (protocolType != null && !verifyProtocolTypeExist(protocolType)) {
        ErrorObject errorOBject = createErrorObject("Study Object", "Protocol Type is not Valid", "ProtocolType");
        errorObjects.add(errorOBject);
    }
    studyDTO.setErrors(errorObjects);
    if (errorObjects != null && errorObjects.size() != 0) {
        studyDTO.setMessage(validation_failed_message);
        response = new ResponseEntity(studyDTO, org.springframework.http.HttpStatus.BAD_REQUEST);
    } else {
        studyBean = buildStudyBean(uniqueProtocolID, name, briefSummary, principalInvestigator, sponsor, Integer.valueOf(expectedTotalEnrollment), protocolType, status, formattedDate, ownerUserAccount);
        StudyBean sBean = createStudy(studyBean, ownerUserAccount);
        studyDTO.setStudyOid(sBean.getOid());
        studyDTO.setMessage(validation_passed_message);
        StudyUserRoleBean sub = new StudyUserRoleBean();
        sub.setRole(Role.COORDINATOR);
        sub.setStudyId(sBean.getId());
        sub.setStatus(Status.AVAILABLE);
        sub.setOwner(ownerUserAccount);
        StudyUserRoleBean surb = createRole(ownerUserAccount, sub);
        ResourceBundle resterm = org.akaza.openclinica.i18n.util.ResourceBundleProvider.getTermsBundle();
        for (UserRole userRole : userList) {
            sub = new StudyUserRoleBean();
            sub.setRole(getStudyRole(userRole.getRole(), resterm));
            sub.setStudyId(sBean.getId());
            sub.setStatus(Status.AVAILABLE);
            sub.setOwner(ownerUserAccount);
            udao = new UserAccountDAO(dataSource);
            UserAccountBean assignedUserBean = (UserAccountBean) udao.findByUserName(userRole.getUsername());
            surb = createRole(assignedUserBean, sub);
        }
        ResponseSuccessStudyDTO responseSuccess = new ResponseSuccessStudyDTO();
        responseSuccess.setMessage(studyDTO.getMessage());
        responseSuccess.setStudyOid(studyDTO.getStudyOid());
        responseSuccess.setUniqueProtocolID(studyDTO.getUniqueProtocolID());
        response = new ResponseEntity(responseSuccess, org.springframework.http.HttpStatus.OK);
    }
    return response;
}

Example 24 with Validator

use of org.akaza.openclinica.control.form.Validator in project OpenClinica by OpenClinica.

the class StudyController method createEventDefinition.

/**
	 * @api {post} /pages/auth/api/v1/studies/:uniqueProtocolId/eventdefinitions Create a study event
	 * @apiName createEventDefinition
	 * @apiPermission Authenticate using api-key. admin
	 * @apiVersion 3.8.0
	 * @apiParam {String} uniqueProtocolId Study unique protocol ID.
	 * @apiParam {String} name Event Name.
	 * @apiParam {String} description Event Description.
	 * @apiParam {String} category Category Name.
	 * @apiParam {Boolean} repeating 'True' or 'False'.
	 * @apiParam {String} type 'Scheduled' , 'UnScheduled' or 'Common'.
	 * @apiGroup Study Event
	 * @apiHeader {String} api_key Users unique access-key.
	 * @apiDescription Creates a study event definition.
	 * @apiParamExample {json} Request-Example:
	 *                  {
	 *                  "name": "Event Name",
	 *                  "description": "Event Description",
	 *                  "category": "Category Name",
	 *                  "repeating": "true",
	 *                  "type":"Scheduled"
	 *                  }
	 * @apiErrorExample {json} Error-Response:
	 *                  HTTP/1.1 400 Bad Request
	 *                  {
	 *                  "name": "Event Name",
	 *                  "message": "VALIDATION FAILED",
	 *                  "type": "",
	 *                  "errors": [
	 *                  {"field": "Type","resource": "Event Definition Object","code": "Type Field should be Either 'Scheduled' , 'UnScheduled' or 'Common'"},
	 *                  {"field": "Type","resource": "Event Definition Object","code": "This field cannot be blank."}
	 *                  ],
	 *                  "category": "Category Name",
	 *                  "description": "Event Description",
	 *                  "eventDefOid": null,
	 *                  "repeating": "true"
	 *                  }
	 * @apiSuccessExample {json} Success-Response:
	 *                    HTTP/1.1 200 OK
	 *                    {
	 *                    "message": "SUCCESS",
	 *                    "name": "Event Name",
	 *                    "eventDefOid": "SE_EVENTNAME"
	 *                    }
	 */
@RequestMapping(value = "/{uniqueProtocolID}/eventdefinitions", method = RequestMethod.POST)
public ResponseEntity<Object> createEventDefinition(HttpServletRequest request, @RequestBody HashMap<String, Object> map, @PathVariable("uniqueProtocolID") String uniqueProtocolID) throws Exception {
    System.out.println("I'm in Create Event Definition ");
    ArrayList<ErrorObject> errorObjects = new ArrayList();
    StudyEventDefinitionBean eventBean = null;
    ResponseEntity<Object> response = null;
    String validation_failed_message = "VALIDATION FAILED";
    String validation_passed_message = "SUCCESS";
    String name = (String) map.get("name");
    String description = (String) map.get("description");
    String category = (String) map.get("category");
    String type = (String) map.get("type");
    String repeating = (String) map.get("repeating");
    EventDefinitionDTO eventDefinitionDTO = buildEventDefnDTO(name, description, category, repeating, type);
    if (name == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "Missing Field", "Name");
        errorObjects.add(errorOBject);
    } else {
        name = name.trim();
    }
    if (description == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "Missing Field", "Description");
        errorObjects.add(errorOBject);
    } else {
        description = description.trim();
    }
    if (category == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "Missing Field", "Category");
        errorObjects.add(errorOBject);
    } else {
        category = category.trim();
    }
    if (type == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "Missing Field", "Type");
        errorObjects.add(errorOBject);
    } else {
        type = type.trim();
    }
    if (repeating == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "Missing Field", "Repeating");
        errorObjects.add(errorOBject);
    } else {
        repeating = repeating.trim();
    }
    if (repeating != null) {
        if (!repeating.equalsIgnoreCase("true") && !repeating.equalsIgnoreCase("false")) {
            ErrorObject errorOBject = createErrorObject("Event Definition Object", "Repeating Field should be Either 'True' or 'False'", "Repeating");
            errorObjects.add(errorOBject);
        }
    }
    if (type != null) {
        if (!type.equalsIgnoreCase("scheduled") && !type.equalsIgnoreCase("unscheduled") && !type.equalsIgnoreCase("common")) {
            ErrorObject errorOBject = createErrorObject("Event Definition Object", "Type Field should be Either 'Scheduled' , 'UnScheduled' or 'Common'", "Type");
            errorObjects.add(errorOBject);
        }
    }
    request.setAttribute("name", name);
    request.setAttribute("description", description);
    request.setAttribute("category", category);
    request.setAttribute("type", type);
    request.setAttribute("repeating", repeating);
    StudyBean parentStudy = getStudyByUniqId(uniqueProtocolID);
    if (parentStudy == null) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "The Study Protocol Id provided in the URL is not a valid Protocol Id", "Unique Study Protocol Id");
        errorObjects.add(errorOBject);
    } else if (parentStudy.getParentStudyId() != 0) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "The Study Protocol Id provided in the URL is not a valid Study Protocol Id", "Unique Study Protocol Id");
        errorObjects.add(errorOBject);
    }
    UserAccountBean ownerUserAccount = getStudyOwnerAccount(request);
    if (ownerUserAccount == null) {
        ErrorObject errorOBject = createErrorObject("Study Object", "The Owner User Account is not Valid Account or Does not have Admin user type", "Owner Account");
        errorObjects.add(errorOBject);
    }
    Validator v1 = new Validator(request);
    v1.addValidation("name", Validator.NO_BLANKS);
    HashMap vError1 = v1.validate();
    if (!vError1.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "This field cannot be blank.", "Name");
        errorObjects.add(errorOBject);
    }
    if (name != null) {
        Validator v2 = new Validator(request);
        v2.addValidation("name", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 2000);
        HashMap vError2 = v2.validate();
        if (!vError2.isEmpty()) {
            ErrorObject errorOBject = createErrorObject("Event Definition Object", "The Length Should not exceed 2000.", "Name");
            errorObjects.add(errorOBject);
        }
    }
    if (description != null) {
        Validator v3 = new Validator(request);
        v3.addValidation("description", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 2000);
        HashMap vError3 = v3.validate();
        if (!vError3.isEmpty()) {
            ErrorObject errorOBject = createErrorObject("Event Definition Object", "The Length Should not exceed 2000.", "Description");
            errorObjects.add(errorOBject);
        }
    }
    if (category != null) {
        Validator v4 = new Validator(request);
        v4.addValidation("category", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 2000);
        HashMap vError4 = v4.validate();
        if (!vError4.isEmpty()) {
            ErrorObject errorOBject = createErrorObject("Event Definition Object", "The Length Should not exceed 2000.", "Category");
            errorObjects.add(errorOBject);
        }
    }
    Validator v5 = new Validator(request);
    v5.addValidation("repeating", Validator.NO_BLANKS);
    HashMap vError5 = v5.validate();
    if (!vError5.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "This field cannot be blank.", "Repeating");
        errorObjects.add(errorOBject);
    }
    Validator v6 = new Validator(request);
    v6.addValidation("type", Validator.NO_BLANKS);
    HashMap vError6 = v6.validate();
    if (!vError6.isEmpty()) {
        ErrorObject errorOBject = createErrorObject("Event Definition Object", "This field cannot be blank.", "Type");
        errorObjects.add(errorOBject);
    }
    eventDefinitionDTO.setErrors(errorObjects);
    if (errorObjects != null && errorObjects.size() != 0) {
        eventDefinitionDTO.setMessage(validation_failed_message);
        response = new ResponseEntity(eventDefinitionDTO, org.springframework.http.HttpStatus.BAD_REQUEST);
    } else {
        eventBean = buildEventDefBean(name, description, category, type, repeating, ownerUserAccount, parentStudy);
        StudyEventDefinitionBean sedBean = createEventDefn(eventBean, ownerUserAccount);
        eventDefinitionDTO.setEventDefOid(sedBean.getOid());
        eventDefinitionDTO.setMessage(validation_passed_message);
    }
    ResponseSuccessEventDefDTO responseSuccess = new ResponseSuccessEventDefDTO();
    responseSuccess.setMessage(eventDefinitionDTO.getMessage());
    responseSuccess.setEventDefOid(eventDefinitionDTO.getEventDefOid());
    responseSuccess.setName(eventDefinitionDTO.getName());
    response = new ResponseEntity(responseSuccess, org.springframework.http.HttpStatus.OK);
    return response;
}

Example 25 with Validator

use of org.akaza.openclinica.control.form.Validator in project OpenClinica by OpenClinica.

the class TriggerService method validateForm.

public HashMap validateForm(FormProcessor fp, HttpServletRequest request, String[] triggerNames, String properName) {
    Validator v = new Validator(request);
    v.addValidation(JOB_NAME, Validator.NO_BLANKS);
    // need to be unique too
    v.addValidation(JOB_DESC, Validator.NO_BLANKS);
    v.addValidation(EMAIL, Validator.IS_A_EMAIL);
    v.addValidation(PERIOD, Validator.NO_BLANKS);
    v.addValidation(DATE_START_JOB + "Date", Validator.IS_A_DATE);
    // v.addValidation(DATE_START_JOB + "Date", new Date(), Validator.DATE_IS_AFTER_OR_EQUAL);
    // TODO job names will have to be unique, tbh
    String tab = fp.getString(TAB);
    String cdisc = fp.getString(CDISC);
    String cdisc12 = fp.getString(ExampleSpringJob.CDISC12);
    String cdisc13 = fp.getString(ExampleSpringJob.CDISC13);
    String cdisc13oc = fp.getString(ExampleSpringJob.CDISC13OC);
    String spss = fp.getString(SPSS);
    Date jobDate = fp.getDateTime(DATE_START_JOB);
    HashMap errors = v.validate();
    if ((tab == "") && (cdisc == "") && (spss == "") && (cdisc12 == "") && (cdisc13 == "") && (cdisc13oc == "")) {
        // throw an error here, at least one should work
        // errors.put(TAB, "Error Message - Pick one of the below");
        v.addError(errors, TAB, "Please pick at least one of the below.");
    }
    for (String triggerName : triggerNames) {
        if (triggerName.equals(fp.getString(JOB_NAME)) && (!triggerName.equals(properName))) {
            v.addError(errors, JOB_NAME, "A job with that name already exists.  Please pick another name.");
        }
    }
    if (jobDate.before(new Date())) {
        v.addError(errors, DATE_START_JOB + "Date", "This date needs to be later than the present time.");
    }
    return errors;
}