@SuppressWarnings("unchecked")
@Override
public void setDataAndLimitVariables(TableFacade tableFacade) {
// initialize i18n
resword = ResourceBundleProvider.getWordsBundle(getLocale());
resformat = ResourceBundleProvider.getFormatBundle(getLocale());
Limit limit = tableFacade.getLimit();
ListSubjectFilter listSubjectFilter = getListSubjectFilter(limit);
if (!limit.isComplete()) {
int totalRows = getSubjectDao().getCountWithFilter(listSubjectFilter, getCurrentStudy());
tableFacade.setTotalRows(totalRows);
}
ListSubjectSort listSubjectSort = getListSubjectSort(limit);
int rowStart = limit.getRowSelect().getRowStart();
int rowEnd = limit.getRowSelect().getRowEnd();
Collection<SubjectBean> items =
getSubjectDao()
.getWithFilterAndSort(
getCurrentStudy(), listSubjectFilter, listSubjectSort, rowStart, rowEnd);
Collection<HashMap<Object, Object>> theItems = new ArrayList<HashMap<Object, Object>>();
for (SubjectBean subject : items) {
UserAccountBean owner = (UserAccountBean) getUserAccountDao().findByPK(subject.getOwnerId());
UserAccountBean updater =
subject.getUpdaterId() == 0
? null
: (UserAccountBean) getUserAccountDao().findByPK(subject.getUpdaterId());
HashMap<Object, Object> h = new HashMap<Object, Object>();
String studySubjectIdAndStudy = "";
List<StudySubjectBean> studySubjects =
getStudySubjectDao().findAllBySubjectId(subject.getId());
for (StudySubjectBean studySubjectBean : studySubjects) {
StudyBean study = (StudyBean) getStudyDao().findByPK(studySubjectBean.getStudyId());
studySubjectIdAndStudy += studySubjectIdAndStudy.length() == 0 ? "" : ",";
studySubjectIdAndStudy += study.getIdentifier() + "-" + studySubjectBean.getLabel();
}
h.put("studySubjectIdAndStudy", studySubjectIdAndStudy);
h.put("subject", subject);
h.put("subject.uniqueIdentifier", subject.getUniqueIdentifier());
h.put("subject.gender", subject.getGender());
h.put("subject.createdDate", subject.getCreatedDate());
h.put("subject.owner", owner);
h.put("subject.updatedDate", subject.getUpdatedDate());
h.put("subject.updater", updater);
h.put("subject.status", subject.getStatus());
theItems.add(h);
}
tableFacade.setItems(theItems);
}
/*
* (non-Javadoc)
* @see org.akaza.openclinica.service.subject.SubjectServiceInterface#createSubject(org.akaza.openclinica.bean.submit.SubjectBean,
* org.akaza.openclinica.bean.managestudy.StudyBean)
*/
public String createSubject(
SubjectBean subjectBean, StudyBean studyBean, Date enrollmentDate, String secondaryId) {
// studyBean = getStudyDao().findByUniqueIdentifier(studyBean.getIdentifier()); // Need to
if (subjectBean.getUniqueIdentifier() != null
&& getSubjectDao().findByUniqueIdentifier(subjectBean.getUniqueIdentifier()).getId() != 0) {
subjectBean = getSubjectDao().findByUniqueIdentifier(subjectBean.getUniqueIdentifier());
} else {
subjectBean.setStatus(Status.AVAILABLE);
subjectBean = getSubjectDao().create(subjectBean);
}
StudySubjectBean studySubject =
createStudySubject(subjectBean, studyBean, enrollmentDate, secondaryId);
getStudySubjectDao().createWithoutGroup(studySubject);
return studySubject.getLabel();
}
@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");
}
presetValues.put(INPUT_LOCATION, currentStudy.getFacilityCity()); // defualt
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.info("set preset values: " + presetValues.toString());
System.out.println("set preset values: " + presetValues.toString());
logger.info("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.info(dateCheck+"; "+endCheck);
String dateCheck2 = request.getParameter("startDate");
String endCheck2 = request.getParameter("endDate");
logger.info(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.info(">>> 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
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);
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.info("has scheduled definition******");
v.addValidation(
this.INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i],
Validator.ENTITY_EXISTS_IN_STUDY,
seddao,
studyWithEventDefinitions);
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.info("v is not null *****");
String location = resword.getString("location");
// don't allow user to use the default value 'Location' since
// 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 =
(StudySubjectBean)
sdao.findByLabelAndStudy(fp.getString(INPUT_STUDY_SUBJECT_LABEL), currentStudy);
// >> 4358 tbh, 11/2009
// 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
System.out.println("tripped the error here 20091109");
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);
System.out.println(
"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 {
// if in same date, only check when both had time
// 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 >>
System.out.println("we have errors; number of this; " + errors.size());
if (!errors.isEmpty()) {
logger.info("we have errors; number of this; " + errors.size());
System.out.println(
"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 {
System.out.println("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.info("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);
}
// tbh
// 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.info("here ok 3333333333333333");
if (hasScheduledEvent) {
for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
// should only do the following process if user inputs a
// scheduled event,
// 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()));
response.encodeRedirectURL("EnterDataForStudyEvent?eventId=" + studyEvent.getId());
forwardPage(Page.ENTER_DATA_FOR_STUDY_EVENT_SERVLET);
// we want to actually have url of entering data in browser, so
// redirecting
// response.sendRedirect(response.encodeRedirectURL(
// "EnterDataForStudyEvent?eventId="
// + studyEvent.getId()));
return;
}
}
}
/**
* Organize objects in a certain way so that we can show to Users on UI. step1 : Get StudyEvent ,
* eventCrf , crfVersion from studyEventId.
*
* @param crfViewSpecificOrderedObjects
* @param ruleSet
* @param rule
* @return
*/
private HashMap<RuleBulkExecuteContainer, HashMap<RuleBulkExecuteContainerTwo, Set<String>>>
populateForCrfBasedRulesView(
HashMap<RuleBulkExecuteContainer, HashMap<RuleBulkExecuteContainerTwo, Set<String>>>
crfViewSpecificOrderedObjects,
RuleSetBean ruleSet,
RuleBean rule,
String result,
StudyBean currentStudy,
List<RuleActionBean> actions) {
// step1
StudyEventBean studyEvent =
(StudyEventBean)
getStudyEventDao()
.findByPK(
Integer.valueOf(
getExpressionService()
.getStudyEventDefenitionOrdninalCurated(
ruleSet.getTarget().getValue())));
EventCRFBean eventCrf =
(EventCRFBean)
getEventCrfDao()
.findAllByStudyEventAndCrfOrCrfVersionOid(
studyEvent, getExpressionService().getCrfOid(ruleSet.getTarget().getValue()))
.get(0);
CRFVersionBean crfVersion =
(CRFVersionBean) getCrfVersionDao().findByPK(eventCrf.getCRFVersionId());
RuleBulkExecuteContainer key =
new RuleBulkExecuteContainer(crfVersion.getName(), rule, result, actions);
String key2String =
getExpressionService()
.getCustomExpressionUsedToCreateView(
ruleSet.getTarget().getValue(), studyEvent.getSampleOrdinal());
String studyEventDefinitionName =
getExpressionService()
.getStudyEventDefinitionFromExpression(ruleSet.getTarget().getValue(), currentStudy)
.getName();
studyEventDefinitionName += " [" + studyEvent.getSampleOrdinal() + "]";
// String itemGroupName =
// getExpressionService().getItemGroupNameAndOrdinal(ruleSet.getTarget().getValue());
// String itemName =
// getExpressionService().getItemGroupExpression(ruleSet.getTarget().getValue()).getName();
String itemGroupName =
getExpressionService().getItemGroupNameAndOrdinal(ruleSet.getTarget().getValue());
ItemGroupBean itemGroupBean =
getExpressionService().getItemGroupExpression(ruleSet.getTarget().getValue());
ItemBean itemBean =
getExpressionService().getItemExpression(ruleSet.getTarget().getValue(), itemGroupBean);
String itemName = itemBean.getName();
RuleBulkExecuteContainerTwo key2 =
new RuleBulkExecuteContainerTwo(
key2String, studyEvent, studyEventDefinitionName, itemGroupName, itemName);
StudySubjectBean studySubject =
(StudySubjectBean) getStudySubjectDao().findByPK(studyEvent.getStudySubjectId());
if (crfViewSpecificOrderedObjects.containsKey(key)) {
HashMap<RuleBulkExecuteContainerTwo, Set<String>> k = crfViewSpecificOrderedObjects.get(key);
if (k.containsKey(key2)) {
k.get(key2).add(String.valueOf(studySubject.getLabel()));
} else {
HashSet<String> values = new HashSet<String>();
values.add(String.valueOf(studySubject.getLabel()));
k.put(key2, values);
}
} else {
HashMap<RuleBulkExecuteContainerTwo, Set<String>> k =
new HashMap<RuleBulkExecuteContainerTwo, Set<String>>();
HashSet<String> values = new HashSet<String>();
values.add(String.valueOf(studySubject.getLabel()));
k.put(key2, values);
crfViewSpecificOrderedObjects.put(key, k);
}
return crfViewSpecificOrderedObjects;
}