Example 1 with DiscrepancyValidator
use of org.akaza.openclinica.control.form.DiscrepancyValidator in project OpenClinica by OpenClinica.
the class AddNewSubjectServlet method processRequest.
// YW >>
/*
* (non-Javadoc)
*
* @see org.akaza.openclinica.control.core.SecureController#processRequest()
*/
@Override
protected void processRequest() throws Exception {
checkStudyLocked(Page.LIST_STUDY_SUBJECTS, respage.getString("current_study_locked"));
checkStudyFrozen(Page.LIST_STUDY_SUBJECTS, respage.getString("current_study_frozen"));
StudySubjectDAO ssd = new StudySubjectDAO(sm.getDataSource());
StudyDAO stdao = new StudyDAO(sm.getDataSource());
StudyGroupClassDAO sgcdao = new StudyGroupClassDAO(sm.getDataSource());
ArrayList classes = new ArrayList();
panel.setStudyInfoShown(false);
FormProcessor fp = new FormProcessor(request);
FormDiscrepancyNotes discNotes;
SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
// TODO l10n for dates? Note that in some places we hard-code the YOB by
// using "01/01/"+yob,
// not exactly supporting i18n...tbh
// YW << update study parameters of current study.
// "collectDob" and "genderRequired" are set as the same as the parent
// study
int parentStudyId = currentStudy.getParentStudyId();
if (parentStudyId <= 0) {
parentStudyId = currentStudy.getId();
classes = sgcdao.findAllActiveByStudy(currentStudy);
} else {
StudyBean parentStudy = (StudyBean) stdao.findByPK(parentStudyId);
classes = sgcdao.findAllActiveByStudy(parentStudy);
}
StudyParameterValueDAO spvdao = new StudyParameterValueDAO(sm.getDataSource());
StudyParameterValueBean parentSPV = spvdao.findByHandleAndStudy(parentStudyId, "collectDob");
currentStudy.getStudyParameterConfig().setCollectDob(parentSPV.getValue());
parentSPV = spvdao.findByHandleAndStudy(parentStudyId, "genderRequired");
currentStudy.getStudyParameterConfig().setGenderRequired(parentSPV.getValue());
// YW >>
// tbh
StudyParameterValueBean checkPersonId = spvdao.findByHandleAndStudy(parentStudyId, "subjectPersonIdRequired");
currentStudy.getStudyParameterConfig().setSubjectPersonIdRequired(checkPersonId.getValue());
if (!fp.isSubmitted()) {
if (fp.getBoolean("instr")) {
session.removeAttribute(FORM_DISCREPANCY_NOTES_NAME);
forwardPage(Page.INSTRUCTIONS_ENROLL_SUBJECT);
} else {
setUpBeans(classes);
Date today = new Date(System.currentTimeMillis());
String todayFormatted = local_df.format(today);
fp.addPresetValue(INPUT_ENROLLMENT_DATE, todayFormatted);
// YW 10-07-2007 <<
String idSetting = "";
if (currentStudy.getParentStudyId() > 0) {
parentSPV = spvdao.findByHandleAndStudy(parentStudyId, "subjectIdGeneration");
currentStudy.getStudyParameterConfig().setSubjectIdGeneration(parentSPV.getValue());
}
idSetting = currentStudy.getStudyParameterConfig().getSubjectIdGeneration();
// YW >>
logger.info("subject id setting :" + idSetting);
// available ID (label) for now
if (idSetting.equals("auto editable") || idSetting.equals("auto non-editable")) {
//Shaoyu Su
// int nextLabel = ssd.findTheGreatestLabel() + 1;
// fp.addPresetValue(INPUT_LABEL, new Integer(nextLabel).toString());
fp.addPresetValue(INPUT_LABEL, resword.getString("id_generated_Save_Add"));
}
setPresetValues(fp.getPresetValues());
discNotes = new FormDiscrepancyNotes();
session.setAttribute(FORM_DISCREPANCY_NOTES_NAME, discNotes);
forwardPage(Page.ADD_NEW_SUBJECT);
}
} else {
// values in database <subject> table for "add existing subject"
if (!fp.getBoolean(EXISTING_SUB_SHOWN)) {
DOB = fp.getString(INPUT_DOB);
YOB = fp.getString(INPUT_YOB);
GENDER = fp.getString(INPUT_GENDER);
}
// YW >>
discNotes = (FormDiscrepancyNotes) session.getAttribute(FORM_DISCREPANCY_NOTES_NAME);
if (discNotes == null) {
discNotes = new FormDiscrepancyNotes();
}
DiscrepancyValidator v = new DiscrepancyValidator(request, discNotes);
v.addValidation(INPUT_LABEL, Validator.NO_BLANKS);
String subIdSetting = currentStudy.getStudyParameterConfig().getSubjectIdGeneration();
if (!subIdSetting.equalsIgnoreCase("auto non-editable") && !subIdSetting.equalsIgnoreCase("auto editable")) {
v.addValidation(INPUT_LABEL, Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 30);
}
if (currentStudy.getStudyParameterConfig().getSubjectPersonIdRequired().equals("required")) {
v.addValidation(INPUT_UNIQUE_IDENTIFIER, Validator.NO_BLANKS);
}
v.addValidation(INPUT_UNIQUE_IDENTIFIER, Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 255);
if (!StringUtils.isBlank(fp.getString(INPUT_SECONDARY_LABEL))) {
v.addValidation(INPUT_SECONDARY_LABEL, Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 30);
}
String dobSetting = currentStudy.getStudyParameterConfig().getCollectDob();
if (dobSetting.equals("1")) {
// date of birth
v.addValidation(INPUT_DOB, Validator.IS_A_DATE);
if (!StringUtils.isBlank(fp.getString("INPUT_DOB"))) {
v.alwaysExecuteLastValidation(INPUT_DOB);
}
v.addValidation(INPUT_DOB, Validator.DATE_IN_PAST);
} else if (dobSetting.equals("2")) {
// year of birth
v.addValidation(INPUT_YOB, Validator.IS_AN_INTEGER);
v.alwaysExecuteLastValidation(INPUT_YOB);
v.addValidation(INPUT_YOB, Validator.COMPARES_TO_STATIC_VALUE, NumericComparisonOperator.GREATER_THAN_OR_EQUAL_TO, 1000);
// get today's year
Date today = new Date();
Calendar c = Calendar.getInstance();
c.setTime(today);
int currentYear = c.get(Calendar.YEAR);
v.addValidation(INPUT_YOB, Validator.COMPARES_TO_STATIC_VALUE, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, currentYear);
} else {
// DOB not used, added tbh 102007
logger.info("should read this only if DOB not used");
}
ArrayList acceptableGenders = new ArrayList();
acceptableGenders.add("m");
acceptableGenders.add("f");
if (!currentStudy.getStudyParameterConfig().getGenderRequired().equals("false")) {
v.addValidation(INPUT_GENDER, Validator.IS_IN_SET, acceptableGenders);
}
v.addValidation(INPUT_ENROLLMENT_DATE, Validator.IS_A_DATE);
v.alwaysExecuteLastValidation(INPUT_ENROLLMENT_DATE);
v.addValidation(INPUT_ENROLLMENT_DATE, Validator.DATE_IN_PAST);
boolean locationError = false;
if (fp.getBoolean("addWithEvent")) {
v.addValidation(INPUT_EVENT_START_DATE, Validator.IS_A_DATE);
v.alwaysExecuteLastValidation(INPUT_EVENT_START_DATE);
if (currentStudy.getStudyParameterConfig().getEventLocationRequired().equalsIgnoreCase("required")) {
v.addValidation("location", Validator.NO_BLANKS);
locationError = true;
}
}
HashMap errors = v.validate();
SubjectDAO sdao = new SubjectDAO(sm.getDataSource());
// global
String uniqueIdentifier = fp.getString(INPUT_UNIQUE_IDENTIFIER);
// Id
SubjectBean subjectWithSameId = new SubjectBean();
SubjectBean subjectWithSameIdInParent = new SubjectBean();
boolean showExistingRecord = false;
if (!uniqueIdentifier.equals("")) {
boolean subjectWithSameIdInCurrentStudyTree = false;
// checks whether there is a subject with same id inside current
// study/site
subjectWithSameId = sdao.findByUniqueIdentifierAndStudy(uniqueIdentifier, currentStudy.getId());
// tbh
if (subjectWithSameId.isActive()) {
// ||
// subjectWithSameIdInParent.isActive())
// {
Validator.addError(errors, INPUT_UNIQUE_IDENTIFIER, resexception.getString("subject_with_person_ID") + " " + uniqueIdentifier + " " + resexception.getString("is_already_enrolled_in_this_study"));
subjectWithSameIdInCurrentStudyTree = true;
logger.info("just added unique id in study tree");
} else {
// checks whether there is a subject with same id inside
// sites of
// current study
subjectWithSameId = sdao.findByUniqueIdentifierAndParentStudy(uniqueIdentifier, currentStudy.getId());
if (subjectWithSameId.isActive()) {
StudySubjectBean ssub = ssd.findBySubjectIdAndStudy(subjectWithSameId.getId(), currentStudy);
StudyBean site = (StudyBean) stdao.findByPK(ssub.getStudyId());
Validator.addError(errors, INPUT_UNIQUE_IDENTIFIER, resexception.getString("this_subject_person_ID") + " " + uniqueIdentifier + resexception.getString("has_already_enrolled_site") + site.getName() + resexception.getString("of_current_study_need_to_move") + resexception.getString("please_have_user_manage_privileges"));
subjectWithSameIdInCurrentStudyTree = true;
} else {
// check whether there is a subject with same id in the
// parent study
subjectWithSameId = sdao.findByUniqueIdentifierAndStudy(uniqueIdentifier, currentStudy.getParentStudyId());
if (subjectWithSameId.isActive()) {
Validator.addError(errors, INPUT_UNIQUE_IDENTIFIER, resexception.getString("this_subject_with_person_ID") + " " + uniqueIdentifier + resexception.getString("has_already_enrolled_parent_study"));
subjectWithSameIdInCurrentStudyTree = true;
} else {
// YW 11-26-2007 << check whether there is a subject
// with the same id in other sites of the same study
subjectWithSameId = sdao.findByUniqueIdentifierAndParentStudy(uniqueIdentifier, currentStudy.getParentStudyId());
if (subjectWithSameId.isActive()) {
Validator.addError(errors, INPUT_UNIQUE_IDENTIFIER, resexception.getString("this_subject_with_person_ID") + " " + uniqueIdentifier + resexception.getString("has_already_enrolled_site_study"));
subjectWithSameIdInCurrentStudyTree = true;
}
// YW >>
}
}
}
if (!subjectWithSameIdInCurrentStudyTree) {
subjectWithSameId = sdao.findByUniqueIdentifier(uniqueIdentifier);
// found subject with same id in other study
if (subjectWithSameId.isActive()) {
showExistingRecord = true;
}
}
}
// end of the block if(!uniqueIdentifier.equals(""))
String label = fp.getString(INPUT_LABEL);
String personId = fp.getString(INPUT_UNIQUE_IDENTIFIER);
String secondaryLable = fp.getString(INPUT_SECONDARY_LABEL);
// then Study Subject ID should be created when db row is inserted.
if (label.contains("<") || label.contains(">")) {
Validator.addError(errors, INPUT_LABEL, resexception.getString("study_subject_id_can_not_contain_html_lessthan_or_greaterthan_elements"));
}
if (secondaryLable.contains("<") || secondaryLable.contains(">")) {
Validator.addError(errors, INPUT_SECONDARY_LABEL, resexception.getString("secondary_id_can_not_contain_html_lessthan_or_greaterthan_elements"));
}
if (personId.contains("<") || personId.contains(">")) {
Validator.addError(errors, INPUT_UNIQUE_IDENTIFIER, resexception.getString("person_id_can_not_contain_html_lessthan_or_greaterthan_elements"));
}
if (!label.equalsIgnoreCase(resword.getString("id_generated_Save_Add"))) {
StudySubjectBean subjectWithSameLabel = ssd.findByLabelAndStudy(label, currentStudy);
StudySubjectBean subjectWithSameLabelInParent = new StudySubjectBean();
// tbh
if (currentStudy.getParentStudyId() > 0) {
// <
subjectWithSameLabelInParent = ssd.findSameByLabelAndStudy(label, currentStudy.getParentStudyId(), 0);
// --
// blank
// id
// since
// the
// ss
// hasn't
// been
// created
// yet,
// tbh
}
// tbh
if (subjectWithSameLabel.isActive() || subjectWithSameLabelInParent.isActive()) {
Validator.addError(errors, INPUT_LABEL, resexception.getString("another_assigned_this_ID_choose_unique"));
}
}
if (!classes.isEmpty()) {
for (int i = 0; i < classes.size(); i++) {
StudyGroupClassBean sgc = (StudyGroupClassBean) classes.get(i);
int groupId = fp.getInt("studyGroupId" + i);
String notes = fp.getString("notes" + i);
if ("Required".equals(sgc.getSubjectAssignment()) && groupId == 0) {
Validator.addError(errors, "studyGroupId" + i, resexception.getString("group_class_is_required"));
}
if (notes.trim().length() > 255) {
Validator.addError(errors, "notes" + i, resexception.getString("notes_cannot_longer_255"));
}
sgc.setStudyGroupId(groupId);
sgc.setGroupNotes(notes);
}
}
if (!errors.isEmpty()) {
addPageMessage(respage.getString("there_were_some_errors_submission"));
if (locationError) {
addPageMessage(respage.getString("location_blank_error"));
}
setInputMessages(errors);
fp.addPresetValue(INPUT_DOB, fp.getString(INPUT_DOB));
fp.addPresetValue(INPUT_YOB, fp.getString(INPUT_YOB));
fp.addPresetValue(INPUT_GENDER, fp.getString(INPUT_GENDER));
fp.addPresetValue(INPUT_UNIQUE_IDENTIFIER, uniqueIdentifier);
fp.addPresetValue(INPUT_LABEL, label);
fp.addPresetValue(INPUT_SECONDARY_LABEL, fp.getString(INPUT_SECONDARY_LABEL));
fp.addPresetValue(INPUT_ENROLLMENT_DATE, fp.getString(INPUT_ENROLLMENT_DATE));
fp.addPresetValue(INPUT_EVENT_START_DATE, fp.getString(INPUT_EVENT_START_DATE));
fp.addPresetValue(STUDY_EVENT_DEFINITION, fp.getInt(STUDY_EVENT_DEFINITION));
fp.addPresetValue(LOCATION, fp.getString(LOCATION));
fp.addPresetValue(EDIT_DOB, fp.getString(EDIT_DOB));
setPresetValues(fp.getPresetValues());
setUpBeans(classes);
boolean existingSubShown = fp.getBoolean(EXISTING_SUB_SHOWN);
if (!existingSubShown) {
Object isSubjectOverlay = fp.getRequest().getParameter("subjectOverlay");
if (isSubjectOverlay != null) {
int eventId = fp.getInt("studyEventDefinition");
if (eventId < 1) {
Validator.addError(errors, STUDY_EVENT_DEFINITION, resexception.getString("input_not_acceptable_option"));
}
String location = fp.getString(LOCATION);
if (location == null && location.length() == 0) {
Validator.addError(errors, LOCATION, resexception.getString("field_not_blank"));
}
request.setAttribute("showOverlay", true);
forwardPage(Page.LIST_STUDY_SUBJECTS_SERVLET);
} else {
forwardPage(Page.ADD_NEW_SUBJECT);
}
} else {
forwardPage(Page.ADD_EXISTING_SUBJECT);
}
} else {
// no errors
StudySubjectBean studySubject = new StudySubjectBean();
SubjectBean subject = new SubjectBean();
boolean existingSubShown = fp.getBoolean(EXISTING_SUB_SHOWN);
if (showExistingRecord && !existingSubShown) {
needUpdate = false;
subject = subjectWithSameId;
Calendar cal = Calendar.getInstance();
int year = 0;
if (subject.getDateOfBirth() != null) {
cal.setTime(subject.getDateOfBirth());
year = cal.get(Calendar.YEAR);
fp.addPresetValue(INPUT_DOB, local_df.format(subject.getDateOfBirth()));
} else {
fp.addPresetValue(INPUT_DOB, "");
}
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("1") && !subject.isDobCollected()) {
// fp.addPresetValue(EDIT_DOB, "yes");
fp.addPresetValue(INPUT_DOB, fp.getString(INPUT_DOB));
}
// YW << it has been taken off to solve bug0001125
/*
* else { fp.addPresetValue(INPUT_DOB, ""); }
*/
// YW >>
fp.addPresetValue(INPUT_YOB, String.valueOf(year));
if (!currentStudy.getStudyParameterConfig().getGenderRequired().equals("false")) {
fp.addPresetValue(INPUT_GENDER, subject.getGender() + "");
} else {
fp.addPresetValue(INPUT_GENDER, "");
}
// Shaoyu Su: delay setting INPUT_LABEL field
if (!label.equalsIgnoreCase(resword.getString("id_generated_Save_Add"))) {
fp.addPresetValue(INPUT_LABEL, label);
}
fp.addPresetValue(INPUT_SECONDARY_LABEL, fp.getString(INPUT_SECONDARY_LABEL));
fp.addPresetValue(INPUT_ENROLLMENT_DATE, fp.getString(INPUT_ENROLLMENT_DATE));
fp.addPresetValue(INPUT_EVENT_START_DATE, fp.getString(INPUT_EVENT_START_DATE));
// YW >>
fp.addPresetValue(INPUT_UNIQUE_IDENTIFIER, subject.getUniqueIdentifier());
setPresetValues(fp.getPresetValues());
setUpBeans(classes);
// YW <<
int warningCount = 0;
if (currentStudy.getStudyParameterConfig().getGenderRequired().equalsIgnoreCase("true")) {
if (String.valueOf(subjectWithSameId.getGender()).equals(" ")) {
fp.addPresetValue(G_WARNING, "emptytrue");
fp.addPresetValue(INPUT_GENDER, GENDER);
needUpdate = true;
updateSubject = subjectWithSameId;
updateSubject.setGender(GENDER.toCharArray()[0]);
warningCount++;
} else if (!String.valueOf(subjectWithSameId.getGender()).equals(GENDER)) {
fp.addPresetValue(G_WARNING, "true");
warningCount++;
} else {
fp.addPresetValue(G_WARNING, "false");
}
} else {
fp.addPresetValue(G_WARNING, "false");
}
// Current study required DOB
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("1")) {
// date-of-birth in subject table is not completed
if (subjectWithSameId.isDobCollected() == false) {
needUpdate = true;
updateSubject = subjectWithSameId;
updateSubject.setDobCollected(true);
if (subjectWithSameId.getDateOfBirth() == null) {
fp.addPresetValue(INPUT_DOB, DOB);
updateSubject.setDateOfBirth(new Date(DOB));
} else {
String y = String.valueOf(subjectWithSameId.getDateOfBirth()).split("\\-")[0];
String[] d = DOB.split("\\/");
// if year-of-birth in subject table
if (!y.equals("0001")) {
// year, use year-of-birth
if (!y.equals(d[2])) {
fp.addPresetValue(D_WARNING, "dobYearWrong");
fp.addPresetValue(INPUT_DOB, d[0] + "/" + d[1] + "/" + y);
updateSubject.setDateOfBirth(sdf.parse(d[0] + "/" + d[1] + "/" + y));
} else {
fp.addPresetValue(D_WARNING, "dobUsed");
fp.addPresetValue(INPUT_DOB, DOB);
updateSubject.setDateOfBirth(sdf.parse(DOB));
}
} else // date-of-birth is not required in subject
// table
{
fp.addPresetValue(D_WARNING, "emptyD");
fp.addPresetValue(INPUT_DOB, DOB);
updateSubject.setDateOfBirth(sdf.parse(DOB));
}
}
warningCount++;
} else // date-of-birth in subject table but doesn't match DOB
if (!local_df.format(subjectWithSameId.getDateOfBirth()).toString().equals(DOB)) {
// System.out.println("comparing " +
// local_df.format(
// subjectWithSameId.getDateOfBirth()).toString());
fp.addPresetValue(D_WARNING, "currentDOBWrong");
warningCount++;
} else // date-of-birth in subject table matchs DOB
{
fp.addPresetValue(D_WARNING, "false");
}
} else // current Study require YOB
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("2")) {
String y = String.valueOf(subjectWithSameId.getDateOfBirth()).split("\\-")[0];
// year of date-of-birth in subject table is avaible
if (!y.equals("0001")) {
// year in subject table doesn't match YOB,
if (!y.equals(YOB)) {
fp.addPresetValue(Y_WARNING, "yobWrong");
warningCount++;
} else // year in subject table matches YOB
{
fp.addPresetValue(Y_WARNING, "false");
}
} else // year of date-of-birth in the subject talbe is not
// availbe, YOB is used
{
needUpdate = true;
updateSubject = subjectWithSameId;
fp.addPresetValue(Y_WARNING, "yearEmpty");
fp.addPresetValue(INPUT_YOB, YOB);
updateSubject.setDateOfBirth(sdf.parse("01/01/" + YOB));
warningCount++;
}
} else // current study require no DOB, there is no need to check
// date-of-birth in the subject table
{
fp.addPresetValue(Y_WARNING, "false");
}
if (warningCount > 0) {
warningCount = 0;
forwardPage(Page.ADD_EXISTING_SUBJECT);
return;
}
// forwardPage(Page.ADD_EXISTING_SUBJECT);
// return;
// YW >>
}
// to be inserted into both <subject> and <studysubject> tables
if (!showExistingRecord) {
// YW >>
if (!StringUtil.isBlank(fp.getString(INPUT_GENDER))) {
subject.setGender(fp.getString(INPUT_GENDER).charAt(0));
} else {
subject.setGender(' ');
}
subject.setUniqueIdentifier(uniqueIdentifier);
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("1")) {
if (!StringUtil.isBlank(fp.getString(INPUT_DOB))) {
subject.setDateOfBirth(fp.getDate(INPUT_DOB));
subject.setDobCollected(true);
} else {
subject.setDateOfBirth(null);
subject.setDobCollected(false);
}
} else if (currentStudy.getStudyParameterConfig().getCollectDob().equals("2")) {
// generate a fake birthday in 01/01/YYYY format, only
// the year is
// valid
// added the "2" to make sure that 'not used' is kept to
// null, tbh 102007
subject.setDobCollected(false);
int yob = fp.getInt(INPUT_YOB);
Date fakeDate = new Date("01/01/" + yob);
// Calendar fakeCal = Calendar.getInstance();
// fakeCal.set(Calendar.YEAR, yob);
// fakeCal.set(Calendar.MONTH, 1);
// fakeCal.set(Calendar.DAY_OF_MONTH, 1);
// String dobString = "01/01/" + yob;
String dobString = local_df.format(fakeDate);
try {
Date fakeDOB = local_df.parse(dobString);
subject.setDateOfBirth(fakeDOB);
} catch (ParseException pe) {
subject.setDateOfBirth(new Date());
addPageMessage(respage.getString("problem_happened_saving_year"));
}
}
subject.setStatus(Status.AVAILABLE);
subject.setOwner(ub);
subject = sdao.create(subject);
if (!subject.isActive()) {
throw new OpenClinicaException(resexception.getString("could_not_create_subject"), "3");
}
// YW << for showExistingRecord && existingSubShown,
// If input value(s) is(are) different from database,
// warning will be shown.
// If value(s) in database is(are) empty, entered value(s)
// could be used;
// Otherwise, value(s) in database will be used.
// For date-of-birth, if database only has year-of-birth,
// the year in database will be used for year part
} else if (existingSubShown) {
if (!needUpdate) {
subject = subjectWithSameId;
} else {
updateSubject.setUpdater(ub);
updateSubject = (SubjectBean) sdao.update(updateSubject);
if (!updateSubject.isActive()) {
throw new OpenClinicaException("Could not create subject.", "5");
}
subject = updateSubject;
needUpdate = false;
}
}
// YW >>
// enroll the subject in the active study
studySubject.setSubjectId(subject.getId());
studySubject.setStudyId(currentStudy.getId());
studySubject.setLabel(fp.getString(INPUT_LABEL));
studySubject.setSecondaryLabel(fp.getString(INPUT_SECONDARY_LABEL));
studySubject.setStatus(Status.AVAILABLE);
studySubject.setEnrollmentDate(fp.getDate(INPUT_ENROLLMENT_DATE));
if (fp.getBoolean("addWithEvent")) {
studySubject.setEventStartDate(fp.getDate(INPUT_EVENT_START_DATE));
}
studySubject.setOwner(ub);
// Shaoyu Su: prevent same label ("Study Subject ID")
if (fp.getString(INPUT_LABEL).equalsIgnoreCase(resword.getString("id_generated_Save_Add"))) {
synchronized (simpleLockObj) {
int nextLabel = ssd.findTheGreatestLabel() + 1;
studySubject.setLabel(nextLabel + "");
studySubject = ssd.createWithoutGroup(studySubject);
if (showExistingRecord && !existingSubShown) {
fp.addPresetValue(INPUT_LABEL, label);
}
}
} else {
studySubject = ssd.createWithoutGroup(studySubject);
}
if (!classes.isEmpty() && studySubject.isActive()) {
SubjectGroupMapDAO sgmdao = new SubjectGroupMapDAO(sm.getDataSource());
for (int i = 0; i < classes.size(); i++) {
StudyGroupClassBean group = (StudyGroupClassBean) classes.get(i);
int studyGroupId = group.getStudyGroupId();
String notes = group.getGroupNotes();
SubjectGroupMapBean map = new SubjectGroupMapBean();
map.setNotes(group.getGroupNotes());
map.setStatus(Status.AVAILABLE);
map.setStudyGroupId(group.getStudyGroupId());
map.setStudySubjectId(studySubject.getId());
map.setStudyGroupClassId(group.getId());
map.setOwner(ub);
if (map.getStudyGroupId() > 0) {
sgmdao.create(map);
}
}
}
if (!studySubject.isActive()) {
throw new OpenClinicaException(resexception.getString("could_not_create_study_subject"), "4");
}
// save discrepancy notes into DB
FormDiscrepancyNotes fdn = (FormDiscrepancyNotes) session.getAttribute(FORM_DISCREPANCY_NOTES_NAME);
DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(sm.getDataSource());
String[] subjectFields = { INPUT_DOB, INPUT_YOB, INPUT_GENDER };
for (String element : subjectFields) {
saveFieldNotes(element, fdn, dndao, subject.getId(), "subject", currentStudy);
}
saveFieldNotes(INPUT_ENROLLMENT_DATE, fdn, dndao, studySubject.getId(), "studySub", currentStudy);
request.removeAttribute(FormProcessor.FIELD_SUBMITTED);
request.setAttribute(CreateNewStudyEventServlet.INPUT_STUDY_SUBJECT, studySubject);
request.setAttribute(CreateNewStudyEventServlet.INPUT_REQUEST_STUDY_SUBJECT, "no");
request.setAttribute(FormProcessor.FIELD_SUBMITTED, "0");
addPageMessage(respage.getString("subject_with_unique_identifier") + studySubject.getLabel() + respage.getString("X_was_created_succesfully"));
if (fp.getBoolean("addWithEvent")) {
createStudyEvent(fp, studySubject);
// YW <<
request.setAttribute("id", studySubject.getId() + "");
// String url= response.encodeRedirectURL("ViewStudySubject?id=" + studySubject.getId());
// response.sendRedirect(url);
forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
// + studySubject.getId()));
return;
}
String submitEvent = fp.getString(SUBMIT_EVENT_BUTTON);
String submitEnroll = fp.getString(SUBMIT_ENROLL_BUTTON);
String submitDone = fp.getString(SUBMIT_DONE_BUTTON);
session.removeAttribute(FORM_DISCREPANCY_NOTES_NAME);
if (!StringUtil.isBlank(submitEvent)) {
forwardPage(Page.CREATE_NEW_STUDY_EVENT_SERVLET);
} else if (!StringUtil.isBlank(submitEnroll)) {
// NEW MANTIS ISSUE 4770
setUpBeans(classes);
Date today = new Date(System.currentTimeMillis());
String todayFormatted = local_df.format(today);
fp.addPresetValue(INPUT_ENROLLMENT_DATE, todayFormatted);
// YW 10-07-2007 <<
String idSetting = "";
if (currentStudy.getParentStudyId() > 0) {
parentSPV = spvdao.findByHandleAndStudy(parentStudyId, "subjectIdGeneration");
currentStudy.getStudyParameterConfig().setSubjectIdGeneration(parentSPV.getValue());
}
idSetting = currentStudy.getStudyParameterConfig().getSubjectIdGeneration();
// YW >>
logger.info("subject id setting :" + idSetting);
// set up auto study subject id
if (idSetting.equals("auto editable") || idSetting.equals("auto non-editable")) {
//Shaoyu Su
//int nextLabel = ssd.findTheGreatestLabel() + 1;
//fp.addPresetValue(INPUT_LABEL, new Integer(nextLabel).toString());
fp.addPresetValue(INPUT_LABEL, resword.getString("id_generated_Save_Add"));
}
setPresetValues(fp.getPresetValues());
discNotes = new FormDiscrepancyNotes();
session.setAttribute(FORM_DISCREPANCY_NOTES_NAME, discNotes);
// End of 4770
forwardPage(Page.ADD_NEW_SUBJECT);
} else {
// forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
// forwardPage(Page.SUBMIT_DATA_SERVLET);
request.setAttribute("id", studySubject.getId() + "");
// String url=response.encodeRedirectURL("ViewStudySubject?id=" + studySubject.getId());
// response.sendRedirect(url);
forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
return;
}
}
// end of no error (errors.isEmpty())
}
// end of fp.isSubmitted()
}
Also used :
SubjectGroupMapBean(org.akaza.openclinica.bean.submit.SubjectGroupMapBean)
HashMap(java.util.HashMap)
StudyGroupClassDAO(org.akaza.openclinica.dao.managestudy.StudyGroupClassDAO)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
SubjectDAO(org.akaza.openclinica.dao.submit.SubjectDAO)
ArrayList(java.util.ArrayList)
OpenClinicaException(org.akaza.openclinica.exception.OpenClinicaException)
StudyParameterValueBean(org.akaza.openclinica.bean.service.StudyParameterValueBean)
StudyGroupClassBean(org.akaza.openclinica.bean.managestudy.StudyGroupClassBean)
StudyDAO(org.akaza.openclinica.dao.managestudy.StudyDAO)
DiscrepancyNoteDAO(org.akaza.openclinica.dao.managestudy.DiscrepancyNoteDAO)
FormDiscrepancyNotes(org.akaza.openclinica.control.form.FormDiscrepancyNotes)
SubjectGroupMapDAO(org.akaza.openclinica.dao.submit.SubjectGroupMapDAO)
FormProcessor(org.akaza.openclinica.control.form.FormProcessor)
StudyBean(org.akaza.openclinica.bean.managestudy.StudyBean)
Calendar(java.util.Calendar)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
Date(java.util.Date)
SubjectBean(org.akaza.openclinica.bean.submit.SubjectBean)
DisplaySubjectBean(org.akaza.openclinica.bean.submit.DisplaySubjectBean)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
DiscrepancyValidator(org.akaza.openclinica.control.form.DiscrepancyValidator)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
ParseException(java.text.ParseException)
StudyParameterValueDAO(org.akaza.openclinica.dao.service.StudyParameterValueDAO)
SimpleDateFormat(java.text.SimpleDateFormat)
Example 2 with DiscrepancyValidator
use of org.akaza.openclinica.control.form.DiscrepancyValidator in project OpenClinica by OpenClinica.
the class DataEntryServlet method processRequest.
@Override
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//JN:The following were the the global variables, moved as local.
locale = LocaleResolver.getLocale(request);
EventCRFBean ecb = (EventCRFBean) request.getAttribute(INPUT_EVENT_CRF);
SectionBean sb = (SectionBean) request.getAttribute(SECTION_BEAN);
ItemDataDAO iddao = new ItemDataDAO(getDataSource(), locale);
HttpSession session = request.getSession();
StudyBean currentStudy = (StudyBean) session.getAttribute("study");
StudyUserRoleBean currentRole = (StudyUserRoleBean) session.getAttribute("userRole");
SectionDAO sdao = new SectionDAO(getDataSource());
/**
* Determines whether the form was submitted. Calculated once in processRequest. The reason we don't use the normal means to determine if the form was
* submitted (ie FormProcessor.isSubmitted) is because when we use forwardPage, Java confuses the inputs from the just-processed form with the inputs for
* the forwarded-to page. This is a problem since frequently we're forwarding from one (submitted) section to the next (unsubmitted) section. If we use the
* normal means, Java will always think that the unsubmitted section is, in fact, submitted. This member is guaranteed to be calculated before
* shouldLoadDBValues() is called.
*/
boolean isSubmitted = false;
boolean hasGroup = false;
EventCRFDAO ecdao = null;
FormProcessor fp = new FormProcessor(request);
logMe("Enterting DataEntry Servlet" + System.currentTimeMillis());
EventDefinitionCRFDAO edcdao = new EventDefinitionCRFDAO(getDataSource());
FormDiscrepancyNotes discNotes;
panel.setStudyInfoShown(false);
String age = "";
UserAccountBean ub = (UserAccountBean) request.getSession().getAttribute(USER_BEAN_NAME);
String instantAtt = CV_INSTANT_META + ecb.getCRFVersionId();
//for 11958: repeating groups rows appear if validation returns to the same section
int isFirstTimeOnSection = fp.getInt("isFirstTimeOnSection");
request.setAttribute("isFirstTimeOnSection", isFirstTimeOnSection + "");
if (getCrfLocker().isLocked(ecb.getId())) {
int userId = getCrfLocker().getLockOwner(ecb.getId());
UserAccountDAO udao = new UserAccountDAO(getDataSource());
UserAccountBean ubean = (UserAccountBean) udao.findByPK(userId);
if (ubean.getId() != ub.getId()) {
addPageMessage(resword.getString("CRF_unavailable") + " " + ubean.getName() + " " + resword.getString("Currently_entering_data") + " " + resword.getString("Leave_the_CRF"), request);
forwardPage(Page.LIST_STUDY_SUBJECTS_SERVLET, request, response);
}
} else {
getCrfLocker().lock(ecb.getId(), ub.getId());
}
if (!ecb.isActive()) {
throw new InconsistentStateException(Page.LIST_STUDY_SUBJECTS_SERVLET, resexception.getString("event_not_exists"));
}
logMe("Enterting DataEntry Get the status/number of item discrepancy notes" + System.currentTimeMillis());
// Get the status/number of item discrepancy notes
DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(getDataSource());
ArrayList<DiscrepancyNoteBean> allNotes = new ArrayList<DiscrepancyNoteBean>();
List<DiscrepancyNoteBean> eventCrfNotes = new ArrayList<DiscrepancyNoteBean>();
List<DiscrepancyNoteThread> noteThreads = new ArrayList<DiscrepancyNoteThread>();
// BWP: this try block is not necessary try {
dndao = new DiscrepancyNoteDAO(getDataSource());
allNotes = dndao.findAllTopNotesByEventCRF(ecb.getId());
eventCrfNotes = dndao.findOnlyParentEventCRFDNotesFromEventCRF(ecb);
if (!eventCrfNotes.isEmpty()) {
allNotes.addAll(eventCrfNotes);
}
logMe("Entering DataEntry Create disc note threads out of the various notes" + System.currentTimeMillis());
// Create disc note threads out of the various notes
DiscrepancyNoteUtil dNoteUtil = new DiscrepancyNoteUtil();
noteThreads = dNoteUtil.createThreadsOfParents(allNotes, getDataSource(), currentStudy, null, -1, true);
// variables that provide values for the CRF discrepancy note header
int updatedNum = 0;
int openNum = 0;
int closedNum = 0;
int resolvedNum = 0;
int notAppNum = 0;
DiscrepancyNoteBean tempBean;
for (DiscrepancyNoteThread dnThread : noteThreads) {
/*
* 3014: do not count parent beans, only the last child disc note of the thread.
*/
tempBean = dnThread.getLinkedNoteList().getLast();
if (tempBean != null) {
if (ResolutionStatus.UPDATED.equals(tempBean.getResStatus())) {
updatedNum++;
} else if (ResolutionStatus.OPEN.equals(tempBean.getResStatus())) {
openNum++;
} else if (ResolutionStatus.CLOSED.equals(tempBean.getResStatus())) {
// if (dn.getParentDnId() > 0){
closedNum++;
// }
} else if (ResolutionStatus.RESOLVED.equals(tempBean.getResStatus())) {
// if (dn.getParentDnId() > 0){
resolvedNum++;
// }
} else if (ResolutionStatus.NOT_APPLICABLE.equals(tempBean.getResStatus())) {
notAppNum++;
}
}
}
logMe("Entering DataEntry Create disc note threads out of the various notes DONE" + System.currentTimeMillis());
request.setAttribute("updatedNum", updatedNum + "");
request.setAttribute("openNum", openNum + "");
request.setAttribute("closedNum", closedNum + "");
request.setAttribute("resolvedNum", resolvedNum + "");
request.setAttribute("notAppNum", notAppNum + "");
String fromViewNotes = fp.getString("fromViewNotes");
if (fromViewNotes != null && "1".equals(fromViewNotes)) {
request.setAttribute("fromViewNotes", fromViewNotes);
}
logMe("Entering Create studySubjDao.. ++++stuff" + System.currentTimeMillis());
StudySubjectDAO ssdao = new StudySubjectDAO(getDataSource());
StudySubjectBean ssb = (StudySubjectBean) ssdao.findByPK(ecb.getStudySubjectId());
// YW 11-07-2007, data entry could not be performed if its study subject
// has been removed.
// Notice: ViewSectionDataEntryServelet, ViewSectionDataEntryPreview,
// PrintCRFServlet and PrintDataEntryServlet, have theirs own
// processRequest
Status s = ssb.getStatus();
if ("removed".equalsIgnoreCase(s.getName()) || "auto-removed".equalsIgnoreCase(s.getName())) {
addPageMessage(respage.getString("you_may_not_perform_data_entry_on_a_CRF") + respage.getString("study_subject_has_been_deleted"), request);
request.setAttribute("id", new Integer(ecb.getStudySubjectId()).toString());
session.removeAttribute(instantAtt);
forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET, request, response);
}
// YW >>
HashMap<String, String> newUploadedFiles = (HashMap<String, String>) session.getAttribute("newUploadedFiles");
if (newUploadedFiles == null) {
newUploadedFiles = new HashMap<String, String>();
}
request.setAttribute("newUploadedFiles", newUploadedFiles);
if (!fp.getString("exitTo").equals("")) {
request.setAttribute("exitTo", fp.getString("exitTo"));
}
//some EVENT CRF CHECK
logMe("Entering some EVENT CRF CHECK" + System.currentTimeMillis());
if (!fp.getString(GO_EXIT).equals("")) {
session.removeAttribute(GROUP_HAS_DATA);
session.removeAttribute("to_create_crf");
session.removeAttribute("mayProcessUploading");
//Removing the user and EventCRF from the locked CRF List
if (getCrfLocker().isLocked(ecb.getId()) && getCrfLocker().getLockOwner(ecb.getId()) == ub.getId())
getCrfLocker().unlock(ecb.getId());
if (newUploadedFiles.size() > 0) {
if (this.unloadFiles(newUploadedFiles)) {
} else {
String missed = "";
Iterator iter = newUploadedFiles.keySet().iterator();
while (iter.hasNext()) {
missed += " " + newUploadedFiles.get(iter.next());
}
addPageMessage(respage.getString("uploaded_files_not_deleted_or_not_exist") + ": " + missed, request);
}
}
session.removeAttribute("newUploadedFiles");
addPageMessage(respage.getString("exit_without_saving"), request);
// another servlet
if (fromViewNotes != null && "1".equals(fromViewNotes)) {
String viewNotesURL = (String) session.getAttribute("viewNotesURL");
if (viewNotesURL != null && viewNotesURL.length() > 0) {
response.sendRedirect(response.encodeRedirectURL(viewNotesURL));
}
return;
}
String fromResolvingNotes = fp.getString("fromResolvingNotes", true);
String winLocation = (String) session.getAttribute(ViewNotesServlet.WIN_LOCATION);
session.removeAttribute(instantAtt);
if (!StringUtil.isBlank(fromResolvingNotes) && !StringUtil.isBlank(winLocation)) {
response.sendRedirect(response.encodeRedirectURL(winLocation));
} else {
if (!fp.getString("exitTo").equals("")) {
response.sendRedirect(response.encodeRedirectURL(fp.getString("exitTo")));
} else
response.sendRedirect(response.encodeRedirectURL("ListStudySubjects"));
}
// forwardPage(Page.SUBMIT_DATA_SERVLET);
return;
}
logMe("Entering some EVENT CRF CHECK DONE" + System.currentTimeMillis());
// checks if the section has items in item group
// for repeating items
// hasGroup = getInputBeans();
hasGroup = checkGroups(fp, ecb);
Boolean b = (Boolean) request.getAttribute(INPUT_IGNORE_PARAMETERS);
isSubmitted = fp.isSubmitted() && b == null;
// variable is used for fetching any null values like "not applicable"
int eventDefinitionCRFId = 0;
if (fp != null) {
eventDefinitionCRFId = fp.getInt("eventDefinitionCRFId");
}
StudyBean study = (StudyBean) session.getAttribute("study");
// constructs the list of items used on UI
// tbh>>
// logger.trace("trying event def crf id: "+eventDefinitionCRFId);
logMe("Entering some EVENT DEF CRF CHECK " + System.currentTimeMillis());
if (eventDefinitionCRFId <= 0) {
// TODO we have to get that id before we can continue
EventDefinitionCRFBean edcBean = edcdao.findByStudyEventIdAndCRFVersionId(study, ecb.getStudyEventId(), ecb.getCRFVersionId());
eventDefinitionCRFId = edcBean.getId();
}
logMe("Entering some EVENT DEF CRF CHECK DONE " + System.currentTimeMillis());
logMe("Entering some Study EVENT DEF CRF CHECK " + System.currentTimeMillis());
StudyEventDAO seDao = new StudyEventDAO(getDataSource());
EventDefinitionCRFBean edcBean = (EventDefinitionCRFBean) edcdao.findByPK(eventDefinitionCRFId);
EventDefinitionCRFBean edcb = (EventDefinitionCRFBean) edcdao.findByPK(eventDefinitionCRFId);
//JN:Putting the event_def_crf_bean in the request attribute.
request.setAttribute(EVENT_DEF_CRF_BEAN, edcb);
StudyEventBean studyEventBean = (StudyEventBean) seDao.findByPK(ecb.getStudyEventId());
edcBean.setId(eventDefinitionCRFId);
StudyEventDefinitionDAO seddao = new StudyEventDefinitionDAO(getDataSource());
StudyEventDefinitionBean studyEventDefinition = (StudyEventDefinitionBean) seddao.findByPK(edcBean.getStudyEventDefinitionId());
CRFVersionDAO cvdao = new CRFVersionDAO(getDataSource());
CRFVersionBean crfVersionBean = (CRFVersionBean) cvdao.findByPK(ecb.getCRFVersionId());
Phase phase2 = Phase.INITIAL_DATA_ENTRY;
if (getServletPage(request).startsWith(Page.DOUBLE_DATA_ENTRY_SERVLET.getFileName())) {
phase2 = Phase.DOUBLE_DATA_ENTRY;
} else if (getServletPage(request).startsWith(Page.ADMIN_EDIT_SERVLET.getFileName())) {
phase2 = Phase.ADMIN_EDITING;
}
logMe("Entering ruleSets::: CreateAndInitializeRuleSet:::" + Thread.currentThread());
logMe("Entering ruleSets::: CreateAndInitializeRuleSet:::" + Thread.currentThread() + "currentStudy?" + currentStudy + "studyEventDefinition" + studyEventDefinition + "crfVersionBean" + crfVersionBean + "studyEventBean" + studyEventBean + "ecb" + ecb);
// List<RuleSetBean> ruleSets = createAndInitializeRuleSet(currentStudy, studyEventDefinition, crfVersionBean, studyEventBean, ecb, true, request, response);
// boolean shouldRunRules = getRuleSetService(request).shouldRunRulesForRuleSets(ruleSets, phase2);
logMe("Entering getDisplayBean:::::Thread::::" + Thread.currentThread());
DisplaySectionBean section = getDisplayBean(hasGroup, false, request, isSubmitted);
//hasSCDItem has been initialized in getDisplayBean() which is online above
VariableSubstitutionHelper.replaceVariables(section, study, ssb, studyEventDefinition, studyEventBean, dataSource);
if (section.getSection().hasSCDItem()) {
SimpleConditionalDisplayService cds0 = (SimpleConditionalDisplayService) SpringServletAccess.getApplicationContext(getServletContext()).getBean("simpleConditionalDisplayService");
section = cds0.initConditionalDisplays(section);
}
logMe("Entering Find out the id of the section's first field " + System.currentTimeMillis());
// 2790: Find out the id of the section's first field
String firstFieldId = getSectionFirstFieldId(section.getSection().getId());
request.setAttribute("formFirstField", firstFieldId);
// logger.trace("now trying event def crf id: "+eventDefinitionCRFId);
// above is necessary to give us null values during DDE
// ironically, this only covers vertical null value result sets
// horizontal ones are covered in FormBeanUtil, tbh 112007
logMe("Entering displayItemWithGroups " + System.currentTimeMillis());
//@pgawade 30-May-2012 Fix for issue 13963 - added an extra parameter 'isSubmitted' to method createItemWithGroups
List<DisplayItemWithGroupBean> displayItemWithGroups = createItemWithGroups(section, hasGroup, eventDefinitionCRFId, request, isSubmitted);
logMe("Entering displayItemWithGroups end " + System.currentTimeMillis());
this.getItemMetadataService().updateGroupDynamicsInSection(displayItemWithGroups, section.getSection().getId(), ecb);
section.setDisplayItemGroups(displayItemWithGroups);
DisplayTableOfContentsBean toc = TableOfContentsServlet.getDisplayBeanWithShownSections(getDataSource(), (DisplayTableOfContentsBean) request.getAttribute(TOC_DISPLAY), (DynamicsMetadataService) SpringServletAccess.getApplicationContext(getServletContext()).getBean("dynamicsMetadataService"));
request.setAttribute(TOC_DISPLAY, toc);
LinkedList<Integer> sectionIdsInToc = TableOfContentsServlet.sectionIdsInToc(toc);
// why do we get previousSec and nextSec here, rather than in
// getDisplayBeans?
// so that we can use them in forwarding the user to the previous/next
// section
// if the validation was successful
logMe("Entering displayItemWithGroups sdao.findPrevious " + System.currentTimeMillis());
int sIndex = TableOfContentsServlet.sectionIndexInToc(section.getSection(), toc, sectionIdsInToc);
SectionBean previousSec = this.prevSection(section.getSection(), ecb, toc, sIndex);
logMe("Entering displayItemWithGroups sdao.findPrevious end " + System.currentTimeMillis());
SectionBean nextSec = this.nextSection(section.getSection(), ecb, toc, sIndex);
section.setFirstSection(!previousSec.isActive());
section.setLastSection(!nextSec.isActive());
// this is for generating side info panel
// and the information panel under the Title
SubjectDAO subjectDao = new SubjectDAO(getDataSource());
StudyDAO studydao = new StudyDAO(getDataSource());
SubjectBean subject = (SubjectBean) subjectDao.findByPK(ssb.getSubjectId());
// Get the study then the parent study
logMe("Entering Get the study then the parent study " + System.currentTimeMillis());
if (study.getParentStudyId() > 0) {
// this is a site,find parent
StudyBean parentStudy = (StudyBean) studydao.findByPK(study.getParentStudyId());
request.setAttribute("studyTitle", parentStudy.getName());
request.setAttribute("siteTitle", study.getName());
} else {
request.setAttribute("studyTitle", study.getName());
}
logMe("Entering Get the study then the parent study end " + System.currentTimeMillis());
// Let us process the age
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("1")) {
// YW 11-16-2007 erollment-date is used for calculating age.
Date enrollmentDate = ssb.getEnrollmentDate();
age = Utils.getInstacne().processAge(enrollmentDate, subject.getDateOfBirth());
}
//ArrayList beans = ViewStudySubjectServlet.getDisplayStudyEventsForStudySubject(ssb, getDataSource(), ub, currentRole);
request.setAttribute("studySubject", ssb);
request.setAttribute("subject", subject);
//request.setAttribute("beans", beans);
request.setAttribute("eventCRF", ecb);
request.setAttribute("age", age);
request.setAttribute("decryptedPassword", ((SecurityManager) SpringServletAccess.getApplicationContext(getServletContext()).getBean("securityManager")).encrytPassword("root", getUserDetails()));
// set up interviewer name and date
fp.addPresetValue(INPUT_INTERVIEWER, ecb.getInterviewerName());
if (ecb.getDateInterviewed() != null) {
DateFormat local_df = new SimpleDateFormat(resformat.getString("date_format_string"), ResourceBundleProvider.getLocale());
String idateFormatted = local_df.format(ecb.getDateInterviewed());
fp.addPresetValue(INPUT_INTERVIEW_DATE, idateFormatted);
} else {
fp.addPresetValue(INPUT_INTERVIEW_DATE, "");
}
setPresetValues(fp.getPresetValues(), request);
logMe("Entering Checks !submitted " + System.currentTimeMillis());
if (!isSubmitted) {
// TODO: prevent data enterer from seeing results of first round of
// data
// entry, if this is second round
// FLAG--SLOW HERE WHEN LOADING
logMe("Entering Checks !submitted entered " + System.currentTimeMillis());
long t = System.currentTimeMillis();
request.setAttribute(BEAN_DISPLAY, section);
request.setAttribute(BEAN_ANNOTATIONS, getEventCRFAnnotations(request));
session.setAttribute("shouldRunValidation", null);
session.setAttribute("rulesErrors", null);
session.setAttribute(DataEntryServlet.NOTE_SUBMITTED, null);
discNotes = new FormDiscrepancyNotes();
// discNotes = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
// if (discNotes == null) {
// discNotes = new FormDiscrepancyNotes();
// }
// << tbh 01/2010
section = populateNotesWithDBNoteCounts(discNotes, section, request);
populateInstantOnChange(request.getSession(), ecb, section);
LOGGER.debug("+++ just ran populateNotes, printing field notes: " + discNotes.getFieldNotes().toString());
LOGGER.debug("found disc notes: " + discNotes.getNumExistingFieldNotes().toString());
session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
if (section.getSection().hasSCDItem()) {
section = SCDItemDisplayInfo.generateSCDDisplayInfo(section, this.getServletPage(request).equals(Page.INITIAL_DATA_ENTRY) || this.getServletPage(request).equals(Page.ADMIN_EDIT_SERVLET) && !this.isAdminForcedReasonForChange(request));
}
int keyId = ecb.getId();
session.removeAttribute(DoubleDataEntryServlet.COUNT_VALIDATE + keyId);
setUpPanel(section);
if (newUploadedFiles.size() > 0) {
if (this.unloadFiles(newUploadedFiles)) {
} else {
String missed = "";
Iterator iter = newUploadedFiles.keySet().iterator();
while (iter.hasNext()) {
missed += " " + newUploadedFiles.get(iter.next());
}
addPageMessage(respage.getString("uploaded_files_not_deleted_or_not_exist") + ": " + missed, request);
}
}
logMe("Entering Checks !submitted entered end forwarding page " + System.currentTimeMillis());
logMe("Time Took for this block" + (System.currentTimeMillis() - t));
forwardPage(getJSPPage(), request, response);
return;
} else {
logMe("Entering Checks !submitted not entered " + System.currentTimeMillis());
//
// VALIDATION / LOADING DATA
//
// If validation is required for this round, we will go through
// each item and add an appropriate validation to the Validator
//
// Otherwise, we will just load the data into the DisplayItemBean
// so that we can write to the database later.
//
// Validation is required if two conditions are met:
// 1. The user clicked a "Save" button, not a "Confirm" button
// 2. In this type of data entry servlet, when the user clicks
// a Save button, the inputs are validated
//
boolean validate = fp.getBoolean(INPUT_CHECK_INPUTS) && validateInputOnFirstRound();
// did the user click a "Save" button?
// is validation required in this type of servlet when the user
// clicks
// "Save"?
// We can conclude that the user is trying to save data; therefore,
// set a request
// attribute indicating that default values for items shouldn't be
// displayed
// in the application UI that will subsequently be displayed
// TODO: find a better, less random place for this
// session.setAttribute(HAS_DATA_FLAG, true);
// section.setCheckInputs(fp.getBoolean(INPUT_CHECK_INPUTS));
errors = new HashMap();
// ArrayList items = section.getItems();
discNotes = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
if (discNotes == null) {
discNotes = new FormDiscrepancyNotes();
}
// populateNotesWithDBNoteCounts(discNotes, section);
// all items- inlcude items in item groups and other single items
List<DisplayItemWithGroupBean> allItems = section.getDisplayItemGroups();
String attachedFilePath = Utils.getAttachedFilePath(currentStudy);
DiscrepancyValidator v = new DiscrepancyValidator(request, discNotes);
RuleValidator ruleValidator = new RuleValidator(request);
LOGGER.debug("SZE 1 :: " + allItems.size());
logMe("Looping inside !submitted " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); i++) {
LOGGER.trace("===itering through items: " + i);
DisplayItemWithGroupBean diwg = allItems.get(i);
if (diwg.isInGroup()) {
// for the items in groups
DisplayItemGroupBean dgb = diwg.getItemGroup();
List<DisplayItemGroupBean> dbGroups = diwg.getDbItemGroups();
//dbGroups = diwg.getItemGroups();
List<DisplayItemGroupBean> formGroups = new ArrayList<DisplayItemGroupBean>();
LOGGER.debug("got db item group size " + dbGroups.size());
if (validate) {
// int manualGroups = getManualRows(dbGroups2);
// logger.debug("+++ found manual rows from db group 2: " + manualGroups);
LOGGER.debug("===IF VALIDATE NOT A SINGLE ITEM: got to this part in the validation loop: " + dgb.getGroupMetaBean().getName());
// TODO next marker tbh 112007
// formGroups = validateDisplayItemGroupBean(v,
// dgb,dbGroups, formGroups,
// ruleValidator,groupOrdinalPLusItemOid);
formGroups = validateDisplayItemGroupBean(v, dgb, dbGroups, formGroups, request, response);
LOGGER.debug("form group size after validation " + formGroups.size());
} else {
LOGGER.debug("+++ELSE NOT A SINGLE ITEM: got to this part in the validation loop: " + dgb.getGroupMetaBean().getName());
formGroups = loadFormValueForItemGroup(dgb, dbGroups, formGroups, eventDefinitionCRFId, request);
LOGGER.debug("form group size without validation " + formGroups.size());
}
diwg.setItemGroup(dgb);
diwg.setItemGroups(formGroups);
allItems.set(i, diwg);
} else {
// other single items
DisplayItemBean dib = diwg.getSingleItem();
// dib = (DisplayItemBean) allItems.get(i);
if (validate) {
// generate input name here?
// DisplayItemGroupBean dgb = diwg.getItemGroup();
String itemName = getInputName(dib);
// no Item group for single item, so just use blank
// string as parameter for inputName
// this
dib = validateDisplayItemBean(v, dib, "", request);
// should be
// used,
// otherwise,
// DDE not
// working-jxu
LOGGER.debug("&&& found name: " + itemName);
LOGGER.debug("input VALIDATE " + itemName + ": " + fp.getString(itemName));
// dib.loadFormValue(fp.getString(itemName));
LOGGER.debug("input " + itemName + " has a response set of " + dib.getMetadata().getResponseSet().getOptions().size() + " options");
} else {
String itemName = getInputName(dib);
LOGGER.debug("input NONVALIDATE " + itemName + ": " + fp.getString(itemName));
// dib.loadFormValue(itemName);
dib = loadFormValue(dib, request);
// String itemName = getInputName(dib);
// dib = loadFormValue(itemName);
}
ArrayList children = dib.getChildren();
for (int j = 0; j < children.size(); j++) {
DisplayItemBean child = (DisplayItemBean) children.get(j);
// DisplayItemGroupBean dgb = diwg.getItemGroup();
String itemName = getInputName(child);
child.loadFormValue(fp.getString(itemName));
if (validate) {
// child = validateDisplayItemBean(v, child,
// itemName, ruleValidator, groupOrdinalPLusItemOid,
// false);
child = validateDisplayItemBean(v, child, itemName, request);
// was null changed value 092007 tbh
} else {
// child.loadFormValue(itemName);
child = loadFormValue(child, request);
}
LOGGER.debug("Checking child value for " + itemName + ": " + child.getData().getValue());
children.set(j, child);
}
dib.setChildren(children);
diwg.setSingleItem(runDynamicsItemCheck(dib, null, request));
// logger.trace("just set single item on line 447:
// "+dib.getData().getValue());
// items.set(i, dib);
LOGGER.debug(" I : " + i);
allItems.set(i, diwg);
}
}
logMe("Loop ended " + System.currentTimeMillis());
//JN: This is the list that contains all the scd-shown items.
List<ItemBean> itemBeansWithSCDShown = new ArrayList<ItemBean>();
if (validate && section.getSection().hasSCDItem()) {
logMe(" Validate and Loop " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); ++i) {
DisplayItemBean dib = allItems.get(i).getSingleItem();
ItemFormMetadataBean ifmb = dib.getMetadata();
if (ifmb.getParentId() == 0) {
if (dib.getScdData().getScdSetsForControl().size() > 0) {
//for control item
//dib has to loadFormValue first. Here loadFormValue has been done in validateDisplayItemBean(v, dib, "")
section.setShowSCDItemIds(SimpleConditionalDisplayService.conditionalDisplayToBeShown(dib, section.getShowSCDItemIds()));
}
if (dib.getScdData().getScdItemMetadataBean().getScdItemFormMetadataId() > 0) {
//for scd item
//a control item is always before its scd item
dib.setIsSCDtoBeShown(section.getShowSCDItemIds().contains(dib.getMetadata().getItemId()));
if (dib.getIsSCDtoBeShown())
itemBeansWithSCDShown.add(dib.getItem());
validateSCDItemBean(v, dib);
}
ArrayList<DisplayItemBean> children = dib.getChildren();
for (int j = 0; j < children.size(); j++) {
DisplayItemBean child = children.get(j);
if (child.getScdData().getScdSetsForControl().size() > 0) {
//for control item
//dib has to loadFormValue first. Here loadFormValue has been done in validateDisplayItemBean(v, dib, "")
section.setShowSCDItemIds(SimpleConditionalDisplayService.conditionalDisplayToBeShown(child, section.getShowSCDItemIds()));
}
if (child.getScdData().getScdItemMetadataBean().getScdItemFormMetadataId() > 0) {
//for scd item
//a control item is always before its scd item
child.setIsSCDtoBeShown(section.getShowSCDItemIds().contains(child.getMetadata().getItemId()));
if (child.getIsSCDtoBeShown())
itemBeansWithSCDShown.add(dib.getItem());
validateSCDItemBean(v, child);
}
}
}
}
logMe(" Validate and Loop end " + System.currentTimeMillis());
}
logMe(" Validate and Loop end " + System.currentTimeMillis());
//JN:calling again here, for the items with simple conditional display and rules.
List<RuleSetBean> ruleSets = createAndInitializeRuleSet(currentStudy, studyEventDefinition, crfVersionBean, studyEventBean, ecb, true, request, response, itemBeansWithSCDShown);
boolean shouldRunRules = getRuleSetService(request).shouldRunRulesForRuleSets(ruleSets, phase2);
// this.getItemMetadataService().resetItemCounter();
HashMap<String, ArrayList<String>> groupOrdinalPLusItemOid = null;
groupOrdinalPLusItemOid = runRules(allItems, ruleSets, true, shouldRunRules, MessageType.ERROR, phase2, ecb, request);
logMe("allItems Loop begin " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); i++) {
DisplayItemWithGroupBean diwg = allItems.get(i);
if (diwg.isInGroup()) {
// for the items in groups
DisplayItemGroupBean dgb = diwg.getItemGroup();
List<DisplayItemGroupBean> dbGroups = diwg.getDbItemGroups();
//dbGroups = diwg.getItemGroups();
// tbh 01/2010 change the group list?
List<DisplayItemGroupBean> formGroups = new ArrayList<DisplayItemGroupBean>();
// items again?
if (validate) {
// int manualGroups = getManualRows(dbGroups2);
// logger.debug("+++ found manual rows for db group2: " + manualGroups);
formGroups = validateDisplayItemGroupBean(v, dgb, dbGroups, formGroups, ruleValidator, groupOrdinalPLusItemOid, request, response);
// formGroups = validateDisplayItemGroupBean(v, dgb,
// dbGroups, formGroups);
LOGGER.debug("*** form group size after validation " + formGroups.size());
}
diwg.setItemGroup(dgb);
diwg.setItemGroups(formGroups);
allItems.set(i, diwg);
} else {
// other single items
DisplayItemBean dib = diwg.getSingleItem();
// dib = (DisplayItemBean) allItems.get(i);
if (validate) {
String itemName = getInputName(dib);
//
dib = validateDisplayItemBean(v, dib, "", ruleValidator, groupOrdinalPLusItemOid, false, null, request);
// / dib = validateDisplayItemBean(v, dib, "");// this
}
ArrayList children = dib.getChildren();
for (int j = 0; j < children.size(); j++) {
DisplayItemBean child = (DisplayItemBean) children.get(j);
// DisplayItemGroupBean dgb = diwg.getItemGroup();
String itemName = getInputName(child);
child.loadFormValue(fp.getString(itemName));
if (validate) {
child = validateDisplayItemBean(v, child, "", ruleValidator, groupOrdinalPLusItemOid, false, null, request);
// child = validateDisplayItemBean(v, child,
// itemName);
}
children.set(j, child);
LOGGER.debug(" J (children): " + j);
}
dib.setChildren(children);
diwg.setSingleItem(runDynamicsItemCheck(dib, null, request));
LOGGER.debug(" I : " + i);
allItems.set(i, diwg);
}
}
logMe("allItems Loop end " + System.currentTimeMillis());
// YW, 2-1-2008 <<
// A map from item name to item bean object.
HashMap<String, ItemBean> scoreItems = new HashMap<String, ItemBean>();
HashMap<String, String> scoreItemdata = new HashMap<String, String>();
HashMap<String, ItemDataBean> oldItemdata = prepareSectionItemdataObject(sb.getId(), request);
// hold all item names of changed ItemBean in current section
TreeSet<String> changedItems = new TreeSet<String>();
// holds complete disply item beans for checking against 'request
// for change' restriction
ArrayList<DisplayItemBean> changedItemsList = new ArrayList<DisplayItemBean>();
// key is repeating item name, value is its display item group bean
HashMap<String, DisplayItemGroupBean> changedItemsMap = new HashMap<String, DisplayItemGroupBean>();
// key is itemid, value is set of itemdata-ordinal
HashMap<Integer, TreeSet<Integer>> itemOrdinals = prepareItemdataOrdinals(request);
// prepare item data for scoring
updateDataOrdinals(allItems);
section.setDisplayItemGroups(allItems);
scoreItems = prepareScoreItems(request);
scoreItemdata = prepareScoreItemdata(request);
logMe("allItems 2 Loop begin " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); i++) {
DisplayItemWithGroupBean diwb = allItems.get(i);
if (diwb.isInGroup()) {
// for the items in groups
DisplayItemGroupBean digb = diwb.getItemGroup();
List<DisplayItemGroupBean> dbGroups = diwb.getDbItemGroups();
for (int j = 0; j < dbGroups.size(); j++) {
DisplayItemGroupBean displayGroup = dbGroups.get(j);
List<DisplayItemBean> items = displayGroup.getItems();
if ("remove".equalsIgnoreCase(displayGroup.getEditFlag())) {
for (DisplayItemBean displayItem : items) {
if (displayItem.getMetadata().isShowItem() && digb.getGroupMetaBean().isShowGroup()) {
int itemId = displayItem.getItem().getId();
int ordinal = displayItem.getData().getOrdinal();
if (itemOrdinals.containsKey(itemId)) {
itemOrdinals.get(itemId).remove(ordinal);
}
if (scoreItemdata.containsKey(itemId + "_" + ordinal)) {
scoreItemdata.remove(itemId + "_" + ordinal);
}
changedItems.add(displayItem.getItem().getName());
changedItemsList.add(displayItem);
String formName = displayItem.getItem().getName();
// logger.debug("SET: formName:" + formName);
if (displayGroup.isAuto()) {
formName = getGroupItemInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("GET: changed formName to " + formName);
} else {
formName = getGroupItemManualInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("GET-MANUAL: changed formName to " + formName);
}
changedItemsMap.put(formName, displayGroup);
LOGGER.debug("adding to changed items map: " + formName);
}
}
}
}
List<DisplayItemGroupBean> dgbs = diwb.getItemGroups();
int groupsize = dgbs.size();
HashMap<Integer, Integer> maxOrdinals = new HashMap<Integer, Integer>();
boolean first = true;
for (int j = 0; j < dgbs.size(); j++) {
DisplayItemGroupBean displayGroup = dgbs.get(j);
List<DisplayItemBean> items = displayGroup.getItems();
boolean isAdd = "add".equalsIgnoreCase(displayGroup.getEditFlag()) ? true : false;
for (DisplayItemBean displayItem : items) {
ItemBean ib = displayItem.getItem();
String itemName = ib.getName();
int itemId = ib.getId();
if (first) {
maxOrdinals.put(itemId, iddao.getMaxOrdinalForGroup(ecb, sb, displayGroup.getItemGroupBean()));
}
ItemDataBean idb = displayItem.getData();
String value = idb.getValue();
scoreItems.put(itemName, ib);
int ordinal = displayItem.getData().getOrdinal();
if (isAdd && scoreItemdata.containsKey(itemId + "_" + ordinal)) {
int formMax = 1;
if (maxOrdinals.containsKey(itemId)) {
formMax = maxOrdinals.get(itemId);
}
int dbMax = iddao.getMaxOrdinalForGroup(ecb, sb, displayGroup.getItemGroupBean());
ordinal = ordinal >= dbMax ? formMax + 1 : ordinal;
maxOrdinals.put(itemId, ordinal);
displayItem.getData().setOrdinal(ordinal);
scoreItemdata.put(itemId + "_" + ordinal, value);
} else {
scoreItemdata.put(itemId + "_" + ordinal, value);
}
if (itemOrdinals.containsKey(itemId)) {
itemOrdinals.get(itemId).add(ordinal);
} else {
TreeSet<Integer> ordinalSet = new TreeSet<Integer>();
ordinalSet.add(ordinal);
itemOrdinals.put(itemId, ordinalSet);
}
if (isChanged(displayItem, oldItemdata, attachedFilePath)) {
changedItems.add(itemName);
changedItemsList.add(displayItem);
String formName = displayItem.getItem().getName();
// logger.debug("SET: formName:" + formName);
if (displayGroup.isAuto()) {
formName = getGroupItemInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("RESET: formName group-item-input:" + formName);
} else {
formName = getGroupItemManualInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("RESET: formName group-item-input-manual:" + formName);
}
changedItemsMap.put(formName, displayGroup);
LOGGER.debug("adding to changed items map: " + formName);
}
}
first = false;
}
} else {
DisplayItemBean dib = diwb.getSingleItem();
ItemBean ib = dib.getItem();
ItemDataBean idb = dib.getData();
int itemId = ib.getId();
String itemName = ib.getName();
String value = idb.getValue();
scoreItems.put(itemName, ib);
// for items which are not in any group, their ordinal is
// set as 1
TreeSet<Integer> ordinalset = new TreeSet<Integer>();
ordinalset.add(1);
itemOrdinals.put(itemId, ordinalset);
scoreItemdata.put(itemId + "_" + 1, value);
if (isChanged(idb, oldItemdata, dib, attachedFilePath)) {
changedItems.add(itemName);
changedItemsList.add(dib);
// changedItemsMap.put(dib.getItem().getName(), new
// DisplayItemGroupBean());
}
ArrayList children = dib.getChildren();
for (int j = 0; j < children.size(); j++) {
DisplayItemBean child = (DisplayItemBean) children.get(j);
ItemBean cib = child.getItem();
scoreItems.put(cib.getName(), cib);
TreeSet<Integer> cordinalset = new TreeSet<Integer>();
cordinalset.add(1);
itemOrdinals.put(itemId, cordinalset);
scoreItemdata.put(cib.getId() + "_" + 1, child.getData().getValue());
if (isChanged(child.getData(), oldItemdata, child, attachedFilePath)) {
changedItems.add(itemName);
changedItemsList.add(child);
// changedItemsMap.put(itemName, new
// DisplayItemGroupBean());
}
}
}
}
logMe("allItems 2 Loop end " + System.currentTimeMillis());
// do calculation for 'calculation' and 'group-calculation' type
// items
// and write the result in DisplayItemBean's ItemDateBean - data
ScoreItemValidator sv = new ScoreItemValidator(request, discNotes);
// *** doing calc here, load it where? ***
SessionManager sm = (SessionManager) request.getSession().getAttribute("sm");
ScoreCalculator sc = new ScoreCalculator(sm, ecb, ub);
logMe("allItems 3 Loop begin " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); i++) {
DisplayItemWithGroupBean diwb = allItems.get(i);
if (diwb.isInGroup()) {
List<DisplayItemGroupBean> dgbs = diwb.getItemGroups();
for (int j = 0; j < dgbs.size(); j++) {
DisplayItemGroupBean displayGroup = dgbs.get(j);
List<DisplayItemBean> items = displayGroup.getItems();
for (DisplayItemBean displayItem : items) {
ItemFormMetadataBean ifmb = displayItem.getMetadata();
int responseTypeId = ifmb.getResponseSet().getResponseTypeId();
if (responseTypeId == 8 || responseTypeId == 9) {
StringBuffer err = new StringBuffer();
ResponseOptionBean robBean = (ResponseOptionBean) ifmb.getResponseSet().getOptions().get(0);
String value = "";
String inputName = "";
// getFormInputOrdinal() here, tbh 06/2009
if (displayGroup.isAuto()) {
inputName = getGroupItemInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("returning input name: " + inputName);
} else {
inputName = getGroupItemManualInputName(displayGroup, displayGroup.getFormInputOrdinal(), displayItem);
LOGGER.debug("returning input name: " + inputName);
}
if (robBean.getValue().startsWith("func: getexternalvalue") || robBean.getValue().startsWith("func: getExternalValue")) {
value = fp.getString(inputName);
LOGGER.debug("*** just set " + fp.getString(inputName) + " for line 815 " + displayItem.getItem().getName() + " with input name " + inputName);
} else {
value = sc.doCalculation(displayItem, scoreItems, scoreItemdata, itemOrdinals, err, displayItem.getData().getOrdinal());
}
displayItem.loadFormValue(value);
if (isChanged(displayItem, oldItemdata, attachedFilePath)) {
changedItems.add(displayItem.getItem().getName());
changedItemsList.add(displayItem);
}
request.setAttribute(inputName, value);
if (validate) {
displayItem = validateCalcTypeDisplayItemBean(sv, displayItem, inputName, request);
if (err.length() > 0) {
Validation validation = new Validation(Validator.CALCULATION_FAILED);
validation.setErrorMessage(err.toString());
sv.addValidation(inputName, validation);
}
}
}
}
}
} else {
DisplayItemBean dib = diwb.getSingleItem();
ItemFormMetadataBean ifmb = dib.getMetadata();
int responseTypeId = ifmb.getResponseSet().getResponseTypeId();
if (responseTypeId == 8 || responseTypeId == 9) {
StringBuffer err = new StringBuffer();
ResponseOptionBean robBean = (ResponseOptionBean) ifmb.getResponseSet().getOptions().get(0);
String value = "";
if (robBean.getValue().startsWith("func: getexternalvalue") || robBean.getValue().startsWith("func: getExternalValue")) {
String itemName = getInputName(dib);
value = fp.getString(itemName);
LOGGER.debug("just set " + fp.getString(itemName) + " for " + dib.getItem().getName());
LOGGER.debug("found in fp: " + fp.getString(dib.getItem().getName()));
// logger.debug("scoreitemdata: " +
// scoreItemdata.toString());
} else {
value = sc.doCalculation(dib, scoreItems, scoreItemdata, itemOrdinals, err, 1);
}
dib.loadFormValue(value);
if (isChanged(dib.getData(), oldItemdata, dib, attachedFilePath)) {
changedItems.add(dib.getItem().getName());
changedItemsList.add(dib);
// changedItemsMap.put(dib.getItem().getName(), new
// DisplayItemGroupBean());
}
String inputName = getInputName(dib);
request.setAttribute(inputName, value);
if (validate) {
dib = validateCalcTypeDisplayItemBean(sv, dib, "", request);
if (err.length() > 0) {
Validation validation = new Validation(Validator.CALCULATION_FAILED);
validation.setErrorMessage(err.toString());
sv.addValidation(inputName, validation);
}
}
}
ArrayList children = dib.getChildren();
for (int j = 0; j < children.size(); j++) {
DisplayItemBean child = (DisplayItemBean) children.get(j);
ItemFormMetadataBean cifmb = child.getMetadata();
int resTypeId = cifmb.getResponseSet().getResponseTypeId();
if (resTypeId == 8 || resTypeId == 9) {
StringBuffer cerr = new StringBuffer();
child.getDbData().setValue(child.getData().getValue());
ResponseOptionBean crobBean = (ResponseOptionBean) cifmb.getResponseSet().getOptions().get(0);
String cvalue = "";
if (crobBean.getValue().startsWith("func: getexternalvalue") || crobBean.getValue().startsWith("func: getExternalValue")) {
String itemName = getInputName(child);
cvalue = fp.getString(itemName);
LOGGER.debug("just set " + fp.getString(itemName) + " for " + child.getItem().getName());
} else {
cvalue = sc.doCalculation(child, scoreItems, scoreItemdata, itemOrdinals, cerr, 1);
}
child.loadFormValue(cvalue);
if (isChanged(child.getData(), oldItemdata, child, attachedFilePath)) {
changedItems.add(child.getItem().getName());
changedItemsList.add(child);
// changedItemsMap.put(child.getItem().getName(),
// new DisplayItemGroupBean());
}
String cinputName = getInputName(child);
request.setAttribute(cinputName, cvalue);
if (validate) {
child = validateCalcTypeDisplayItemBean(sv, child, "", request);
if (cerr.length() > 0) {
Validation cvalidation = new Validation(Validator.CALCULATION_FAILED);
cvalidation.setErrorMessage(cerr.toString());
sv.addValidation(cinputName, cvalidation);
}
}
}
children.set(j, child);
}
}
}
logMe("allItems 3 Loop end " + System.currentTimeMillis());
// YW >>
// we have to do this since we loaded all the form values into the
// display
// item beans above
// section.setItems(items);
// setting this AFTER we populate notes - will that make a difference?
section.setDisplayItemGroups(allItems);
// logger.debug("+++ try to populate notes");
section = populateNotesWithDBNoteCounts(discNotes, section, request);
populateInstantOnChange(request.getSession(), ecb, section);
if (currentStudy.getStudyParameterConfig().getInterviewerNameRequired().equals("yes")) {
v.addValidation(INPUT_INTERVIEWER, Validator.NO_BLANKS);
}
if (currentStudy.getStudyParameterConfig().getInterviewDateRequired().equals("yes")) {
v.addValidation(INPUT_INTERVIEW_DATE, Validator.NO_BLANKS);
}
if (!StringUtil.isBlank(fp.getString(INPUT_INTERVIEW_DATE))) {
v.addValidation(INPUT_INTERVIEW_DATE, Validator.IS_A_DATE);
v.alwaysExecuteLastValidation(INPUT_INTERVIEW_DATE);
}
if (section.getSection().hasSCDItem()) {
section = SCDItemDisplayInfo.generateSCDDisplayInfo(section, this.getServletPage(request).equals(Page.INITIAL_DATA_ENTRY) || this.getServletPage(request).equals(Page.ADMIN_EDIT_SERVLET) && !this.isAdminForcedReasonForChange(request));
}
// logger.debug("about to validate: " + v.getKeySet());
errors = v.validate();
// tbh >>
if (this.isAdminForcedReasonForChange(request) && this.isAdministrativeEditing() && errors.isEmpty()) {
// "You have changed data after this CRF was marked complete. "
// +
// "You must provide a Reason For Change discrepancy note for this item before you can save this updated information."
String error = respage.getString("reason_for_change_error");
// "Please enter a reason for change discrepancy note before saving."
// ;
int nonforcedChanges = 0;
// items map
if (changedItemsList.size() > 0) {
LOGGER.debug("found admin force reason for change: changed items " + changedItems.toString() + " and changed items list: " + changedItemsList.toString() + " changed items map: " + changedItemsMap.toString());
logMe("DisplayItemBean Loop begin " + System.currentTimeMillis());
for (DisplayItemBean displayItem : changedItemsList) {
String formName = getInputName(displayItem);
ItemDataBean idb = displayItem.getData();
ItemBean item_bean = displayItem.getItem();
ItemFormMetadataBean ifmb = displayItem.getMetadata();
LOGGER.debug("-- found group label " + ifmb.getGroupLabel());
if (!ifmb.getGroupLabel().equalsIgnoreCase("Ungrouped") && !ifmb.getGroupLabel().equalsIgnoreCase("")) {
// << tbh 11/2009 sometimes the group label is blank instead of ungrouped???
Iterator iter = changedItemsMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, DisplayItemGroupBean> pairs = (Map.Entry) iter.next();
String formName2 = pairs.getKey();
DisplayItemGroupBean dgb = pairs.getValue();
// logger.debug("found auto: " +
// dgb.isAuto());
String testFormName = "";
if (dgb.isAuto()) {
// testFormName = getGroupItemInputName(dgb, dgb.getFormInputOrdinal(), getManualRows(dgbs), displayItem);
testFormName = getGroupItemInputName(dgb, dgb.getFormInputOrdinal(), displayItem);
} else {
testFormName = getGroupItemManualInputName(dgb, dgb.getFormInputOrdinal(), displayItem);
}
LOGGER.debug("found test form name: " + testFormName);
// if our test is the same with both the display
// item and the display group ...
// logger.debug("comparing " +
// testFormName + " and " + formName2);
int existingNotes = dndao.findNumExistingNotesForItem(idb.getId());
if (testFormName.equals(formName2)) {
formName = formName2;
this.setReasonForChangeError(ecb, item_bean, idb, formName, error, request);
changedItemsMap.remove(formName2);
LOGGER.debug("form name changed: " + formName);
break;
// .., send it as the form name
}
// ... otherwise, don't touch it
// how to tell vs. manual and just plain input?
}
} else {
this.setReasonForChangeError(ecb, item_bean, idb, formName, error, request);
LOGGER.debug("form name added: " + formName);
}
}
logMe("DisplayItemBean Loop end " + System.currentTimeMillis());
}
if (nonforcedChanges > 0) {
// do smething here?
}
}
LOGGER.debug("errors here: " + errors.toString());
// <<
logMe("error check Loop begin " + System.currentTimeMillis());
if (errors.isEmpty() && shouldRunRules) {
LOGGER.debug("Errors was empty");
if (session.getAttribute("rulesErrors") != null) {
// rules have already generated errors, Let's compare old
// error list with new
// error list, if lists not same show errors.
HashMap h = ruleValidator.validate();
Set<String> a = (Set<String>) session.getAttribute("rulesErrors");
Set<String> ba = h.keySet();
Boolean showErrors = false;
for (Object key : ba) {
if (!a.contains(key)) {
showErrors = true;
}
}
if (showErrors) {
errors = h;
if (errors.size() > 0) {
session.setAttribute("shouldRunValidation", "1");
session.setAttribute("rulesErrors", errors.keySet());
} else {
session.setAttribute("shouldRunValidation", null);
session.setAttribute("rulesErrors", null);
}
} else {
session.setAttribute("shouldRunValidation", null);
session.setAttribute("rulesErrors", null);
}
} else if (session.getAttribute("shouldRunValidation") != null && session.getAttribute("shouldRunValidation").toString().equals("1")) {
session.setAttribute("shouldRunValidation", null);
session.setAttribute("rulesErrors", null);
} else {
errors = ruleValidator.validate();
if (errors.size() > 0) {
session.setAttribute("shouldRunValidation", "1");
session.setAttribute("rulesErrors", errors.keySet());
}
}
}
if (!errors.isEmpty()) {
LOGGER.debug("threw an error with data entry...");
// copying below three lines, tbh 03/2010
String[] textFields = { INPUT_INTERVIEWER, INPUT_INTERVIEW_DATE };
fp.setCurrentStringValuesAsPreset(textFields);
setPresetValues(fp.getPresetValues(), request);
// YW, 2-4-2008 <<
logMe("!errors if Loop begin " + System.currentTimeMillis());
HashMap<String, ArrayList<String>> siErrors = sv.validate();
if (siErrors != null && !siErrors.isEmpty()) {
Iterator iter = siErrors.keySet().iterator();
while (iter.hasNext()) {
String fieldName = iter.next().toString();
errors.put(fieldName, siErrors.get(fieldName));
}
}
// we should 'shift' the names here, tbh 02/2010
// need: total number of rows, manual rows, all row names
// plus: error names
Iterator iter2 = errors.keySet().iterator();
while (iter2.hasNext()) {
String fieldName = iter2.next().toString();
LOGGER.debug("found error " + fieldName);
}
// for (int i = 0; i < allItems.size(); i++) {
// DisplayItemWithGroupBean diwb = allItems.get(i);
//
// if (diwb.isInGroup()) {
// List<DisplayItemGroupBean> dgbs = diwb.getItemGroups();
// logger.debug("found manual rows " + getManualRows(dgbs) + " and total rows " + dgbs.size() + " from ordinal " + diwb.getOrdinal());
// }
// }
errors = reshuffleErrorGroupNamesKK(errors, allItems, request);
reshuffleReasonForChangeHashAndDiscrepancyNotes(allItems, request, ecb);
// reset manual rows, so that we can catch errors correctly
// but it needs to be set per block of repeating items? what if there are two or more?
/*
int manualRows = 0; // getManualRows(formGroups);
for (int i = 0; i < allItems.size(); i++) {
DisplayItemWithGroupBean diwb = allItems.get(i);
if (diwb.isInGroup()) {
List<DisplayItemGroupBean> dgbs = diwb.getItemGroups();
manualRows = getManualRows(dgbs);
}
}
*/
//request.setAttribute("manualRows", new Integer(manualRows));
Iterator iter3 = errors.keySet().iterator();
while (iter3.hasNext()) {
String fieldName = iter3.next().toString();
LOGGER.debug("found error after shuffle " + fieldName);
}
//Mantis Issue: 8116. Parsist the markComplete chebox on error
request.setAttribute("markComplete", fp.getString(INPUT_MARK_COMPLETE));
// << tbh, 02/2010
// YW >>
// copied
request.setAttribute(BEAN_DISPLAY, section);
request.setAttribute(BEAN_ANNOTATIONS, fp.getString(INPUT_ANNOTATIONS));
setInputMessages(errors, request);
addPageMessage(respage.getString("errors_in_submission_see_below"), request);
request.setAttribute("hasError", "true");
// addPageMessage("To override these errors and keep the data as
// you
// entered it, click one of the \"Confirm\" buttons. ");
// if (section.isCheckInputs()) {
// addPageMessage("Please notice that you must enter data for
// the
// <b>required</b> entries.");
// }
// we do not save any DNs if we get here, so we have to set it back into session...
session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
// << tbh 01/2010
setUpPanel(section);
forwardPage(getJSPPage(), request, response);
} else {
//reshuffleReasonForChangeHashAndDiscrepancyNotes( allItems, request, ecb);
LOGGER.debug("Do we hit this in save ?????");
logMe("Do we hit this in save ???? " + System.currentTimeMillis());
boolean success = true;
boolean temp = true;
// save interviewer name and date into DB
ecb.setInterviewerName(fp.getString(INPUT_INTERVIEWER));
if (!StringUtil.isBlank(fp.getString(INPUT_INTERVIEW_DATE))) {
ecb.setDateInterviewed(fp.getDate(INPUT_INTERVIEW_DATE));
} else {
ecb.setDateInterviewed(null);
}
if (ecdao == null) {
ecdao = new EventCRFDAO(getDataSource());
}
// set validator id for DDE
DataEntryStage stage = ecb.getStage();
if (stage.equals(DataEntryStage.INITIAL_DATA_ENTRY_COMPLETE) || stage.equals(DataEntryStage.DOUBLE_DATA_ENTRY)) {
ecb.setValidatorId(ub.getId());
}
// for Administrative editing
if (studyEventBean.getSubjectEventStatus().equals(SubjectEventStatus.SIGNED) && changedItemsList.size() > 0) {
studyEventBean.setSubjectEventStatus(SubjectEventStatus.COMPLETED);
studyEventBean.setUpdater(ub);
studyEventBean.setUpdatedDate(new Date());
seDao.update(studyEventBean);
}
// If the Study Subject's Satus is signed and we save a section
// , change status to available
LOGGER.debug("Status of Study Subject {}", ssb.getStatus().getName());
if (ssb.getStatus() == Status.SIGNED && changedItemsList.size() > 0) {
LOGGER.debug("Status of Study Subject is Signed we are updating");
StudySubjectDAO studySubjectDao = new StudySubjectDAO(getDataSource());
ssb.setStatus(Status.AVAILABLE);
ssb.setUpdater(ub);
ssb.setUpdatedDate(new Date());
studySubjectDao.update(ssb);
}
if (ecb.isSdvStatus() && changedItemsList.size() > 0) {
LOGGER.debug("Status of Study Subject is SDV we are updating");
StudySubjectDAO studySubjectDao = new StudySubjectDAO(getDataSource());
ssb.setStatus(Status.AVAILABLE);
ssb.setUpdater(ub);
ssb.setUpdatedDate(new Date());
studySubjectDao.update(ssb);
ecb.setSdvStatus(false);
ecb.setSdvUpdateId(ub.getId());
}
ecb = (EventCRFBean) ecdao.update(ecb);
// save discrepancy notes into DB
FormDiscrepancyNotes fdn = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
dndao = new DiscrepancyNoteDAO(getDataSource());
AddNewSubjectServlet.saveFieldNotes(INPUT_INTERVIEWER, fdn, dndao, ecb.getId(), "EventCRF", currentStudy);
AddNewSubjectServlet.saveFieldNotes(INPUT_INTERVIEW_DATE, fdn, dndao, ecb.getId(), "EventCRF", currentStudy);
// items = section.getItems();
allItems = section.getDisplayItemGroups();
int nextOrdinal = 0;
LOGGER.debug("all items before saving into DB" + allItems.size());
this.output(allItems);
//TODO:Seems longer here, check this
logMe("DisplayItemWithGroupBean allitems4 " + System.currentTimeMillis());
for (int i = 0; i < allItems.size(); i++) {
DisplayItemWithGroupBean diwb = allItems.get(i);
// from executing writeToDB.
if (diwb.isInGroup()) {
List<DisplayItemGroupBean> dgbs = diwb.getItemGroups();
// using the above gets us the correct number of manual groups, tbh 01/2010
List<DisplayItemGroupBean> dbGroups = diwb.getDbItemGroups();
LOGGER.debug("item group size: " + dgbs.size());
LOGGER.debug("item db-group size: " + dbGroups.size());
for (int j = 0; j < dgbs.size(); j++) {
DisplayItemGroupBean displayGroup = dgbs.get(j);
List<DisplayItemBean> items = displayGroup.getItems();
// this ordinal will only useful to create a new
// item data
// update an item data won't touch its ordinal
// int nextOrdinal = iddao.getMaxOrdinalForGroup(ecb, sb, displayGroup.getItemGroupBean()) + 1;
// Determine if any items in this group have data. If so we need to undelete and previously deleted items.
boolean undelete = false;
for (DisplayItemBean displayItem : items) {
String currItemVal = displayItem.getData().getValue();
if (currItemVal != null && !currItemVal.equals("")) {
undelete = true;
break;
}
}
for (DisplayItemBean displayItem : items) {
String fileName = this.addAttachedFilePath(displayItem, attachedFilePath);
boolean writeDN = true;
displayItem.setEditFlag(displayGroup.getEditFlag());
LOGGER.debug("group item value: " + displayItem.getData().getValue());
// if ("add".equalsIgnoreCase(displayItem.getEditFlag()) && fileName.length() > 0 && !newUploadedFiles.containsKey(fileName)) {
// displayItem.getData().setValue("");
// }
//15350, this particular logic, takes into consideration that a DN is created properly as long as the item data record exists and it fails to get created when it doesnt.
//so, we are expanding the logic from writeToDb method to avoid creating duplicate records.
writeDN = writeDN(displayItem);
//pulling from dataset instead of database and correcting the flawed logic of using the database ordinals as max ordinal...
nextOrdinal = displayItem.getData().getOrdinal();
temp = writeToDB(displayItem, iddao, nextOrdinal, request);
LOGGER.debug("just executed writeToDB - 1");
LOGGER.debug("next ordinal: " + nextOrdinal);
// Undelete item if any item in the repeating group has data.
if (undelete && displayItem.getDbData() != null && displayItem.getDbData().isDeleted()) {
iddao.undelete(displayItem.getDbData().getId(), ub.getId());
}
if (temp && newUploadedFiles.containsKey(fileName)) {
newUploadedFiles.remove(fileName);
}
// maybe put ordinal in the place of j? maybe subtract max rows from next ordinal if j is gt
// next ordinal?
String inputName = getGroupItemInputName(displayGroup, j, displayItem);
// String inputName2 = getGroupItemManualInputName(displayGroup, j, displayItem);
if (!displayGroup.isAuto()) {
LOGGER.trace("not auto");
inputName = this.getGroupItemManualInputName(displayGroup, j, displayItem);
}
//htaycher last DN is not stored for new rows
// if (j == dgbs.size() - 1) {
// // LAST ONE
// logger.trace("last one");
// int ordinal = j - this.getManualRows(dgbs);
// logger.debug("+++ found manual rows from line 1326: " + ordinal);
// inputName = getGroupItemInputName(displayGroup, ordinal, displayItem);
// }
// logger.trace("&&& we get previous looking at input name: " + inputName + " " + inputName2);
LOGGER.trace("&&& we get previous looking at input name: " + inputName);
// input name 2 removed from below
inputName = displayItem.getFieldName();
if (writeDN) {
AddNewSubjectServlet.saveFieldNotes(inputName, fdn, dndao, displayItem.getData().getId(), "itemData", currentStudy, ecb.getId());
}
success = success && temp;
}
}
for (int j = 0; j < dbGroups.size(); j++) {
DisplayItemGroupBean displayGroup = dbGroups.get(j);
//JN: Since remove button is gone, the following code can be commented out, however it needs to be tested? Can be tackled when handling discrepancy note w/repeating groups issues.
if ("remove".equalsIgnoreCase(displayGroup.getEditFlag())) {
List<DisplayItemBean> items = displayGroup.getItems();
for (DisplayItemBean displayItem : items) {
String fileName = this.addAttachedFilePath(displayItem, attachedFilePath);
displayItem.setEditFlag(displayGroup.getEditFlag());
LOGGER.debug("group item value: " + displayItem.getData().getValue());
// if ("add".equalsIgnoreCase(displayItem.getEditFlag()) && fileName.length() > 0 && !newUploadedFiles.containsKey(fileName)) {
// displayItem.getData().setValue("");
// }
temp = writeToDB(displayItem, iddao, 0, request);
LOGGER.debug("just executed writeToDB - 2");
if (temp && newUploadedFiles.containsKey(fileName)) {
newUploadedFiles.remove(fileName);
}
// just use 0 here since update doesn't
// touch ordinal
success = success && temp;
}
}
}
} else {
DisplayItemBean dib = diwb.getSingleItem();
// TODO work on this line
// this.addAttachedFilePath(dib, attachedFilePath);
String fileName = addAttachedFilePath(dib, attachedFilePath);
boolean writeDN = writeDN(dib);
temp = writeToDB(dib, iddao, 1, request);
LOGGER.debug("just executed writeToDB - 3");
if (temp && (newUploadedFiles.containsKey(dib.getItem().getId() + "") || newUploadedFiles.containsKey(fileName))) {
// so newUploadedFiles will contain only failed file
// items;
newUploadedFiles.remove(dib.getItem().getId() + "");
newUploadedFiles.remove(fileName);
}
String inputName = getInputName(dib);
LOGGER.trace("3 - found input name: " + inputName);
if (writeDN)
AddNewSubjectServlet.saveFieldNotes(inputName, fdn, dndao, dib.getData().getId(), "itemData", currentStudy, ecb.getId());
success = success && temp;
ArrayList childItems = dib.getChildren();
for (int j = 0; j < childItems.size(); j++) {
DisplayItemBean child = (DisplayItemBean) childItems.get(j);
this.addAttachedFilePath(child, attachedFilePath);
writeDN = writeDN(child);
temp = writeToDB(child, iddao, 1, request);
LOGGER.debug("just executed writeToDB - 4");
if (temp && newUploadedFiles.containsKey(child.getItem().getId() + "")) {
// so newUploadedFiles will contain only failed
// file items;
newUploadedFiles.remove(child.getItem().getId() + "");
}
inputName = getInputName(child);
if (writeDN)
AddNewSubjectServlet.saveFieldNotes(inputName, fdn, dndao, child.getData().getId(), "itemData", currentStudy, ecb.getId());
success = success && temp;
}
}
}
logMe("DisplayItemWithGroupBean allitems4 end " + System.currentTimeMillis());
LOGGER.debug("running rules: " + phase2.name());
List<Integer> prevShownDynItemDataIds = shouldRunRules ? this.getItemMetadataService().getDynamicsItemFormMetadataDao().findShowItemDataIdsInSection(section.getSection().getId(), ecb.getCRFVersionId(), ecb.getId()) : new ArrayList<Integer>();
logMe("DisplayItemWithGroupBean dryrun start" + System.currentTimeMillis());
HashMap<String, ArrayList<String>> rulesPostDryRun = runRules(allItems, ruleSets, false, shouldRunRules, MessageType.WARNING, phase2, ecb, request);
HashMap<String, ArrayList<String>> errorsPostDryRun = new HashMap<String, ArrayList<String>>();
// additional step needed, run rules and see if any items are 'shown' AFTER saving data
logMe("DisplayItemWithGroupBean dryrun end" + System.currentTimeMillis());
boolean inSameSection = false;
logMe("DisplayItemWithGroupBean allitems4 " + System.currentTimeMillis());
if (!rulesPostDryRun.isEmpty()) {
// in same section?
// iterate through the OIDs and see if any of them belong to this section
Iterator iter3 = rulesPostDryRun.keySet().iterator();
while (iter3.hasNext()) {
String fieldName = iter3.next().toString();
LOGGER.debug("found oid after post dry run " + fieldName);
// set up a listing of OIDs in the section
// BUT: Oids can have the group name in them.
int ordinal = -1;
String newFieldName = fieldName;
String[] fieldNames = fieldName.split("\\.");
if (fieldNames.length == 2) {
newFieldName = fieldNames[1];
// check items in item groups here?
if (fieldNames[0].contains("[")) {
int p1 = fieldNames[0].indexOf("[");
int p2 = fieldNames[0].indexOf("]");
try {
ordinal = Integer.valueOf(fieldNames[0].substring(p1 + 1, p2));
} catch (NumberFormatException e) {
ordinal = -1;
}
fieldNames[0] = fieldNames[0].substring(0, p1);
}
}
List<DisplayItemWithGroupBean> displayGroupsWithItems = section.getDisplayItemGroups();
//ArrayList<DisplayItemBean> displayItems = section.getItems();
for (int i = 0; i < displayGroupsWithItems.size(); i++) {
DisplayItemWithGroupBean itemWithGroup = displayGroupsWithItems.get(i);
if (itemWithGroup.isInGroup()) {
LOGGER.debug("found group: " + fieldNames[0]);
// do something there
List<DisplayItemGroupBean> digbs = itemWithGroup.getItemGroups();
LOGGER.debug("digbs size: " + digbs.size());
for (int j = 0; j < digbs.size(); j++) {
DisplayItemGroupBean displayGroup = digbs.get(j);
if (displayGroup.getItemGroupBean().getOid().equals(fieldNames[0]) && displayGroup.getOrdinal() == ordinal - 1) {
List<DisplayItemBean> items = displayGroup.getItems();
for (int k = 0; k < items.size(); k++) {
DisplayItemBean dib = items.get(k);
if (dib.getItem().getOid().equals(newFieldName)) {
//inSameSection = true;
if (!dib.getMetadata().isShowItem()) {
LOGGER.debug("found item in group " + this.getGroupItemInputName(displayGroup, j, dib) + " vs. " + fieldName + " and is show item: " + dib.getMetadata().isShowItem());
dib.getMetadata().setShowItem(true);
}
if (prevShownDynItemDataIds == null || !prevShownDynItemDataIds.contains(dib.getData().getId())) {
inSameSection = true;
errorsPostDryRun.put(this.getGroupItemInputName(displayGroup, j, dib), rulesPostDryRun.get(fieldName));
}
}
items.set(k, dib);
}
displayGroup.setItems(items);
digbs.set(j, displayGroup);
}
}
itemWithGroup.setItemGroups(digbs);
} else {
DisplayItemBean displayItemBean = itemWithGroup.getSingleItem();
ItemBean itemBean = displayItemBean.getItem();
if (newFieldName.equals(itemBean.getOid())) {
//System.out.println("check run dynamics item check " + runDynamicsItemCheck(displayItemBean).getMetadata().isShowItem());
if (!displayItemBean.getMetadata().isShowItem()) {
// double check there?
LOGGER.debug("found item " + this.getInputName(displayItemBean) + " vs. " + fieldName + " and is show item: " + displayItemBean.getMetadata().isShowItem());
// if is repeating, use the other input name? no
displayItemBean.getMetadata().setShowItem(true);
if (prevShownDynItemDataIds == null || !prevShownDynItemDataIds.contains(displayItemBean.getData().getId())) {
inSameSection = true;
errorsPostDryRun.put(this.getInputName(displayItemBean), rulesPostDryRun.get(fieldName));
}
}
}
itemWithGroup.setSingleItem(displayItemBean);
}
displayGroupsWithItems.set(i, itemWithGroup);
}
logMe("DisplayItemWithGroupBean allitems4 end,begin" + System.currentTimeMillis());
// check groups
//List<DisplayItemGroupBean> itemGroups = new ArrayList<DisplayItemGroupBean>();
//itemGroups = section.getDisplayFormGroups();
// But in jsp: section.displayItemGroups.itemGroup.groupMetaBean.showGroup
List<DisplayItemWithGroupBean> itemGroups = section.getDisplayItemGroups();
// List<DisplayItemGroupBean> newItemGroups = new ArrayList<DisplayItemGroupBean>();
for (DisplayItemWithGroupBean itemGroup : itemGroups) {
DisplayItemGroupBean displayGroup = itemGroup.getItemGroup();
if (newFieldName.equals(displayGroup.getItemGroupBean().getOid())) {
if (!displayGroup.getGroupMetaBean().isShowGroup()) {
inSameSection = true;
LOGGER.debug("found itemgroup " + displayGroup.getItemGroupBean().getOid() + " vs. " + fieldName + " and is show item: " + displayGroup.getGroupMetaBean().isShowGroup());
// hmmm how to set highlighting for a group?
errorsPostDryRun.put(displayGroup.getItemGroupBean().getOid(), rulesPostDryRun.get(fieldName));
displayGroup.getGroupMetaBean().setShowGroup(true);
// add necessary rows to the display group here????
// we have to set the items in the itemGroup for the displayGroup
loadItemsWithGroupRows(itemGroup, sb, edcb, ecb, request);
}
}
// newItemGroups.add(displayGroup);
}
logMe("DisplayItemWithGroupBean allitems4 end,end" + System.currentTimeMillis());
// trying to reset the display form groups here, tbh
// section.setItems(displayItems);
section.setDisplayItemGroups(displayGroupsWithItems);
populateInstantOnChange(request.getSession(), ecb, section);
// section.setDisplayFormGroups(newDisplayBean.getDisplayFormGroups());
}
//
this.getItemMetadataService().updateGroupDynamicsInSection(displayItemWithGroups, section.getSection().getId(), ecb);
toc = TableOfContentsServlet.getDisplayBeanWithShownSections(getDataSource(), (DisplayTableOfContentsBean) request.getAttribute(TOC_DISPLAY), (DynamicsMetadataService) SpringServletAccess.getApplicationContext(getServletContext()).getBean("dynamicsMetadataService"));
request.setAttribute(TOC_DISPLAY, toc);
sectionIdsInToc = TableOfContentsServlet.sectionIdsInToc(toc);
sIndex = TableOfContentsServlet.sectionIndexInToc(section.getSection(), toc, sectionIdsInToc);
previousSec = this.prevSection(section.getSection(), ecb, toc, sIndex);
nextSec = this.nextSection(section.getSection(), ecb, toc, sIndex);
section.setFirstSection(!previousSec.isActive());
section.setLastSection(!nextSec.isActive());
//
// we need the following for repeating groups, tbh
// >> tbh 06/2010
// List<DisplayItemWithGroupBean> displayItemWithGroups2 = createItemWithGroups(section, hasGroup, eventDefinitionCRFId);
// section.setDisplayItemGroups(displayItemWithGroups2);
// if so, stay at this section
LOGGER.debug(" in same section: " + inSameSection);
if (inSameSection) {
// copy of one line from early on around line 400, forcing a re-show of the items
// section = getDisplayBean(hasGroup, true);// include all items, tbh
// below a copy of three lines from the if errors = true line, tbh 03/2010
String[] textFields = { INPUT_INTERVIEWER, INPUT_INTERVIEW_DATE };
fp.setCurrentStringValuesAsPreset(textFields);
setPresetValues(fp.getPresetValues(), request);
// below essetially a copy except for rulesPostDryRun
request.setAttribute(BEAN_DISPLAY, section);
request.setAttribute(BEAN_ANNOTATIONS, fp.getString(INPUT_ANNOTATIONS));
setInputMessages(errorsPostDryRun, request);
addPageMessage(respage.getString("your_answers_activated_hidden_items"), request);
request.setAttribute("hasError", "true");
request.setAttribute("hasShown", "true");
session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
setUpPanel(section);
forwardPage(getJSPPage(), request, response);
}
}
if (!inSameSection) {
// else if not in same section, progress as usual
/*
toc =
TableOfContentsServlet.getDisplayBeanWithShownSections(getDataSource(), (DisplayTableOfContentsBean) request.getAttribute(TOC_DISPLAY),
(DynamicsMetadataService) SpringServletAccess.getApplicationContext(getServletContext()).getBean("dynamicsMetadataService"));
request.setAttribute(TOC_DISPLAY, toc);
sectionIdsInToc = TableOfContentsServlet.sectionIdsInToc(toc);
sIndex = TableOfContentsServlet.sectionIndexInToc(section.getSection(), toc, sectionIdsInToc);
previousSec = this.prevSection(section.getSection(), ecb, toc, sIndex);
nextSec = this.nextSection(section.getSection(), ecb, toc, sIndex);
section.setFirstSection(!previousSec.isActive());
section.setLastSection(!nextSec.isActive());
*/
// can we just forward page or do we actually need an ELSE here?
// yes, we do. tbh 05/03/2010
ArrayList<String> updateFailedItems = sc.redoCalculations(scoreItems, scoreItemdata, changedItems, itemOrdinals, sb.getId());
success = updateFailedItems.size() > 0 ? false : true;
// now check if CRF is marked complete
boolean markComplete = fp.getString(INPUT_MARK_COMPLETE).equals(VALUE_YES);
// if the CRF was marked
boolean markSuccessfully = false;
// successfully
if (markComplete && section.isLastSection()) {
LOGGER.debug("need to mark CRF as complete");
markSuccessfully = markCRFComplete(request);
LOGGER.debug("...marked CRF as complete: " + markSuccessfully);
if (!markSuccessfully) {
request.setAttribute(BEAN_DISPLAY, section);
request.setAttribute(BEAN_ANNOTATIONS, fp.getString(INPUT_ANNOTATIONS));
setUpPanel(section);
forwardPage(getJSPPage(), request, response);
return;
}
}
// now write the event crf bean to the database
String annotations = fp.getString(INPUT_ANNOTATIONS);
setEventCRFAnnotations(annotations, request);
Date now = new Date();
ecb.setUpdatedDate(now);
ecb.setUpdater(ub);
ecb = (EventCRFBean) ecdao.update(ecb);
success = success && ecb.isActive();
StudyEventDAO sedao = new StudyEventDAO(getDataSource());
StudyEventBean seb = (StudyEventBean) sedao.findByPK(ecb.getStudyEventId());
seb.setUpdatedDate(now);
seb.setUpdater(ub);
seb = (StudyEventBean) sedao.update(seb);
success = success && seb.isActive();
request.setAttribute(INPUT_IGNORE_PARAMETERS, Boolean.TRUE);
if (newUploadedFiles.size() > 0) {
if (this.unloadFiles(newUploadedFiles)) {
} else {
String missed = "";
Iterator iter = newUploadedFiles.keySet().iterator();
while (iter.hasNext()) {
missed += " " + newUploadedFiles.get(iter.next());
}
addPageMessage(respage.getString("uploaded_files_not_deleted_or_not_exist") + ": " + missed, request);
}
}
if (!success) {
// YW, 3-6-2008 <<
if (updateFailedItems.size() > 0) {
String mess = "";
for (String ss : updateFailedItems) {
mess += ss + ", ";
}
mess = mess.substring(0, mess.length() - 2);
addPageMessage(resexception.getString("item_save_failed_because_database_error") + mess, request);
} else {
// YW>>
addPageMessage(resexception.getString("database_error"), request);
}
request.setAttribute(BEAN_DISPLAY, section);
session.removeAttribute(GROUP_HAS_DATA);
session.removeAttribute(HAS_DATA_FLAG);
session.removeAttribute(DDE_PROGESS);
session.removeAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
LOGGER.debug("try to remove to_create_crf");
session.removeAttribute("to_create_crf");
session.removeAttribute(instantAtt);
// forwardPage(Page.SUBMIT_DATA_SERVLET);
forwardPage(Page.LIST_STUDY_SUBJECTS_SERVLET, request, response);
// >> changed tbh, 06/2009
} else {
boolean forwardingSucceeded = false;
if (!fp.getString(GO_PREVIOUS).equals("")) {
if (previousSec.isActive()) {
forwardingSucceeded = true;
request.setAttribute(INPUT_EVENT_CRF, ecb);
request.setAttribute(INPUT_SECTION, previousSec);
int tabNum = 0;
if (fp.getString("tab") == null) {
tabNum = 1;
} else {
tabNum = fp.getInt("tab");
}
request.setAttribute("tab", new Integer(tabNum - 1).toString());
// forwardPage(getServletPage(request), request, response);
getServletContext().getRequestDispatcher(getServletPage(request)).forward(request, response);
}
} else if (!fp.getString(GO_NEXT).equals("")) {
if (nextSec.isActive()) {
forwardingSucceeded = true;
request.setAttribute(INPUT_EVENT_CRF, ecb);
request.setAttribute(INPUT_SECTION, nextSec);
int tabNum = 0;
if (fp.getString("tab") == null) {
tabNum = 1;
} else {
tabNum = fp.getInt("tab");
}
request.setAttribute("tab", new Integer(tabNum + 1).toString());
getServletContext().getRequestDispatcher(getServletPage(request)).forward(request, response);
//forwardPage(getServletPage(request), request, response);
}
}
if (!forwardingSucceeded) {
// ecb);
if (markSuccessfully) {
addPageMessage(respage.getString("data_saved_CRF_marked_complete"), request);
session.removeAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
session.removeAttribute(GROUP_HAS_DATA);
session.removeAttribute(HAS_DATA_FLAG);
session.removeAttribute(DDE_PROGESS);
session.removeAttribute("to_create_crf");
request.setAttribute("eventId", new Integer(ecb.getStudyEventId()).toString());
forwardPage(Page.ENTER_DATA_FOR_STUDY_EVENT_SERVLET, request, response);
} else {
// use clicked 'save'
addPageMessage(respage.getString("data_saved_continue_entering_edit_later"), request);
request.setAttribute(INPUT_EVENT_CRF, ecb);
request.setAttribute(INPUT_EVENT_CRF_ID, new Integer(ecb.getId()).toString());
// is not the last section
if (!section.isLastSection()) {
request.setAttribute(INPUT_SECTION, nextSec);
request.setAttribute(INPUT_SECTION_ID, new Integer(nextSec.getId()).toString());
session.removeAttribute("mayProcessUploading");
} else if (section.isLastSection()) {
//JN ADDED TO avoid return down
// already the last section, should go back to
// view event page
session.removeAttribute(GROUP_HAS_DATA);
session.removeAttribute(HAS_DATA_FLAG);
session.removeAttribute(DDE_PROGESS);
session.removeAttribute("to_create_crf");
session.removeAttribute("mayProcessUploading");
request.setAttribute("eventId", new Integer(ecb.getStudyEventId()).toString());
if (fromViewNotes != null && "1".equals(fromViewNotes)) {
String viewNotesPageFileName = (String) session.getAttribute("viewNotesPageFileName");
session.removeAttribute("viewNotesPageFileName");
session.removeAttribute("viewNotesURL");
if (viewNotesPageFileName != null && viewNotesPageFileName.length() > 0) {
// forwardPage(Page.setNewPage(viewNotesPageFileName, "View Notes"), request, response);
getServletContext().getRequestDispatcher(viewNotesPageFileName).forward(request, response);
}
}
session.removeAttribute(instantAtt);
forwardPage(Page.ENTER_DATA_FOR_STUDY_EVENT_SERVLET, request, response);
return;
}
int tabNum = 0;
if (fp.getString("tab") == null) {
tabNum = 1;
} else {
tabNum = fp.getInt("tab");
}
if (!section.isLastSection()) {
request.setAttribute("tab", new Integer(tabNum + 1).toString());
}
// forwardPage(getServletPage(request), request, response);
getServletContext().getRequestDispatcher(getServletPage(request)).forward(request, response);
}
// session.removeAttribute(AddNewSubjectServlet.
// FORM_DISCREPANCY_NOTES_NAME);
// forwardPage(Page.SUBMIT_DATA_SERVLET);
}
}
}
// end of if-block for dynamic rules not in same section, tbh 05/2010
}
// end of save
}
}
Also used :
DisplayItemBean(org.akaza.openclinica.bean.submit.DisplayItemBean)
ItemBean(org.akaza.openclinica.bean.submit.ItemBean)
HashMap(java.util.HashMap)
ArrayList(java.util.ArrayList)
StudyEventDefinitionBean(org.akaza.openclinica.bean.managestudy.StudyEventDefinitionBean)
StudyEventBean(org.akaza.openclinica.bean.managestudy.StudyEventBean)
EventCRFBean(org.akaza.openclinica.bean.submit.EventCRFBean)
ItemDataBean(org.akaza.openclinica.bean.submit.ItemDataBean)
TreeSet(java.util.TreeSet)
StudyEventDAO(org.akaza.openclinica.dao.managestudy.StudyEventDAO)
ScoreCalculator(org.akaza.openclinica.logic.score.ScoreCalculator)
DiscrepancyNoteUtil(org.akaza.openclinica.service.DiscrepancyNoteUtil)
DynamicsMetadataService(org.akaza.openclinica.service.crfdata.DynamicsMetadataService)
StudyDAO(org.akaza.openclinica.dao.managestudy.StudyDAO)
Status(org.akaza.openclinica.bean.core.Status)
ResolutionStatus(org.akaza.openclinica.bean.core.ResolutionStatus)
SubjectEventStatus(org.akaza.openclinica.bean.core.SubjectEventStatus)
Validation(org.akaza.openclinica.control.form.Validation)
DiscrepancyNoteDAO(org.akaza.openclinica.dao.managestudy.DiscrepancyNoteDAO)
CRFVersionDAO(org.akaza.openclinica.dao.submit.CRFVersionDAO)
FormDiscrepancyNotes(org.akaza.openclinica.control.form.FormDiscrepancyNotes)
FormProcessor(org.akaza.openclinica.control.form.FormProcessor)
DisplayItemWithGroupBean(org.akaza.openclinica.bean.submit.DisplayItemWithGroupBean)
StudyBean(org.akaza.openclinica.bean.managestudy.StudyBean)
EventDefinitionCRFDAO(org.akaza.openclinica.dao.managestudy.EventDefinitionCRFDAO)
UserAccountDAO(org.akaza.openclinica.dao.login.UserAccountDAO)
InconsistentStateException(org.akaza.openclinica.web.InconsistentStateException)
DataEntryStage(org.akaza.openclinica.bean.core.DataEntryStage)
SectionBean(org.akaza.openclinica.bean.submit.SectionBean)
DisplaySectionBean(org.akaza.openclinica.bean.submit.DisplaySectionBean)
SubjectBean(org.akaza.openclinica.bean.submit.SubjectBean)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
ScoreItemValidator(org.akaza.openclinica.control.form.ScoreItemValidator)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
StudyEventDefinitionDAO(org.akaza.openclinica.dao.managestudy.StudyEventDefinitionDAO)
DiscrepancyNoteBean(org.akaza.openclinica.bean.managestudy.DiscrepancyNoteBean)
EventDefinitionCRFBean(org.akaza.openclinica.bean.managestudy.EventDefinitionCRFBean)
Map(java.util.Map)
HashMap(java.util.HashMap)
SectionDAO(org.akaza.openclinica.dao.submit.SectionDAO)
Phase(org.akaza.openclinica.domain.rule.action.RuleActionRunBean.Phase)
Set(java.util.Set)
TreeSet(java.util.TreeSet)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
SubjectDAO(org.akaza.openclinica.dao.submit.SubjectDAO)
ItemDataDAO(org.akaza.openclinica.dao.submit.ItemDataDAO)
UserAccountBean(org.akaza.openclinica.bean.login.UserAccountBean)
Iterator(java.util.Iterator)
DisplayItemBean(org.akaza.openclinica.bean.submit.DisplayItemBean)
EventCRFDAO(org.akaza.openclinica.dao.submit.EventCRFDAO)
DiscrepancyNoteThread(org.akaza.openclinica.service.DiscrepancyNoteThread)
DisplayItemGroupBean(org.akaza.openclinica.bean.submit.DisplayItemGroupBean)
HttpSession(javax.servlet.http.HttpSession)
SessionManager(org.akaza.openclinica.core.SessionManager)
StudyUserRoleBean(org.akaza.openclinica.bean.login.StudyUserRoleBean)
DisplayTableOfContentsBean(org.akaza.openclinica.bean.submit.DisplayTableOfContentsBean)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
ResponseOptionBean(org.akaza.openclinica.bean.submit.ResponseOptionBean)
Date(java.util.Date)
DisplaySectionBean(org.akaza.openclinica.bean.submit.DisplaySectionBean)
DiscrepancyValidator(org.akaza.openclinica.control.form.DiscrepancyValidator)
SimpleConditionalDisplayService(org.akaza.openclinica.service.crfdata.SimpleConditionalDisplayService)
SimpleDateFormat(java.text.SimpleDateFormat)
DateFormat(java.text.DateFormat)
CRFVersionBean(org.akaza.openclinica.bean.submit.CRFVersionBean)
SimpleDateFormat(java.text.SimpleDateFormat)
DynamicsItemFormMetadataBean(org.akaza.openclinica.domain.crfdata.DynamicsItemFormMetadataBean)
ItemFormMetadataBean(org.akaza.openclinica.bean.submit.ItemFormMetadataBean)
RuleSetBean(org.akaza.openclinica.domain.rule.RuleSetBean)
RuleValidator(org.akaza.openclinica.control.form.RuleValidator)
Example 3 with DiscrepancyValidator
use of org.akaza.openclinica.control.form.DiscrepancyValidator in project OpenClinica by OpenClinica.
the class UpdateSubjectServlet method confirm.
/**
* Processes 'confirm' request, validate the subject object
*
* @throws Exception
*/
private void confirm(SubjectBean subject, int subjectId) throws Exception {
FormDiscrepancyNotes discNotes = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
if (discNotes == null) {
discNotes = new FormDiscrepancyNotes();
}
DiscrepancyValidator v = new DiscrepancyValidator(request, discNotes);
FormProcessor fp = new FormProcessor(request);
if (currentStudy.getStudyParameterConfig().getPersonIdShownOnCRF().equals("true")) {
v.addValidation("uniqueIdentifier", Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 255);
v.alwaysExecuteLastValidation("uniqueIdentifier");
}
String personId = fp.getString(INPUT_UNIQUE_IDENTIFIER);
if (personId.contains("<") || personId.contains(">")) {
v.addValidation("uniqueIdentifier", Validator.DOES_NOT_CONTAIN_HTML_LESSTHAN_GREATERTHAN_ELEMENTS);
}
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("1")) {
if (!StringUtil.isBlank(fp.getString(DATE_DOB))) {
v.addValidation(DATE_DOB, Validator.IS_A_DATE);
v.alwaysExecuteLastValidation(DATE_DOB);
} else if (StringUtil.isBlank(fp.getString(DATE_DOB)) && subject.getDateOfBirth() != null) {
Validator.addError(errors, DATE_DOB, resexception.getString("field_not_blank"));
}
if (fp.getDate(DATE_DOB) != null) {
subject.setDateOfBirth(fp.getDate(DATE_DOB));
String converted_date = local_df.format(subject.getDateOfBirth());
request.setAttribute(DATE_DOB_TO_SAVE, converted_date);
}
} else if (currentStudy.getStudyParameterConfig().getCollectDob().equals("2")) {
if (!StringUtils.isBlank(fp.getString(DATE_DOB))) {
// if DOB was not updated (and originally entered as a full day, post it as is
String submitted_date = fp.getString(DATE_DOB);
boolean isTheSameDate = false;
try {
Date fakeDOB = yformat.parse(submitted_date);
if (subject.getDateOfBirth() != null) {
if (subject.getDateOfBirth().getYear() == (fakeDOB.getYear())) {
isTheSameDate = true;
String converted_date = yformat.format(subject.getDateOfBirth());
request.setAttribute(DATE_DOB_TO_SAVE, converted_date);
}
}
} catch (ParseException pe) {
logger.debug("update subject: cannot convert date " + submitted_date);
//I am putting on Pradnya's request the link to code review with a long discussion
//about what type of logging should be here: enjoy
//https://dev.openclinica.com/crucible/cru/OC-117
}
if (!isTheSameDate) {
v.addValidation(DATE_DOB, Validator.IS_AN_INTEGER);
v.alwaysExecuteLastValidation(DATE_DOB);
v.addValidation(DATE_DOB, Validator.COMPARES_TO_STATIC_VALUE, NumericComparisonOperator.GREATER_THAN_OR_EQUAL_TO, 1000);
// get today's year
Date today = new Date();
Calendar c = Calendar.getInstance();
c.setTime(today);
int currentYear = c.get(Calendar.YEAR);
v.addValidation(DATE_DOB, Validator.COMPARES_TO_STATIC_VALUE, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, currentYear);
int yob = fp.getInt(DATE_DOB);
Date fakeDate = new Date(yob);
String dobString = yformat.format(fakeDate);
try {
Date fakeDOB = yformat.parse(dobString);
if (yob != 0) {
subject.setDateOfBirth(fakeDOB);
}
request.setAttribute(DATE_DOB_TO_SAVE, yob);
} catch (ParseException pe) {
logger.debug("Parse exception happened.");
//I am putting on Pradnya's request the link to code review with a long discussion
//about what type of logging should be here: enjoy
//https://dev.openclinica.com/crucible/cru/OC-117
Validator.addError(errors, DATE_DOB, resexception.getString("please_enter_a_valid_year_birth"));
}
}
request.setAttribute(DATE_DOB, fp.getString(DATE_DOB));
} else {
Validator.addError(errors, DATE_DOB, resexception.getString("field_not_blank"));
}
}
errors = v.validate();
// uniqueIdentifier must be unique in the system
if (currentStudy.getStudyParameterConfig().getSubjectPersonIdRequired().equals("required") || currentStudy.getStudyParameterConfig().getSubjectPersonIdRequired().equals("optional")) {
String uniqueIdentifier = fp.getString("uniqueIdentifier");
if (currentStudy.getStudyParameterConfig().getSubjectPersonIdRequired().equals("required") && !(subject.getUniqueIdentifier() == null || subject.getUniqueIdentifier().isEmpty()) && (uniqueIdentifier == null || uniqueIdentifier.isEmpty())) {
Validator.addError(errors, "uniqueIdentifier", resexception.getString("field_not_blank"));
}
if (uniqueIdentifier != null && !uniqueIdentifier.isEmpty()) {
if (uniqueIdentifier.length() > 255) {
String descr = resexception.getString("input_provided_is_not") + NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO.getDescription() + " 255 " + resword.getString("characters_long") + ".";
Validator.addError(errors, "uniqueIdentifier", descr);
}
SubjectDAO sdao = new SubjectDAO(sm.getDataSource());
SubjectBean sub1 = (SubjectBean) sdao.findAnotherByIdentifier(uniqueIdentifier, subject.getId());
if (sub1.getId() > 0) {
Validator.addError(errors, "uniqueIdentifier", resexception.getString("person_ID_used_by_another_choose_unique"));
}
SubjectBean subjectWithSameId = sdao.findByUniqueIdentifier(uniqueIdentifier);
if (subjectWithSameId.isActive() && subjectWithSameId.getId() != subject.getId()) {
Validator.addError(errors, "uniqueIdentifier", resexception.getString("another_assigned_this_ID_choose_unique"));
}
}
subject.setUniqueIdentifier(uniqueIdentifier);
}
if (!StringUtil.isBlank(fp.getString("gender"))) {
subject.setGender(fp.getString("gender").charAt(0));
} else {
if (currentStudy.getStudyParameterConfig().getGenderRequired().equals("true") && subject.getGender() != ' ') {
Validator.addError(errors, "gender", resexception.getString("field_not_blank"));
}
subject.setGender(' ');
}
request.setAttribute("subjectToUpdate", subject);
if (errors.isEmpty()) {
forwardPage(Page.UPDATE_SUBJECT_CONFIRM);
} else {
//I am putting on Pradnya's request the link to code review with a long discussion
//about what type of logging should be here: enjoy
//https://dev.openclinica.com/crucible/cru/OC-117
logger.error("update subject validation errors");
setInputMessages(errors);
setDNFlag(subjectId);
setLocalDOB(subject);
if (currentStudy.getStudyParameterConfig().getCollectDob().equals("2"))
request.setAttribute("localBirthDate", "");
forwardPage(Page.UPDATE_SUBJECT);
}
}
Also used :
SubjectBean(org.akaza.openclinica.bean.submit.SubjectBean)
DiscrepancyValidator(org.akaza.openclinica.control.form.DiscrepancyValidator)
FormDiscrepancyNotes(org.akaza.openclinica.control.form.FormDiscrepancyNotes)
FormProcessor(org.akaza.openclinica.control.form.FormProcessor)
SubjectDAO(org.akaza.openclinica.dao.submit.SubjectDAO)
Calendar(java.util.Calendar)
ParseException(java.text.ParseException)
Date(java.util.Date)
Example 4 with DiscrepancyValidator
use of org.akaza.openclinica.control.form.DiscrepancyValidator in project OpenClinica by OpenClinica.
the class CreateNewStudyEventServlet method processRequest.
@Override
protected void processRequest() throws Exception {
checkStudyLocked(Page.LIST_STUDY_SUBJECTS, respage.getString("current_study_locked"));
panel.setStudyInfoShown(false);
fp = new FormProcessor(request);
FormDiscrepancyNotes discNotes = null;
int studySubjectId = fp.getInt(INPUT_STUDY_SUBJECT_ID_FROM_VIEWSUBJECT);
// input from manage subject matrix, user has specified definition id
int studyEventDefinitionId = fp.getInt(INPUT_STUDY_EVENT_DEFINITION);
// TODO: make this sensitive to permissions
StudySubjectDAO sdao = new StudySubjectDAO(sm.getDataSource());
StudySubjectBean ssb;
if (studySubjectId <= 0) {
ssb = (StudySubjectBean) request.getAttribute(INPUT_STUDY_SUBJECT);
} else {
// YW 11-08-2007, << a new study event could not be added if its
// study subject has been removed
ssb = (StudySubjectBean) sdao.findByPK(studySubjectId);
Status s = ssb.getStatus();
if ("removed".equalsIgnoreCase(s.getName()) || "auto-removed".equalsIgnoreCase(s.getName())) {
addPageMessage(resword.getString("study_event") + resterm.getString("could_not_be") + resterm.getString("added") + "." + respage.getString("study_subject_has_been_deleted"));
request.setAttribute("id", new Integer(studySubjectId).toString());
forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
}
// YW >>
request.setAttribute(INPUT_REQUEST_STUDY_SUBJECT, "no");
}
// running this crashes the server, or so we think...instead, let's grab a count
// or remove it altogether tbh 10/2009
// ArrayList subjects = sdao.findAllActiveByStudyOrderByLabel(currentStudy);
// TODO: make this sensitive to permissions
StudyEventDefinitionDAO seddao = new StudyEventDefinitionDAO(sm.getDataSource());
StudyBean studyWithEventDefinitions = currentStudy;
if (currentStudy.getParentStudyId() > 0) {
studyWithEventDefinitions = new StudyBean();
studyWithEventDefinitions.setId(currentStudy.getParentStudyId());
}
// find all active definitions with CRFs
ArrayList eventDefinitions = seddao.findAllActiveByStudy(studyWithEventDefinitions);
// EventDefinitionCRFDAO edcdao = new
// EventDefinitionCRFDAO(sm.getDataSource());
// ArrayList definitionsWithCRF = new ArrayList();
// for (int i=0; i<eventDefinitions.size(); i++) {
// StudyEventDefinitionBean sed =
// (StudyEventDefinitionBean)eventDefinitions.get(i);
// logger.info("StudyEventDefinition name[" + sed.getName() + "]");
// ArrayList edcs = edcdao.findAllByEventDefinitionId(sed.getId());
// if (!edcs.isEmpty()) {
// definitionsWithCRF.add(sed);
// }
// }
// Collections.sort(definitionsWithCRF);
Collections.sort(eventDefinitions);
/*
* ArrayList eventDefinitionsScheduled = new ArrayList(); for (int i =
* 0; i < eventDefinitions.size(); i++) { StudyEventDefinitionBean sed =
* (StudyEventDefinitionBean) eventDefinitions.get(i); if
* (sed.getType().equalsIgnoreCase("scheduled")) {
* eventDefinitionsScheduled.add(sed); } }
*/
// all definitions will appear in scheduled event creation box-11/26/05
ArrayList eventDefinitionsScheduled = eventDefinitions;
if (!fp.isSubmitted()) {
// StudyEventDAO sed = new StudyEventDAO(sm.getDataSource());
// sed.updateSampleOrdinals_v092();
HashMap presetValues = new HashMap();
// YW 08-16-2007 << set default as blank for time
presetValues.put(INPUT_STARTDATE_PREFIX + "Hour", new Integer(-1));
presetValues.put(INPUT_STARTDATE_PREFIX + "Minute", new Integer(-1));
presetValues.put(INPUT_STARTDATE_PREFIX + "Half", new String(""));
presetValues.put(INPUT_ENDDATE_PREFIX + "Hour", new Integer(-1));
presetValues.put(INPUT_ENDDATE_PREFIX + "Minute", new Integer(-1));
presetValues.put(INPUT_ENDDATE_PREFIX + "Half", new String(""));
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Hour", new Integer(-1));
presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Minute", new Integer(-1));
presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Half", new String(""));
presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Hour", new Integer(-1));
presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Minute", new Integer(-1));
presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Half", new String(""));
}
// SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
// example of taking the above line and transferring to i18n on the
// below line, tbh
String dateValue = local_df.format(new Date(System.currentTimeMillis()));
presetValues.put(INPUT_STARTDATE_PREFIX + "Date", dateValue);
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date", dateValue);
// location
presetValues.put(INPUT_SCHEDULED_LOCATION[i], currentStudy.getFacilityCity());
presetValues.put(this.DISPLAY_SCHEDULED[i], "none");
}
// defualt
presetValues.put(INPUT_LOCATION, currentStudy.getFacilityCity());
if (ssb != null && ssb.isActive()) {
presetValues.put(INPUT_STUDY_SUBJECT, ssb);
String requestStudySubject = (String) request.getAttribute(INPUT_REQUEST_STUDY_SUBJECT);
if (requestStudySubject != null) {
presetValues.put(INPUT_REQUEST_STUDY_SUBJECT, requestStudySubject);
dateValue = local_df.format(new Date());
presetValues.put(INPUT_STARTDATE_PREFIX + "Date", dateValue);
}
}
if (studyEventDefinitionId > 0) {
StudyEventDefinitionBean sed = (StudyEventDefinitionBean) seddao.findByPK(studyEventDefinitionId);
presetValues.put(INPUT_STUDY_EVENT_DEFINITION, sed);
}
// tbh
logger.debug("set preset values: " + presetValues.toString());
logger.debug("found def.w.CRF list, size " + eventDefinitions.size());
// tbh
setPresetValues(presetValues);
ArrayList subjects = new ArrayList();
setupBeans(subjects, eventDefinitions);
discNotes = new FormDiscrepancyNotes();
session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
request.setAttribute("eventDefinitionsScheduled", eventDefinitionsScheduled);
setInputMessages(new HashMap());
forwardPage(Page.CREATE_NEW_STUDY_EVENT);
} else {
// tbh
// String dateCheck = (String)request.getAttribute("startDate");
// String endCheck = (String)request.getAttribute("endDate");
// logger.debug(dateCheck+"; "+endCheck);
String dateCheck2 = request.getParameter("startDate");
String endCheck2 = request.getParameter("endDate");
logger.debug(dateCheck2 + "; " + endCheck2);
// YW, 3-12-2008, 2220 fix <<
String strEnd = fp.getDateTimeInputString(INPUT_ENDDATE_PREFIX);
String[] strEndScheduled = new String[ADDITIONAL_SCHEDULED_NUM];
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
strEndScheduled[i] = fp.getDateTimeInputString(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
}
Date start = getInputStartDate();
Date end = null;
Date[] startScheduled = new Date[ADDITIONAL_SCHEDULED_NUM];
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
startScheduled[i] = getInputStartDateScheduled(i);
}
Date[] endScheduled = new Date[ADDITIONAL_SCHEDULED_NUM];
// YW >>
// for (java.util.Enumeration enu = request.getAttributeNames();
// enu.hasMoreElements() ;) {
// logger.debug(">>> found "+enu.nextElement().toString());
// }
// tbh
discNotes = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
if (discNotes == null) {
discNotes = new FormDiscrepancyNotes();
session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
}
DiscrepancyValidator v = new DiscrepancyValidator(request, discNotes);
v.addValidation(INPUT_STARTDATE_PREFIX, Validator.IS_DATE_TIME);
v.alwaysExecuteLastValidation(INPUT_STARTDATE_PREFIX);
if (!strEnd.equals("")) {
v.addValidation(INPUT_ENDDATE_PREFIX, Validator.IS_DATE_TIME);
v.alwaysExecuteLastValidation(INPUT_ENDDATE_PREFIX);
}
v.addValidation(INPUT_STUDY_EVENT_DEFINITION, Validator.ENTITY_EXISTS_IN_STUDY, seddao, studyWithEventDefinitions);
// v.addValidation(INPUT_STUDY_SUBJECT, Validator.ENTITY_EXISTS_IN_STUDY, sdao, currentStudy);
// removed tbh 11/2009
//Made optional field-issue-4904.
//v.addValidation(INPUT_LOCATION, Validator.NO_BLANKS);
v.addValidation(INPUT_STUDY_SUBJECT_LABEL, Validator.NO_BLANKS);
v.addValidation(INPUT_LOCATION, Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 2000);
if (currentStudy.getStudyParameterConfig().getEventLocationRequired().equalsIgnoreCase("required")) {
v.addValidation(INPUT_LOCATION, Validator.NO_BLANKS);
}
v.alwaysExecuteLastValidation(INPUT_LOCATION);
boolean hasScheduledEvent = false;
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
if (!StringUtil.isBlank(fp.getString(this.INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i]))) {
// logger.debug("has scheduled definition******");
v.addValidation(this.INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i], Validator.ENTITY_EXISTS_IN_STUDY, seddao, studyWithEventDefinitions);
if (currentStudy.getStudyParameterConfig().getEventLocationRequired().equalsIgnoreCase("required")) {
v.addValidation(INPUT_SCHEDULED_LOCATION[i], Validator.NO_BLANKS);
v.addValidation(INPUT_SCHEDULED_LOCATION[i], Validator.LENGTH_NUMERIC_COMPARISON, NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO, 2000);
v.alwaysExecuteLastValidation(INPUT_SCHEDULED_LOCATION[i]);
}
v.addValidation(INPUT_STARTDATE_PREFIX_SCHEDULED[i], Validator.IS_DATE_TIME);
v.alwaysExecuteLastValidation(INPUT_STARTDATE_PREFIX_SCHEDULED[i]);
if (!strEndScheduled[i].equals("")) {
v.addValidation(INPUT_ENDDATE_PREFIX_SCHEDULED[i], Validator.IS_DATE_TIME);
v.alwaysExecuteLastValidation(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
}
hasScheduledEvent = true;
fp.addPresetValue(DISPLAY_SCHEDULED[i], "all");
} else {
fp.addPresetValue(DISPLAY_SCHEDULED[i], "none");
}
}
HashMap errors = v.validate();
// logger.debug("v is not null *****");
String location = resword.getString("location");
// is a required field
if (!StringUtil.isBlank(fp.getString(INPUT_LOCATION)) && fp.getString(INPUT_LOCATION).equalsIgnoreCase(location)) {
Validator.addError(errors, INPUT_LOCATION, restext.getString("not_a_valid_location"));
}
StudyEventDefinitionBean definition = (StudyEventDefinitionBean) seddao.findByPK(fp.getInt(INPUT_STUDY_EVENT_DEFINITION));
// StudySubjectBean studySubject = (StudySubjectBean) sdao.findByPK(fp.getInt(INPUT_STUDY_SUBJECT));
// sdao.findByLabelAndStudy(label, study)
StudySubjectBean studySubject = sdao.findByLabelAndStudy(fp.getString(INPUT_STUDY_SUBJECT_LABEL), currentStudy);
// what if we are sent here from AddNewSubjectServlet.java??? we need to get that study subject bean
if (request.getAttribute(INPUT_STUDY_SUBJECT) != null) {
studySubject = (StudySubjectBean) request.getAttribute(INPUT_STUDY_SUBJECT);
}
// << tbh
if (studySubject.getLabel() == "") {
// add an error here, tbh
Validator.addError(errors, INPUT_STUDY_SUBJECT, respage.getString("must_enter_subject_ID_for_identifying"));
}
if (!subjectMayReceiveStudyEvent(sm.getDataSource(), definition, studySubject)) {
Validator.addError(errors, INPUT_STUDY_EVENT_DEFINITION, restext.getString("not_added_since_event_not_repeating"));
}
ArrayList<StudyEventDefinitionBean> definitionScheduleds = new ArrayList<StudyEventDefinitionBean>();
int[] scheduledDefinitionIds = new int[ADDITIONAL_SCHEDULED_NUM];
if (hasScheduledEvent) {
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
int pk = fp.getInt(INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i]);
if (pk > 0) {
StudyEventDefinitionBean sedb = (StudyEventDefinitionBean) seddao.findByPK(pk);
logger.debug("scheduled def:" + pk + " " + INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i] + " " + sedb.getName());
definitionScheduleds.add(sedb);
scheduledDefinitionIds[i] = pk;
if (!subjectMayReceiveStudyEvent(sm.getDataSource(), sedb, studySubject)) {
Validator.addError(errors, INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i], restext.getString("not_added_since_event_not_repeating"));
}
} else {
definitionScheduleds.add(new StudyEventDefinitionBean());
}
}
}
// YW, 3-12-2008, 2220 fix >>
if (!"".equals(strEnd) && !errors.containsKey(INPUT_STARTDATE_PREFIX) && !errors.containsKey(INPUT_ENDDATE_PREFIX)) {
end = getInputEndDate();
if (!fp.getString(INPUT_STARTDATE_PREFIX + "Date").equals(fp.getString(INPUT_ENDDATE_PREFIX + "Date"))) {
if (end.before(start)) {
Validator.addError(errors, INPUT_ENDDATE_PREFIX, resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
} else {
// if in same date, only check when both had time entered
if (fp.timeEntered(INPUT_STARTDATE_PREFIX) && fp.timeEntered(INPUT_ENDDATE_PREFIX)) {
if (end.before(start) || end.equals(start)) {
Validator.addError(errors, INPUT_ENDDATE_PREFIX, resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
}
}
}
String prevStartPrefix = INPUT_STARTDATE_PREFIX;
Set<Integer> pickedSeds = new TreeSet<Integer>();
pickedSeds.add(studyEventDefinitionId);
HashMap<Integer, Integer> scheduledSeds = new HashMap<Integer, Integer>();
scheduledSeds.put(studyEventDefinitionId, -1);
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
if (scheduledDefinitionIds[i] > 0 && !errors.containsKey(INPUT_STARTDATE_PREFIX_SCHEDULED[i]) && !errors.containsKey(INPUT_ENDDATE_PREFIX_SCHEDULED[i])) {
if (scheduledSeds.containsKey(scheduledDefinitionIds[i])) {
int prevStart = scheduledSeds.get(scheduledDefinitionIds[i]);
prevStartPrefix = prevStart == -1 ? INPUT_STARTDATE_PREFIX : INPUT_STARTDATE_PREFIX_SCHEDULED[prevStart];
Date prevStartDate = prevStart == -1 ? this.getInputStartDate() : this.getInputStartDateScheduled(Integer.parseInt(prevStartPrefix.charAt(prevStartPrefix.length() - 1) + ""));
if (fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date").equals(fp.getString(prevStartPrefix + "Date"))) {
// if in same day, only check when both have time
// inputs.
boolean schStartTime = fp.timeEntered(INPUT_STARTDATE_PREFIX_SCHEDULED[i]);
boolean startTime = fp.timeEntered(prevStartPrefix);
if (schStartTime && startTime) {
if (startScheduled[i].before(prevStartDate)) {
Validator.addError(errors, INPUT_STARTDATE_PREFIX_SCHEDULED[i], resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
}
} else {
if (startScheduled[i].before(prevStartDate)) {
Validator.addError(errors, INPUT_STARTDATE_PREFIX_SCHEDULED[i], resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
}
}
scheduledSeds.put(scheduledDefinitionIds[i], i);
if (!strEndScheduled[i].equals("")) {
endScheduled[i] = fp.getDateTime(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
String prevEndPrefix = i > 0 ? INPUT_ENDDATE_PREFIX_SCHEDULED[i - 1] : INPUT_ENDDATE_PREFIX;
if (!fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date").equals(fp.getString(prevEndPrefix + "Date"))) {
if (endScheduled[i].before(startScheduled[i])) {
Validator.addError(errors, INPUT_ENDDATE_PREFIX_SCHEDULED[i], resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
} else {
// entered
if (fp.timeEntered(INPUT_STARTDATE_PREFIX_SCHEDULED[i]) && fp.timeEntered(INPUT_ENDDATE_PREFIX_SCHEDULED[i])) {
if (endScheduled[i].before(startScheduled[i]) || endScheduled[i].equals(startScheduled[i])) {
Validator.addError(errors, INPUT_ENDDATE_PREFIX_SCHEDULED[i], resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
}
}
}
}
}
}
// YW >>
logger.error("we have errors; number of this; " + errors.size());
if (!errors.isEmpty()) {
logger.debug("we have errors; number of this; " + errors.size());
logger.error("found request study subject: " + fp.getString(INPUT_REQUEST_STUDY_SUBJECT));
addPageMessage(respage.getString("errors_in_submission_see_below"));
setInputMessages(errors);
fp.addPresetValue(INPUT_STUDY_EVENT_DEFINITION, definition);
fp.addPresetValue(INPUT_STUDY_SUBJECT, studySubject);
fp.addPresetValue(INPUT_STUDY_SUBJECT_LABEL, fp.getString(INPUT_STUDY_SUBJECT_LABEL));
fp.addPresetValue(INPUT_REQUEST_STUDY_SUBJECT, fp.getString(INPUT_REQUEST_STUDY_SUBJECT));
fp.addPresetValue(INPUT_LOCATION, fp.getString(INPUT_LOCATION));
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
fp.addPresetValue(INPUT_SCHEDULED_LOCATION[i], fp.getString(INPUT_SCHEDULED_LOCATION[i]));
}
String[] prefixes = new String[2 + 2 * ADDITIONAL_SCHEDULED_NUM];
prefixes[0] = INPUT_STARTDATE_PREFIX;
prefixes[1] = INPUT_ENDDATE_PREFIX;
int b = ADDITIONAL_SCHEDULED_NUM + 2;
for (int i = 2; i < b; ++i) {
prefixes[i] = INPUT_STARTDATE_PREFIX_SCHEDULED[i - 2];
}
for (int i = b; i < ADDITIONAL_SCHEDULED_NUM + b; ++i) {
prefixes[i] = INPUT_ENDDATE_PREFIX_SCHEDULED[i - b];
}
fp.setCurrentDateTimeValuesAsPreset(prefixes);
if (hasScheduledEvent) {
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
fp.addPresetValue(INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i], definitionScheduleds.get(i));
}
}
setPresetValues(fp.getPresetValues());
ArrayList subjects = new ArrayList();
setupBeans(subjects, eventDefinitions);
request.setAttribute("eventDefinitionsScheduled", eventDefinitionsScheduled);
forwardPage(Page.CREATE_NEW_STUDY_EVENT);
} else {
logger.debug("error is empty");
StudyEventDAO sed = new StudyEventDAO(sm.getDataSource());
StudyEventBean studyEvent = new StudyEventBean();
studyEvent.setStudyEventDefinitionId(definition.getId());
studyEvent.setStudySubjectId(studySubject.getId());
// YW 08-17-2007 <<
if ("-1".equals(getInputStartHour()) && "-1".equals(getInputStartMinute()) && "".equals(getInputStartHalf())) {
studyEvent.setStartTimeFlag(false);
} else {
studyEvent.setStartTimeFlag(true);
}
// YW >>
studyEvent.setDateStarted(start);
// comment to find bug 1389, tbh
logger.debug("found start date: " + local_df.format(start));
Date[] startScheduled2 = new Date[ADDITIONAL_SCHEDULED_NUM];
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
startScheduled2[i] = getInputStartDateScheduled(i);
}
// YW, 3-12-2008, 2220 fix <<
if (!"".equals(strEnd)) {
// YW >>
if ("-1".equals(getInputEndHour()) && "-1".equals(getInputEndMinute()) && "".equals(getInputEndHalf())) {
studyEvent.setEndTimeFlag(false);
} else {
studyEvent.setEndTimeFlag(true);
}
studyEvent.setDateEnded(end);
}
studyEvent.setOwner(ub);
studyEvent.setStatus(Status.AVAILABLE);
studyEvent.setLocation(fp.getString(INPUT_LOCATION));
studyEvent.setSubjectEventStatus(SubjectEventStatus.SCHEDULED);
// ArrayList subjectsExistingEvents =
// sed.findAllByStudyAndStudySubjectId(currentStudy,
// studySubject.getId());
studyEvent.setSampleOrdinal(sed.getMaxSampleOrdinal(definition, studySubject) + 1);
studyEvent = (StudyEventBean) sed.create(studyEvent);
if (!studyEvent.isActive()) {
throw new OpenClinicaException(restext.getString("event_not_created_in_database"), "2");
}
addPageMessage(restext.getString("X_event_wiht_definition") + definition.getName() + restext.getString("X_and_subject") + studySubject.getName() + respage.getString("X_was_created_succesfully"));
// save discrepancy notes into DB
FormDiscrepancyNotes fdn = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(sm.getDataSource());
String[] eventFields = { INPUT_LOCATION, INPUT_STARTDATE_PREFIX, INPUT_ENDDATE_PREFIX };
for (String element : eventFields) {
AddNewSubjectServlet.saveFieldNotes(element, fdn, dndao, studyEvent.getId(), "studyEvent", currentStudy);
}
// logger.debug("here ok 3333333333333333");
if (hasScheduledEvent) {
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
// which is scheduledDefinitionIds[i] > 0
if (scheduledDefinitionIds[i] > 0) {
if (subjectMayReceiveStudyEvent(sm.getDataSource(), definitionScheduleds.get(i), studySubject)) {
StudyEventBean studyEventScheduled = new StudyEventBean();
studyEventScheduled.setStudyEventDefinitionId(scheduledDefinitionIds[i]);
studyEventScheduled.setStudySubjectId(studySubject.getId());
// YW 11-14-2007
if ("-1".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Hour")) && "-1".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Minute")) && "".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Half"))) {
studyEventScheduled.setStartTimeFlag(false);
} else {
studyEventScheduled.setStartTimeFlag(true);
}
// YW >>
studyEventScheduled.setDateStarted(startScheduled[i]);
// YW, 3-12-2008, 2220 fix<<
if (!"".equals(strEndScheduled[i])) {
endScheduled[i] = fp.getDateTime(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
if ("-1".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Hour")) && "-1".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Minute")) && "".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Half"))) {
studyEventScheduled.setEndTimeFlag(false);
} else {
studyEventScheduled.setEndTimeFlag(true);
}
}
studyEventScheduled.setDateEnded(endScheduled[i]);
// YW >>
studyEventScheduled.setOwner(ub);
studyEventScheduled.setStatus(Status.AVAILABLE);
studyEventScheduled.setLocation(fp.getString(INPUT_SCHEDULED_LOCATION[i]));
studyEvent.setSubjectEventStatus(SubjectEventStatus.SCHEDULED);
// subjectsExistingEvents =
// sed.findAllByStudyAndStudySubjectId(
// currentStudy,
// studySubject.getId());
studyEventScheduled.setSampleOrdinal(sed.getMaxSampleOrdinal(definitionScheduleds.get(i), studySubject) + 1);
//System.out.println("create scheduled events");
studyEventScheduled = (StudyEventBean) sed.create(studyEventScheduled);
if (!studyEventScheduled.isActive()) {
throw new OpenClinicaException(restext.getString("scheduled_event_not_created_in_database"), "2");
}
AddNewSubjectServlet.saveFieldNotes(INPUT_SCHEDULED_LOCATION[i], fdn, dndao, studyEventScheduled.getId(), "studyEvent", currentStudy);
// YW 3-12-2008, 2220 fix <<
AddNewSubjectServlet.saveFieldNotes(INPUT_STARTDATE_PREFIX_SCHEDULED[i], fdn, dndao, studyEventScheduled.getId(), "studyEvent", currentStudy);
AddNewSubjectServlet.saveFieldNotes(INPUT_ENDDATE_PREFIX_SCHEDULED[i], fdn, dndao, studyEventScheduled.getId(), "studyEvent", currentStudy);
// YW >>
} else {
addPageMessage(restext.getString("scheduled_event_definition") + definitionScheduleds.get(i).getName() + restext.getString("X_and_subject") + studySubject.getName() + restext.getString("not_created_since_event_not_repeating") + restext.getString("event_type_already_exists"));
}
}
}
}
// if
session.removeAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
request.setAttribute(EnterDataForStudyEventServlet.INPUT_EVENT_ID, String.valueOf(studyEvent.getId()));
ArrayList<String> pMessage = (ArrayList<String>) request.getAttribute(SecureController.PAGE_MESSAGE);
String url = response.encodeRedirectURL("EnterDataForStudyEvent?eventId=" + studyEvent.getId() + "&alertmessage=" + URLEncoder.encode(pMessage.get(0), "UTF-8"));
response.sendRedirect(url);
// + studyEvent.getId()));
return;
}
}
}
Also used :
HashMap(java.util.HashMap)
ArrayList(java.util.ArrayList)
StudyEventDefinitionBean(org.akaza.openclinica.bean.managestudy.StudyEventDefinitionBean)
StudyEventBean(org.akaza.openclinica.bean.managestudy.StudyEventBean)
OpenClinicaException(org.akaza.openclinica.exception.OpenClinicaException)
TreeSet(java.util.TreeSet)
StudyEventDAO(org.akaza.openclinica.dao.managestudy.StudyEventDAO)
Status(org.akaza.openclinica.bean.core.Status)
SubjectEventStatus(org.akaza.openclinica.bean.core.SubjectEventStatus)
DiscrepancyNoteDAO(org.akaza.openclinica.dao.managestudy.DiscrepancyNoteDAO)
FormDiscrepancyNotes(org.akaza.openclinica.control.form.FormDiscrepancyNotes)
FormProcessor(org.akaza.openclinica.control.form.FormProcessor)
StudyBean(org.akaza.openclinica.bean.managestudy.StudyBean)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
Date(java.util.Date)
DiscrepancyValidator(org.akaza.openclinica.control.form.DiscrepancyValidator)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
StudyEventDefinitionDAO(org.akaza.openclinica.dao.managestudy.StudyEventDefinitionDAO)
Example 5 with DiscrepancyValidator
use of org.akaza.openclinica.control.form.DiscrepancyValidator in project OpenClinica by OpenClinica.
the class ImportCRFDataService method lookupValidationErrors.
public List<DisplayItemBeanWrapper> lookupValidationErrors(HttpServletRequest request, ODMContainer odmContainer, UserAccountBean ub, HashMap<String, String> totalValidationErrors, HashMap<String, String> hardValidationErrors, ArrayList<Integer> permittedEventCRFIds) throws OpenClinicaException {
DisplayItemBeanWrapper displayItemBeanWrapper = null;
HashMap validationErrors = new HashMap();
List<DisplayItemBeanWrapper> wrappers = new ArrayList<DisplayItemBeanWrapper>();
ImportHelper importHelper = new ImportHelper();
FormDiscrepancyNotes discNotes = new FormDiscrepancyNotes();
DiscrepancyValidator discValidator = new DiscrepancyValidator(request, discNotes);
// create a second Validator, this one for hard edit checks
HashMap<String, String> hardValidator = new HashMap<String, String>();
StudyEventDAO studyEventDAO = new StudyEventDAO(ds);
StudyDAO studyDAO = new StudyDAO(ds);
StudyBean studyBean = studyDAO.findByOid(odmContainer.getCrfDataPostImportContainer().getStudyOID());
StudySubjectDAO studySubjectDAO = new StudySubjectDAO(ds);
StudyEventDefinitionDAO sedDao = new StudyEventDefinitionDAO(ds);
HashMap<String, ItemDataBean> blankCheck = new HashMap<String, ItemDataBean>();
String hardValidatorErrorMsgs = "";
ArrayList<SubjectDataBean> subjectDataBeans = odmContainer.getCrfDataPostImportContainer().getSubjectData();
int totalEventCRFCount = 0;
int totalItemDataBeanCount = 0;
for (SubjectDataBean subjectDataBean : subjectDataBeans) {
ArrayList<DisplayItemBean> displayItemBeans = new ArrayList<DisplayItemBean>();
logger.debug("iterating through subject data beans: found " + subjectDataBean.getSubjectOID());
ArrayList<StudyEventDataBean> studyEventDataBeans = subjectDataBean.getStudyEventData();
totalEventCRFCount += studyEventDataBeans.size();
StudySubjectBean studySubjectBean = studySubjectDAO.findByOidAndStudy(subjectDataBean.getSubjectOID(), studyBean.getId());
for (StudyEventDataBean studyEventDataBean : studyEventDataBeans) {
int parentStudyId = studyBean.getParentStudyId();
StudyEventDefinitionBean sedBean = sedDao.findByOidAndStudy(studyEventDataBean.getStudyEventOID(), studyBean.getId(), parentStudyId);
ArrayList<FormDataBean> formDataBeans = studyEventDataBean.getFormData();
logger.debug("iterating through study event data beans: found " + studyEventDataBean.getStudyEventOID());
int ordinal = 1;
try {
ordinal = new Integer(studyEventDataBean.getStudyEventRepeatKey()).intValue();
} catch (Exception e) {
// trying to catch NPEs, because tags can be without the
// repeat key
}
StudyEventBean studyEvent = (StudyEventBean) studyEventDAO.findByStudySubjectIdAndDefinitionIdAndOrdinal(studySubjectBean.getId(), sedBean.getId(), ordinal);
displayItemBeans = new ArrayList<DisplayItemBean>();
for (FormDataBean formDataBean : formDataBeans) {
Map<String, Integer> groupMaxOrdinals = new HashMap<String, Integer>();
displayItemBeanWrapper = null;
CRFVersionDAO crfVersionDAO = new CRFVersionDAO(ds);
EventCRFDAO eventCRFDAO = new EventCRFDAO(ds);
ArrayList<CRFVersionBean> crfVersionBeans = crfVersionDAO.findAllByOid(formDataBean.getFormOID());
ArrayList<ImportItemGroupDataBean> itemGroupDataBeans = formDataBean.getItemGroupData();
if ((crfVersionBeans == null) || (crfVersionBeans.size() == 0)) {
MessageFormat mf = new MessageFormat("");
mf.applyPattern(respage.getString("your_crf_version_oid_did_not_generate"));
Object[] arguments = { formDataBean.getFormOID() };
throw new OpenClinicaException(mf.format(arguments), "");
}
CRFVersionBean crfVersion = crfVersionBeans.get(0);
// if you have a mispelled form oid you get an error here
// need to error out gracefully and post an error
logger.debug("iterating through form beans: found " + crfVersion.getOid());
// may be the point where we cut off item groups etc and
// instead work on sections
EventCRFBean eventCRFBean = eventCRFDAO.findByEventCrfVersion(studyEvent, crfVersion);
EventDefinitionCRFDAO eventDefinitionCRFDAO = new EventDefinitionCRFDAO(ds);
EventDefinitionCRFBean eventDefinitionCRF = eventDefinitionCRFDAO.findByStudyEventIdAndCRFVersionId(studyBean, studyEvent.getId(), crfVersion.getId());
if (eventCRFBean != null) {
if (permittedEventCRFIds.contains(new Integer(eventCRFBean.getId()))) {
for (ImportItemGroupDataBean itemGroupDataBean : itemGroupDataBeans) {
groupMaxOrdinals.put(itemGroupDataBean.getItemGroupOID(), 1);
}
// correctness, tbh
for (ImportItemGroupDataBean itemGroupDataBean : itemGroupDataBeans) {
ArrayList<ItemBean> blankCheckItems = new ArrayList<ItemBean>();
ArrayList<ImportItemDataBean> itemDataBeans = itemGroupDataBean.getItemData();
logger.debug("iterating through group beans: " + itemGroupDataBean.getItemGroupOID());
// put a checker in here
ItemGroupDAO itemGroupDAO = new ItemGroupDAO(ds);
ItemGroupBean testBean = itemGroupDAO.findByOid(itemGroupDataBean.getItemGroupOID());
if (testBean == null) {
// TODO i18n of message
MessageFormat mf = new MessageFormat("");
mf.applyPattern(respage.getString("your_item_group_oid_for_form_oid"));
Object[] arguments = { itemGroupDataBean.getItemGroupOID(), formDataBean.getFormOID() };
throw new OpenClinicaException(mf.format(arguments), "");
}
totalItemDataBeanCount += itemDataBeans.size();
for (ImportItemDataBean importItemDataBean : itemDataBeans) {
logger.debug(" iterating through item data beans: " + importItemDataBean.getItemOID());
ItemDAO itemDAO = new ItemDAO(ds);
ItemFormMetadataDAO itemFormMetadataDAO = new ItemFormMetadataDAO(ds);
List<ItemBean> itemBeans = itemDAO.findByOid(importItemDataBean.getItemOID());
if (!itemBeans.isEmpty()) {
ItemBean itemBean = itemBeans.get(0);
logger.debug(" found " + itemBean.getName());
// throw a null pointer? hopefully not if its been checked...
DisplayItemBean displayItemBean = new DisplayItemBean();
displayItemBean.setItem(itemBean);
ArrayList<ItemFormMetadataBean> metadataBeans = itemFormMetadataDAO.findAllByItemId(itemBean.getId());
logger.debug(" found metadata item beans: " + metadataBeans.size());
int groupOrdinal = 1;
if (itemGroupDataBean.getItemGroupRepeatKey() != null) {
try {
groupOrdinal = new Integer(itemGroupDataBean.getItemGroupRepeatKey()).intValue();
if (groupOrdinal > groupMaxOrdinals.get(itemGroupDataBean.getItemGroupOID())) {
groupMaxOrdinals.put(itemGroupDataBean.getItemGroupOID(), groupOrdinal);
}
} catch (Exception e) {
// do nothing here currently, we are
// looking for a number format
// exception
// from the above.
logger.debug("found npe for group ordinals, line 344!");
}
}
ItemDataBean itemDataBean = createItemDataBean(itemBean, eventCRFBean, importItemDataBean.getValue(), ub, groupOrdinal);
blankCheckItems.add(itemBean);
String newKey = groupOrdinal + "_" + itemGroupDataBean.getItemGroupOID() + "_" + itemBean.getOid() + "_" + subjectDataBean.getSubjectOID();
blankCheck.put(newKey, itemDataBean);
logger.info("adding " + newKey + " to blank checks");
if (!metadataBeans.isEmpty()) {
ItemFormMetadataBean metadataBean = metadataBeans.get(0);
// also possible nullpointer
displayItemBean.setData(itemDataBean);
displayItemBean.setMetadata(metadataBean);
displayItemBean.setEventDefinitionCRF(eventDefinitionCRF);
String eventCRFRepeatKey = studyEventDataBean.getStudyEventRepeatKey();
// if you do indeed leave off this in the XML it will pass but return 'null'
// tbh
attachValidator(displayItemBean, importHelper, discValidator, hardValidator, request, eventCRFRepeatKey, studySubjectBean.getOid());
displayItemBeans.add(displayItemBean);
} else {
MessageFormat mf = new MessageFormat("");
mf.applyPattern(respage.getString("no_metadata_could_be_found"));
Object[] arguments = { importItemDataBean.getItemOID() };
throw new OpenClinicaException(mf.format(arguments), "");
}
} else {
// report the error there
MessageFormat mf = new MessageFormat("");
mf.applyPattern(respage.getString("no_item_could_be_found"));
Object[] arguments = { importItemDataBean.getItemOID() };
throw new OpenClinicaException(mf.format(arguments), "");
}
}
// end item data beans
logger.debug(".. found blank check: " + blankCheck.toString());
for (int i = 1; i <= groupMaxOrdinals.get(itemGroupDataBean.getItemGroupOID()); i++) {
for (ItemBean itemBean : blankCheckItems) {
String newKey = i + "_" + itemGroupDataBean.getItemGroupOID() + "_" + itemBean.getOid() + "_" + subjectDataBean.getSubjectOID();
if (blankCheck.get(newKey) == null) {
// if it already exists, Do Not Add It.
ItemDataBean itemDataCheck = getItemDataDao().findByItemIdAndEventCRFIdAndOrdinal(itemBean.getId(), eventCRFBean.getId(), i);
logger.debug("found item data bean id: " + itemDataCheck.getId() + " for ordinal " + i);
if (itemDataCheck.getId() == 0) {
ItemDataBean blank = createItemDataBean(itemBean, eventCRFBean, "", ub, i);
DisplayItemBean displayItemBean = new DisplayItemBean();
displayItemBean.setItem(itemBean);
displayItemBean.setData(blank);
// displayItemBean.setMetadata(metadataBean);
// set event def crf?
displayItemBean.setEventDefinitionCRF(eventDefinitionCRF);
String eventCRFRepeatKey = studyEventDataBean.getStudyEventRepeatKey();
// if you do indeed leave off this in the XML it will pass but return
// 'null'
// tbh
displayItemBeans.add(displayItemBean);
logger.debug("... adding display item bean");
}
}
logger.debug("found a blank at " + i + ", adding " + blankCheckItems.size() + " blank items");
}
}
// << tbh #5548
blankCheckItems = new ArrayList<ItemBean>();
}
// end item group data beans
}
// matches if on permittedCRFIDs
CRFDAO crfDAO = new CRFDAO(ds);
CRFBean crfBean = crfDAO.findByVersionId(crfVersion.getCrfId());
// seems like an extravagance, but is not contained in crf
// version or event crf bean
validationErrors = discValidator.validate();
// totalValidationErrors.addAll(validationErrors);
for (Object errorKey : validationErrors.keySet()) {
// JN: to avoid duplicate errors
if (!totalValidationErrors.containsKey(errorKey.toString()))
totalValidationErrors.put(errorKey.toString(), validationErrors.get(errorKey).toString());
// assuming that this will be put back in to the core
// method's hashmap, updating statically, tbh 06/2008
logger.debug("+++ adding " + errorKey.toString());
}
logger.debug("-- hard validation checks: --");
for (Object errorKey : hardValidator.keySet()) {
logger.debug(errorKey.toString() + " -- " + hardValidator.get(errorKey));
hardValidationErrors.put(errorKey.toString(), hardValidator.get(errorKey));
// updating here 'statically' tbh 06/2008
hardValidatorErrorMsgs += hardValidator.get(errorKey) + "<br/><br/>";
}
String studyEventId = studyEvent.getId() + "";
String crfVersionId = crfVersion.getId() + "";
logger.debug("creation of wrapper: original count of display item beans " + displayItemBeans.size() + ", count of item data beans " + totalItemDataBeanCount + " count of validation errors " + validationErrors.size() + " count of study subjects " + subjectDataBeans.size() + " count of event crfs " + totalEventCRFCount + " count of hard error checks " + hardValidator.size());
// check if we need to overwrite
DataEntryStage dataEntryStage = eventCRFBean.getStage();
Status eventCRFStatus = eventCRFBean.getStatus();
boolean overwrite = false;
// //JN: Commenting out the following 2 lines, coz the prompt should come in the cases on
if (// eventCRFStatus.equals(Status.UNAVAILABLE) ||
dataEntryStage.equals(DataEntryStage.DOUBLE_DATA_ENTRY_COMPLETE) || dataEntryStage.equals(DataEntryStage.INITIAL_DATA_ENTRY_COMPLETE) || dataEntryStage.equals(DataEntryStage.INITIAL_DATA_ENTRY) || dataEntryStage.equals(DataEntryStage.DOUBLE_DATA_ENTRY)) {
overwrite = true;
}
// << tbh, adding extra statuses to prevent appending, 06/2009
// SummaryStatsBean ssBean = new SummaryStatsBean();
// ssBean.setDiscNoteCount(totalValidationErrors);
// ssBean.setEventCrfCount(totalEventCRFCount);
// ssBean.setStudySubjectCount(subjectDataBeans.size());
// // add other stats here, tbh
// not working here, need to do it in a different method,
// tbh
// summary stats added tbh 05/2008
// JN: Changed from validationErrors to totalValidationErrors to create discrepancy notes for
// all
// the
displayItemBeanWrapper = new DisplayItemBeanWrapper(displayItemBeans, true, overwrite, validationErrors, studyEventId, crfVersionId, studyEventDataBean.getStudyEventOID(), studySubjectBean.getLabel(), eventCRFBean.getCreatedDate(), crfBean.getName(), crfVersion.getName(), studySubjectBean.getOid(), studyEventDataBean.getStudyEventRepeatKey());
// JN: Commenting out the following code, since we shouldn't re-initialize at this point, as
// validationErrors would get overwritten and the
// older errors will be overriden. Moving it after the form.
// Removing the comments for now, since it seems to be creating duplicate Discrepancy Notes.
validationErrors = new HashMap();
discValidator = new DiscrepancyValidator(request, discNotes);
// reset to allow for new errors...
}
}
// discValidator = new DiscrepancyValidator(request, discNotes);
if (displayItemBeanWrapper != null && displayItemBeans.size() > 0)
wrappers.add(displayItemBeanWrapper);
}
// after study events
// remove repeats here? remove them below by only forwarding the
// first
// each wrapper represents an Event CRF and a Form, but we don't
// have all events for all forms
// need to not add a wrapper for every event + form combination,
// but instead for every event + form combination which is present
// look at the hack below and see what happens
}
// thrown, tbh 06/2008
if (!hardValidator.isEmpty()) {
// throw new OpenClinicaException(hardValidatorErrorMsgs, "");
}
return wrappers;
}
Also used :
ItemBean(org.akaza.openclinica.bean.submit.ItemBean)
DisplayItemBean(org.akaza.openclinica.bean.submit.DisplayItemBean)
HashMap(java.util.HashMap)
ItemDAO(org.akaza.openclinica.dao.submit.ItemDAO)
ArrayList(java.util.ArrayList)
ItemGroupDAO(org.akaza.openclinica.dao.submit.ItemGroupDAO)
StudyEventDefinitionBean(org.akaza.openclinica.bean.managestudy.StudyEventDefinitionBean)
StudyEventBean(org.akaza.openclinica.bean.managestudy.StudyEventBean)
OpenClinicaException(org.akaza.openclinica.exception.OpenClinicaException)
EventCRFBean(org.akaza.openclinica.bean.submit.EventCRFBean)
ItemDataBean(org.akaza.openclinica.bean.submit.ItemDataBean)
ImportItemDataBean(org.akaza.openclinica.bean.submit.crfdata.ImportItemDataBean)
StudyEventDAO(org.akaza.openclinica.dao.managestudy.StudyEventDAO)
StudyDAO(org.akaza.openclinica.dao.managestudy.StudyDAO)
DisplayItemBeanWrapper(org.akaza.openclinica.bean.submit.DisplayItemBeanWrapper)
Status(org.akaza.openclinica.bean.core.Status)
SubjectEventStatus(org.akaza.openclinica.bean.core.SubjectEventStatus)
EventDefinitionCRFDAO(org.akaza.openclinica.dao.managestudy.EventDefinitionCRFDAO)
EventCRFDAO(org.akaza.openclinica.dao.submit.EventCRFDAO)
CRFDAO(org.akaza.openclinica.dao.admin.CRFDAO)
CRFVersionDAO(org.akaza.openclinica.dao.submit.CRFVersionDAO)
FormDiscrepancyNotes(org.akaza.openclinica.control.form.FormDiscrepancyNotes)
StudyBean(org.akaza.openclinica.bean.managestudy.StudyBean)
EventDefinitionCRFDAO(org.akaza.openclinica.dao.managestudy.EventDefinitionCRFDAO)
EventDefinitionCRFBean(org.akaza.openclinica.bean.managestudy.EventDefinitionCRFBean)
EventCRFBean(org.akaza.openclinica.bean.submit.EventCRFBean)
CRFBean(org.akaza.openclinica.bean.admin.CRFBean)
DataEntryStage(org.akaza.openclinica.bean.core.DataEntryStage)
StudyEventDefinitionDAO(org.akaza.openclinica.dao.managestudy.StudyEventDefinitionDAO)
StudySubjectBean(org.akaza.openclinica.bean.managestudy.StudySubjectBean)
EventDefinitionCRFBean(org.akaza.openclinica.bean.managestudy.EventDefinitionCRFBean)
ItemGroupBean(org.akaza.openclinica.bean.submit.ItemGroupBean)
ImportItemGroupDataBean(org.akaza.openclinica.bean.submit.crfdata.ImportItemGroupDataBean)
ImportItemDataBean(org.akaza.openclinica.bean.submit.crfdata.ImportItemDataBean)
DisplayItemBean(org.akaza.openclinica.bean.submit.DisplayItemBean)
EventCRFDAO(org.akaza.openclinica.dao.submit.EventCRFDAO)
ItemFormMetadataDAO(org.akaza.openclinica.dao.submit.ItemFormMetadataDAO)
MessageFormat(java.text.MessageFormat)
StudyEventDataBean(org.akaza.openclinica.bean.submit.crfdata.StudyEventDataBean)
StudySubjectDAO(org.akaza.openclinica.dao.managestudy.StudySubjectDAO)
OpenClinicaException(org.akaza.openclinica.exception.OpenClinicaException)
ParseException(java.text.ParseException)
DiscrepancyValidator(org.akaza.openclinica.control.form.DiscrepancyValidator)
SubjectDataBean(org.akaza.openclinica.bean.submit.crfdata.SubjectDataBean)
FormDataBean(org.akaza.openclinica.bean.submit.crfdata.FormDataBean)
CRFVersionBean(org.akaza.openclinica.bean.submit.CRFVersionBean)
ItemFormMetadataBean(org.akaza.openclinica.bean.submit.ItemFormMetadataBean)
Aggregations
DiscrepancyValidator (org.akaza.openclinica.control.form.DiscrepancyValidator)8
FormDiscrepancyNotes (org.akaza.openclinica.control.form.FormDiscrepancyNotes)8
ArrayList (java.util.ArrayList)7
StudySubjectBean (org.akaza.openclinica.bean.managestudy.StudySubjectBean)7
StudySubjectDAO (org.akaza.openclinica.dao.managestudy.StudySubjectDAO)7
FormProcessor (org.akaza.openclinica.control.form.FormProcessor)6
Date (java.util.Date)5
HashMap (java.util.HashMap)5
StudyBean (org.akaza.openclinica.bean.managestudy.StudyBean)5
DiscrepancyNoteDAO (org.akaza.openclinica.dao.managestudy.DiscrepancyNoteDAO)5
ParseException (java.text.ParseException)4
Status (org.akaza.openclinica.bean.core.Status)4
SubjectEventStatus (org.akaza.openclinica.bean.core.SubjectEventStatus)4
StudyEventBean (org.akaza.openclinica.bean.managestudy.StudyEventBean)4
StudyEventDefinitionBean (org.akaza.openclinica.bean.managestudy.StudyEventDefinitionBean)4
StudyDAO (org.akaza.openclinica.dao.managestudy.StudyDAO)4
Calendar (java.util.Calendar)3
EventDefinitionCRFBean (org.akaza.openclinica.bean.managestudy.EventDefinitionCRFBean)3
StudyEventDAO (org.akaza.openclinica.dao.managestudy.StudyEventDAO)3
StudyEventDefinitionDAO (org.akaza.openclinica.dao.managestudy.StudyEventDefinitionDAO)3
