001: /**********************************************************************************
002: * $URL: https://source.sakaiproject.org/svn/sam/trunk/component/src/java/org/sakaiproject/tool/assessment/services/assessment/PublishedAssessmentService.java $
003: * $Id: PublishedAssessmentService.java 9273 2006-05-10 22:34:28Z daisyf@stanford.edu $
004: ***********************************************************************************
005: *
006: * Copyright (c) 2004, 2005, 2006 The Sakai Foundation.
007: *
008: * Licensed under the Educational Community License, Version 1.0 (the"License");
009: * you may not use this file except in compliance with the License.
010: * You may obtain a copy of the License at
011: *
012: * http://www.opensource.org/licenses/ecl1.php
013: *
014: * Unless required by applicable law or agreed to in writing, software
015: * distributed under the License is distributed on an "AS IS" BASIS,
016: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: * See the License for the specific language governing permissions and
018: * limitations under the License.
019: *
020: **********************************************************************************/package org.sakaiproject.tool.assessment.services.assessment;
021:
022: import java.util.ArrayList;
023: import java.util.HashMap;
024: import java.util.HashSet;
025: import java.util.List;
026:
027: import org.apache.commons.logging.Log;
028: import org.apache.commons.logging.LogFactory;
029:
030: import org.sakaiproject.tool.assessment.data.dao.assessment.PublishedAssessmentData;
031: import org.sakaiproject.tool.assessment.data.dao.assessment.PublishedItemData;
032: import org.sakaiproject.tool.assessment.data.dao.assessment.PublishedItemText;
033: import org.sakaiproject.tool.assessment.data.dao.assessment.PublishedMetaData;
034: import org.sakaiproject.tool.assessment.data.ifc.assessment.AnswerIfc;
035: import org.sakaiproject.tool.assessment.data.ifc.assessment.PublishedAssessmentIfc;
036: import org.sakaiproject.tool.assessment.data.ifc.assessment.ItemDataIfc;
037: import org.sakaiproject.tool.assessment.data.ifc.assessment.ItemTextIfc;
038: import org.sakaiproject.tool.assessment.data.ifc.assessment.SectionDataIfc;
039: import org.sakaiproject.tool.assessment.facade.AgentFacade;
040: import org.sakaiproject.tool.assessment.facade.AssessmentFacade;
041: import org.sakaiproject.tool.assessment.facade.PublishedAssessmentFacade;
042: import org.sakaiproject.tool.assessment.services.PersistenceService;
043:
044: /**
045: * The QuestionPoolService calls the service locator to reach the
046: * manager on the back end.
047: * @author Rachel Gollub <rgollub@stanford.edu>
048: */
049: public class PublishedAssessmentService {
050: private static Log log = LogFactory
051: .getLog(PublishedAssessmentService.class);
052:
053: /**
054: * Creates a new QuestionPoolService object.
055: */
056: public PublishedAssessmentService() {
057: }
058:
059: /**
060: * rachelgollub: So takeable is that you have *not* reached the number of
061: * submissions and you're either before the due date or (you're after the due
062: * date, you haven't submitted yet, and late handling is enabled).
063: * - quoted from IM on 1/31/05
064: * Marc said some of teh assessment do not have any due date, e.g. survey
065: */
066: public ArrayList getBasicInfoOfAllPublishedAssessments(
067: String agentId, String orderBy, boolean ascending,
068: String siteId) {
069:
070: // 2. get all takeable assessment available
071: return PersistenceService
072: .getInstance()
073: .getPublishedAssessmentFacadeQueries()
074: .getBasicInfoOfAllPublishedAssessments(orderBy,
075: ascending,
076: PublishedAssessmentFacade.ACTIVE_STATUS, siteId);
077: }
078:
079: /**
080: public ArrayList getAllReviewableAssessments(String agentId, String orderBy,
081: boolean ascending) {
082:
083: // 1. get total no. of submission per assessment by the given agent
084: HashMap h = getTotalSubmissionPerAssessment(agentId);
085:
086: ArrayList assessmentList = PersistenceService.getInstance().
087: getPublishedAssessmentFacadeQueries().
088: getAllReviewableAssessments(orderBy, ascending);
089: assessmentList.size());
090: ArrayList reviewableAssessmentList = new ArrayList();
091: for (int i = 0; i < assessmentList.size(); i++) {
092: AssessmentGradingFacade f = (AssessmentGradingFacade) assessmentList.get(
093: i);
094:
095: Integer NumberOfSubmissions = (Integer) h.get(
096: f.getPublishedAssessment().getPublishedAssessmentId());
097: if (NumberOfSubmissions == null) {
098: NumberOfSubmissions = new Integer(0);
099: }
100: try {
101: if (!PersistenceService.getInstance().getAuthzQueriesFacade().isAuthorized(null, "VIEW_PUBLISHED_ASSESSMENT",
102: f.getPublishedAssessment().
103: getPublishedAssessmentId().
104: toString())) {
105: break;
106: }
107: }
108: catch (Exception e1) {
109: log.fatal("Wrapping Error around unhandled Exception: "
110: + e1.getMessage());
111: throw new RuntimeException(e1.getMessage());
112: }
113: // for testing only
114: reviewableAssessmentList.add(f);
115: }
116: return reviewableAssessmentList;
117: }
118: */
119:
120: public ArrayList getAllActivePublishedAssessments(String orderBy) {
121: return getAllPublishedAssessments(orderBy,
122: PublishedAssessmentFacade.ACTIVE_STATUS);
123: }
124:
125: public ArrayList getAllActivePublishedAssessments(int pageSize,
126: int pageNumber, String orderBy) {
127: return getAllPublishedAssessments(pageSize, pageNumber,
128: orderBy, PublishedAssessmentFacade.ACTIVE_STATUS);
129: }
130:
131: public ArrayList getAllInActivePublishedAssessments(String orderBy) {
132: return getAllPublishedAssessments(orderBy,
133: PublishedAssessmentFacade.INACTIVE_STATUS);
134: }
135:
136: public ArrayList getAllInActivePublishedAssessments(int pageSize,
137: int pageNumber, String orderBy) {
138: return getAllPublishedAssessments(pageSize, pageNumber,
139: orderBy, PublishedAssessmentFacade.INACTIVE_STATUS);
140: }
141:
142: public ArrayList getAllPublishedAssessments(String orderBy,
143: Integer status) {
144: return PersistenceService.getInstance()
145: .getPublishedAssessmentFacadeQueries()
146: .getAllPublishedAssessments(orderBy, status); // signalling all & no paging
147: }
148:
149: public ArrayList getAllPublishedAssessments(int pageSize,
150: int pageNumber, String orderBy, Integer status) {
151: try {
152: if (pageSize > 0 && pageNumber > 0) {
153: return PersistenceService.getInstance()
154: .getPublishedAssessmentFacadeQueries()
155: .getAllPublishedAssessments(pageSize,
156: pageNumber, orderBy, status);
157: } else {
158: return PersistenceService.getInstance()
159: .getPublishedAssessmentFacadeQueries()
160: .getAllPublishedAssessments(orderBy, status);
161: }
162: } catch (Exception e) {
163: log.error(e);
164: throw new RuntimeException(e);
165: }
166: }
167:
168: public PublishedAssessmentFacade getPublishedAssessment(
169: String assessmentId) {
170: try {
171: return PersistenceService.getInstance()
172: .getPublishedAssessmentFacadeQueries()
173: .getPublishedAssessment(new Long(assessmentId));
174: } catch (Exception e) {
175: log.error(e);
176: throw new RuntimeException(e);
177: }
178: }
179:
180: public Long getPublishedAssessmentId(String assessmentId) {
181: try {
182: return PersistenceService.getInstance()
183: .getPublishedAssessmentFacadeQueries()
184: .getPublishedAssessmentId(new Long(assessmentId));
185: } catch (Exception e) {
186: log.error(e);
187: throw new RuntimeException(e);
188: }
189: }
190:
191: public PublishedAssessmentFacade publishAssessment(
192: AssessmentFacade assessment) throws Exception {
193: return PersistenceService.getInstance()
194: .getPublishedAssessmentFacadeQueries()
195: .publishAssessment(assessment);
196: }
197:
198: public PublishedAssessmentFacade publishPreviewAssessment(
199: AssessmentFacade assessment) {
200: try {
201: return PersistenceService.getInstance()
202: .getPublishedAssessmentFacadeQueries()
203: .publishPreviewAssessment(assessment);
204: } catch (Exception e) {
205: log.error(e);
206: throw new RuntimeException(e);
207: }
208: }
209:
210: public void saveAssessment(PublishedAssessmentFacade assessment) {
211: try {
212: PersistenceService.getInstance()
213: .getPublishedAssessmentFacadeQueries()
214: .saveOrUpdate(assessment);
215: } catch (Exception e) {
216: log.error(e);
217: }
218: }
219:
220: public void removeAssessment(String assessmentId) {
221: PersistenceService.getInstance()
222: .getPublishedAssessmentFacadeQueries()
223: .removeAssessment(new Long(assessmentId));
224: }
225:
226: public ArrayList getBasicInfoOfAllActivePublishedAssessments(
227: String orderBy, boolean ascending) {
228: String siteAgentId = AgentFacade.getCurrentSiteId();
229: return PersistenceService.getInstance()
230: .getPublishedAssessmentFacadeQueries()
231: .getBasicInfoOfAllActivePublishedAssessments(orderBy,
232: siteAgentId, ascending); // signalling all & no paging
233: }
234:
235: public ArrayList getBasicInfoOfAllInActivePublishedAssessments(
236: String orderBy, boolean ascending) {
237: String siteAgentId = AgentFacade.getCurrentSiteId();
238: return PersistenceService.getInstance()
239: .getPublishedAssessmentFacadeQueries()
240: .getBasicInfoOfAllInActivePublishedAssessments(orderBy,
241: siteAgentId, ascending); // signalling all & no paging
242: }
243:
244: public PublishedAssessmentFacade getSettingsOfPublishedAssessment(
245: String assessmentId) {
246: try {
247: return PersistenceService.getInstance()
248: .getPublishedAssessmentFacadeQueries()
249: .getSettingsOfPublishedAssessment(
250: new Long(assessmentId));
251: } catch (Exception e) {
252: log.error(e);
253: throw new RuntimeException(e);
254: }
255: }
256:
257: public PublishedItemData loadPublishedItem(String itemId) {
258: try {
259: return PersistenceService.getInstance()
260: .getPublishedAssessmentFacadeQueries()
261: .loadPublishedItem(new Long(itemId));
262: } catch (Exception e) {
263: log.error(e);
264: throw new RuntimeException(e);
265: }
266: }
267:
268: public PublishedItemText loadPublishedItemText(String itemTextId) {
269: try {
270: return PersistenceService.getInstance()
271: .getPublishedAssessmentFacadeQueries()
272: .loadPublishedItemText(new Long(itemTextId));
273: } catch (Exception e) {
274: log.error(e);
275: throw new RuntimeException(e);
276: }
277: }
278:
279: /**
280: * return an array list of the last AssessmentGradingFacade per assessment that
281: * a user has submitted for grade.
282: * @param agentId
283: * @param orderBy
284: * @param ascending
285: * @return
286: */
287: public ArrayList getBasicInfoOfLastSubmittedAssessments(
288: String agentId, String orderBy, boolean ascending) {
289: return PersistenceService.getInstance()
290: .getPublishedAssessmentFacadeQueries()
291: .getBasicInfoOfLastSubmittedAssessments(agentId,
292: orderBy, ascending);
293: }
294:
295: /** total submitted for grade
296: * returns HashMap (Long publishedAssessmentId, Integer totalSubmittedForGrade);
297: */
298: public HashMap getTotalSubmissionPerAssessment(String agentId) {
299: return PersistenceService.getInstance()
300: .getPublishedAssessmentFacadeQueries()
301: .getTotalSubmissionPerAssessment(agentId);
302: }
303:
304: public HashMap getTotalSubmissionPerAssessment(String agentId,
305: String siteId) {
306: return PersistenceService.getInstance()
307: .getPublishedAssessmentFacadeQueries()
308: .getTotalSubmissionPerAssessment(agentId, siteId);
309: }
310:
311: public Integer getTotalSubmission(String agentId,
312: String publishedAssessmentId) {
313: return PersistenceService.getInstance()
314: .getPublishedAssessmentFacadeQueries()
315: .getTotalSubmission(agentId,
316: new Long(publishedAssessmentId));
317: }
318:
319: public PublishedAssessmentFacade getPublishedAssessmentIdByAlias(
320: String alias) {
321: return PersistenceService.getInstance()
322: .getPublishedAssessmentFacadeQueries()
323: .getPublishedAssessmentIdByAlias(alias);
324: }
325:
326: public void saveOrUpdateMetaData(PublishedMetaData meta) {
327: PersistenceService.getInstance()
328: .getPublishedAssessmentFacadeQueries()
329: .saveOrUpdateMetaData(meta);
330: }
331:
332: public HashMap getFeedbackHash() {
333: return PersistenceService.getInstance()
334: .getPublishedAssessmentFacadeQueries()
335: .getFeedbackHash();
336: }
337:
338: public HashMap getAllAssessmentsReleasedToAuthenticatedUsers() {
339: return PersistenceService.getInstance()
340: .getPublishedAssessmentFacadeQueries()
341: .getAllAssessmentsReleasedToAuthenticatedUsers();
342: }
343:
344: public String getPublishedAssessmentOwner(Long publishedAssessmentId) {
345: return PersistenceService.getInstance()
346: .getPublishedAssessmentFacadeQueries()
347: .getPublishedAssessmentOwner(
348: publishedAssessmentId.toString());
349: }
350:
351: public boolean publishedAssessmentTitleIsUnique(
352: String assessmentBaseId, String title) {
353: return PersistenceService.getInstance()
354: .getPublishedAssessmentFacadeQueries()
355: .publishedAssessmentTitleIsUnique(
356: new Long(assessmentBaseId), title);
357: }
358:
359: public boolean hasRandomPart(String publishedAssessmentId) {
360: return PersistenceService.getInstance()
361: .getPublishedAssessmentFacadeQueries().hasRandomPart(
362: new Long(publishedAssessmentId));
363: }
364:
365: public PublishedItemData getFirstPublishedItem(
366: String publishedAssessmentId) {
367: return PersistenceService.getInstance()
368: .getPublishedAssessmentFacadeQueries()
369: .getFirstPublishedItem(new Long(publishedAssessmentId));
370: }
371:
372: public List getPublishedItemIds(String publishedAssessmentId) {
373: return PersistenceService.getInstance()
374: .getPublishedAssessmentFacadeQueries()
375: .getPublishedItemIds(new Long(publishedAssessmentId));
376: }
377:
378: public HashSet getPublishedItemSet(Long publishedAssessmentId,
379: Long sectionId) {
380: return PersistenceService.getInstance()
381: .getPublishedAssessmentFacadeQueries()
382: .getPublishedItemSet(publishedAssessmentId, sectionId);
383: }
384:
385: public Long getItemType(String publishedItemId) {
386: return PersistenceService.getInstance()
387: .getPublishedAssessmentFacadeQueries().getItemType(
388: new Long(publishedItemId));
389: }
390:
391: public HashMap preparePublishedItemTextHash(
392: PublishedAssessmentIfc publishedAssessment) {
393: HashMap map = new HashMap();
394: ArrayList sectionArray = publishedAssessment.getSectionArray();
395: for (int i = 0; i < sectionArray.size(); i++) {
396: SectionDataIfc section = (SectionDataIfc) sectionArray
397: .get(i);
398: ArrayList itemArray = section.getItemArray();
399: for (int j = 0; j < itemArray.size(); j++) {
400: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
401: ArrayList itemTextArray = item.getItemTextArray();
402: for (int k = 0; k < itemTextArray.size(); k++) {
403: ItemTextIfc itemText = (ItemTextIfc) itemTextArray
404: .get(k);
405: map.put(itemText.getId(), itemText);
406: }
407: }
408: }
409: return map;
410: }
411:
412: public HashMap preparePublishedItemHash(
413: PublishedAssessmentIfc publishedAssessment) {
414: HashMap map = new HashMap();
415: ArrayList sectionArray = publishedAssessment.getSectionArray();
416: for (int i = 0; i < sectionArray.size(); i++) {
417: SectionDataIfc section = (SectionDataIfc) sectionArray
418: .get(i);
419: ArrayList itemArray = section.getItemArray();
420: for (int j = 0; j < itemArray.size(); j++) {
421: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
422: map.put(item.getItemId(), item);
423: }
424: }
425: return map;
426: }
427:
428: public HashMap preparePublishedAnswerHash(
429: PublishedAssessmentIfc publishedAssessment) {
430: HashMap map = new HashMap();
431: ArrayList sectionArray = publishedAssessment.getSectionArray();
432: for (int i = 0; i < sectionArray.size(); i++) {
433: SectionDataIfc section = (SectionDataIfc) sectionArray
434: .get(i);
435: ArrayList itemArray = section.getItemArray();
436: for (int j = 0; j < itemArray.size(); j++) {
437: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
438: ArrayList itemTextArray = item.getItemTextArray();
439: for (int k = 0; k < itemTextArray.size(); k++) {
440: ItemTextIfc itemText = (ItemTextIfc) itemTextArray
441: .get(k);
442: ArrayList answerArray = itemText
443: .getAnswerArraySorted();
444: for (int m = 0; m < answerArray.size(); m++) {
445: AnswerIfc answer = (AnswerIfc) answerArray
446: .get(m);
447: map.put(answer.getId(), answer);
448: }
449: }
450: }
451: }
452: return map;
453: }
454:
455: public HashMap prepareFIBItemHash(
456: PublishedAssessmentIfc publishedAssessment) {
457: HashMap map = new HashMap();
458: ArrayList sectionArray = publishedAssessment.getSectionArray();
459: for (int i = 0; i < sectionArray.size(); i++) {
460: SectionDataIfc section = (SectionDataIfc) sectionArray
461: .get(i);
462: ArrayList itemArray = section.getItemArray();
463: for (int j = 0; j < itemArray.size(); j++) {
464: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
465: if (item.getTypeId().equals(new Long(8))) // FIB question
466: map.put(item.getItemId(), item);
467: }
468: }
469: return map;
470: }
471:
472: public HashMap prepareFINItemHash(
473: PublishedAssessmentIfc publishedAssessment) {
474: HashMap map = new HashMap();
475: ArrayList sectionArray = publishedAssessment.getSectionArray();
476: for (int i = 0; i < sectionArray.size(); i++) {
477: SectionDataIfc section = (SectionDataIfc) sectionArray
478: .get(i);
479: ArrayList itemArray = section.getItemArray();
480: for (int j = 0; j < itemArray.size(); j++) {
481: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
482: if (item.getTypeId().equals(new Long(11))) // FIN question
483: map.put(item.getItemId(), item);
484: }
485: }
486: return map;
487: }
488:
489: public HashMap prepareMCMRItemHash(
490: PublishedAssessmentIfc publishedAssessment) {
491: HashMap map = new HashMap();
492: ArrayList sectionArray = publishedAssessment.getSectionArray();
493: for (int i = 0; i < sectionArray.size(); i++) {
494: SectionDataIfc section = (SectionDataIfc) sectionArray
495: .get(i);
496: ArrayList itemArray = section.getItemArray();
497: for (int j = 0; j < itemArray.size(); j++) {
498: ItemDataIfc item = (ItemDataIfc) itemArray.get(j);
499: if (item.getTypeId().equals(new Long(2))) // MCMR question
500: map.put(item.getItemId(), item);
501: }
502: }
503: return map;
504: }
505:
506: public HashSet getSectionSetForAssessment(Long publishedAssessmentId) {
507: return PersistenceService.getInstance()
508: .getPublishedAssessmentFacadeQueries()
509: .getSectionSetForAssessment(publishedAssessmentId);
510: }
511:
512: public boolean isRandomDrawPart(Long publishedAssessmentId,
513: Long publishedSectionId) {
514: return PersistenceService.getInstance()
515: .getPublishedAssessmentFacadeQueries()
516: .isRandomDrawPart(publishedAssessmentId,
517: publishedSectionId);
518: }
519:
520: /**
521: * return an array list of the AssessmentGradingFacade that
522: * a user has submitted for grade. one per published assessment.
523: * If an assessment allows multiple submissions and its grading option
524: * is to send highest, then return only the highest submission. If an assessment allows multiple submissions and its grading option
525: * is to send last, then return only the last submission.
526: * @param agentId
527: * @return
528: */
529: public ArrayList getBasicInfoOfLastOrHighestSubmittedAssessmentsByScoringOption(
530: String agentId, String siteId) {
531: return PersistenceService
532: .getInstance()
533: .getPublishedAssessmentFacadeQueries()
534: .getBasicInfoOfLastOrHighestSubmittedAssessmentsByScoringOption(
535: agentId, siteId);
536: }
537:
538: public PublishedAssessmentData getBasicInfoOfPublishedAssessment(
539: String publishedId) {
540: return PersistenceService.getInstance()
541: .getPublishedAssessmentFacadeQueries()
542: .getBasicInfoOfPublishedAssessment(
543: new Long(publishedId));
544: }
545:
546: public String getPublishedAssessmentSiteId(
547: String publishedAssessmentId) {
548: return PersistenceService.getInstance()
549: .getPublishedAssessmentFacadeQueries()
550: .getPublishedAssessmentSiteId(publishedAssessmentId);
551: }
552: }
|