1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.student.enrollment.class2.courseoffering.service.impl;
17
18 import net.sf.ehcache.CacheManager;
19 import net.sf.ehcache.Element;
20 import org.apache.commons.collections.keyvalue.MultiKey;
21 import org.apache.commons.lang.StringUtils;
22 import org.apache.log4j.Logger;
23 import org.kuali.rice.core.api.util.RiceKeyConstants;
24 import org.kuali.rice.kim.api.KimConstants;
25 import org.kuali.rice.kim.api.permission.PermissionService;
26 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
27 import org.kuali.rice.krad.maintenance.MaintenanceDocument;
28 import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
29 import org.kuali.rice.krad.uif.view.View;
30 import org.kuali.rice.krad.util.GlobalVariables;
31 import org.kuali.rice.krad.util.KRADConstants;
32 import org.kuali.student.enrollment.class2.courseoffering.dto.CourseOfferingCreateWrapper;
33 import org.kuali.student.enrollment.class2.courseoffering.dto.FormatOfferingWrapper;
34 import org.kuali.student.enrollment.class2.courseoffering.dto.JointCourseWrapper;
35 import org.kuali.student.enrollment.class2.courseoffering.service.CourseOfferingMaintainable;
36 import org.kuali.student.enrollment.class2.courseoffering.service.decorators.PermissionServiceConstants;
37 import org.kuali.student.enrollment.class2.courseoffering.util.CourseOfferingConstants;
38 import org.kuali.student.enrollment.class2.courseoffering.util.CourseOfferingResourceLoader;
39 import org.kuali.student.enrollment.class2.courseoffering.util.CourseOfferingViewHelperUtil;
40 import org.kuali.student.enrollment.courseoffering.dto.CourseOfferingInfo;
41 import org.kuali.student.enrollment.courseoffering.dto.FormatOfferingInfo;
42 import org.kuali.student.r2.common.dto.AttributeInfo;
43 import org.kuali.student.r2.common.dto.ContextInfo;
44 import org.kuali.student.r2.common.exceptions.InvalidParameterException;
45 import org.kuali.student.r2.common.exceptions.MissingParameterException;
46 import org.kuali.student.r2.common.exceptions.OperationFailedException;
47 import org.kuali.student.r2.common.exceptions.PermissionDeniedException;
48 import org.kuali.student.r2.common.util.ContextUtils;
49 import org.kuali.student.r2.common.util.constants.CourseOfferingServiceConstants;
50 import org.kuali.student.r2.common.util.constants.LuiServiceConstants;
51 import org.kuali.student.r2.common.util.date.DateFormatters;
52 import org.kuali.student.r2.core.atp.dto.AtpInfo;
53 import org.kuali.student.r2.core.atp.service.AtpService;
54 import org.kuali.student.r2.core.class1.type.dto.TypeInfo;
55 import org.kuali.student.r2.core.search.dto.SearchRequestInfo;
56 import org.kuali.student.r2.core.search.dto.SearchResultInfo;
57 import org.kuali.student.r2.core.search.infc.SearchResultCell;
58 import org.kuali.student.r2.core.search.infc.SearchResultRow;
59 import org.kuali.student.r2.lum.clu.service.CluService;
60 import org.kuali.student.r2.lum.course.dto.ActivityInfo;
61 import org.kuali.student.r2.lum.course.dto.CourseInfo;
62 import org.kuali.student.r2.lum.course.dto.CourseJointInfo;
63 import org.kuali.student.r2.lum.course.dto.FormatInfo;
64 import org.kuali.student.r2.lum.util.constants.CluServiceConstants;
65 import org.kuali.student.r2.lum.util.constants.LrcServiceConstants;
66
67 import java.util.ArrayList;
68 import java.util.Collection;
69 import java.util.HashMap;
70 import java.util.List;
71 import java.util.Map;
72
73
74
75
76
77
78 public class CourseOfferingCreateMaintainableImpl extends CourseOfferingMaintainableImpl implements CourseOfferingMaintainable {
79
80 private static final Logger LOG = org.apache.log4j.Logger.getLogger(CourseOfferingCreateMaintainableImpl.class);
81 private static PermissionService permissionService = getPermissionService();
82 private CluService cluService;
83 private AtpService atpService;
84 private static String CACHE_NAME = "CourseOfferingMaintainableImplCache";
85 private CacheManager cacheManager;
86
87
88
89
90
91
92
93
94
95 @Override
96 public void processAfterNew(MaintenanceDocument document, Map<String, String[]> requestParameters) {
97 document.getDocumentHeader().setDocumentDescription("Course Offering");
98 if (requestParameters.get("targetTermCode") != null && requestParameters.get("targetTermCode").length != 0){
99 ((CourseOfferingCreateWrapper)document.getNewMaintainableObject().getDataObject()).setTargetTermCode(requestParameters.get("targetTermCode")[0]);
100 }
101 }
102
103
104
105
106
107 @Override
108 public void saveDataObject() {
109
110 if(getMaintenanceAction().equals(KRADConstants.MAINTENANCE_NEW_ACTION) ||
111 getMaintenanceAction().equals(KRADConstants.MAINTENANCE_COPY_ACTION)) {
112
113 try {
114 CourseOfferingCreateWrapper wrapper = (CourseOfferingCreateWrapper)getDataObject();
115
116 CourseOfferingInfo coInfo = new CourseOfferingInfo();
117 loadCrossListedCOs(wrapper,coInfo);
118
119 CourseOfferingInfo createdCOInfo = createCourseOfferingInfo(wrapper.getTerm().getId(), wrapper.getCourse(), wrapper.getCourseOfferingSuffix(),coInfo);
120 wrapper.setCourseOfferingInfo(createdCOInfo);
121
122 createFormatOfferings(wrapper);
123
124 createJointCOs(wrapper);
125
126 } catch (Exception e) {
127 throw new RuntimeException(e);
128 }
129 }
130 }
131
132 private DefaultOptionKeysService defaultOptionKeysService;
133
134 private DefaultOptionKeysService getDefaultOptionKeysService() {
135 if (defaultOptionKeysService == null) {
136 defaultOptionKeysService = new DefaultOptionKeysServiceImpl();
137 }
138 return this.defaultOptionKeysService;
139 }
140
141
142
143
144
145
146
147
148
149
150
151
152 protected CourseOfferingInfo createCourseOfferingInfo(String termId, CourseInfo courseInfo, String courseOfferingSuffix,CourseOfferingInfo courseOffering) throws Exception {
153
154 List<String> optionKeys = getDefaultOptionKeysService ().getDefaultOptionKeysForCreateCourseOfferingFromCanonical();
155
156 courseOffering.setTermId(termId);
157 courseOffering.setCourseOfferingTitle(courseInfo.getCourseTitle());
158
159
160
161 if (!StringUtils.isEmpty(courseOfferingSuffix)) {
162 courseOffering.setCourseOfferingCode(StringUtils.upperCase(courseOfferingSuffix));
163 courseOffering.setCourseNumberSuffix(StringUtils.upperCase(courseOfferingSuffix));
164 optionKeys.add(CourseOfferingServiceConstants.APPEND_COURSE_OFFERING_CODE_SUFFIX_OPTION_KEY);
165 }
166 courseOffering.setCourseId(courseInfo.getId());
167 courseOffering.setCourseCode(courseInfo.getCode());
168 courseOffering.setTypeKey(LuiServiceConstants.COURSE_OFFERING_TYPE_KEY);
169 courseOffering.setStateKey(LuiServiceConstants.LUI_CO_STATE_DRAFT_KEY);
170
171
172 if(!courseInfo.getCreditOptions().isEmpty()){
173 courseOffering.setCreditOptionId(courseInfo.getCreditOptions().get(0).getKey());
174 }
175
176 List<String> courseGradingOptions = new ArrayList<String>(courseInfo.getGradingOptions());
177 if(courseGradingOptions.remove(LrcServiceConstants.RESULT_GROUP_KEY_GRADE_PASSFAIL) ){
178 courseOffering.getStudentRegistrationGradingOptions().add(LrcServiceConstants.RESULT_GROUP_KEY_GRADE_PASSFAIL);
179 }
180 if(courseGradingOptions.remove(LrcServiceConstants.RESULT_GROUP_KEY_GRADE_AUDIT) ){
181 courseOffering.getStudentRegistrationGradingOptions().add(LrcServiceConstants.RESULT_GROUP_KEY_GRADE_AUDIT);
182 }
183
184 if(!courseGradingOptions.isEmpty()){
185 courseOffering.setGradingOptionId(courseGradingOptions.get(0));
186 }
187
188
189 if(!courseInfo.getAttributes().isEmpty()){
190 for(AttributeInfo info: courseInfo.getAttributes()){
191
192 if(info.getKey().equals("finalExamStatus")){
193 courseOffering.setFinalExamType(convertCourseFinalExamTypeToCourseOfferingFinalExamType(info.getValue()));
194 }
195 }
196 }
197
198 CourseOfferingInfo info = getCourseOfferingService().createCourseOffering(courseInfo.getId(), termId, LuiServiceConstants.COURSE_OFFERING_TYPE_KEY, courseOffering, optionKeys, ContextUtils.createDefaultContextInfo());
199 return info;
200 }
201
202
203
204
205
206
207 protected static String convertCourseFinalExamTypeToCourseOfferingFinalExamType(String courseFinalExamType){
208 String sRet = null;
209 if("STD".equals(courseFinalExamType)) {
210 sRet = CourseOfferingConstants.COURSEOFFERING_FINAL_EXAM_TYPE_STANDARD;
211 } else if("ALT".equals(courseFinalExamType)) {
212 sRet = CourseOfferingConstants.COURSEOFFERING_FINAL_EXAM_TYPE_ALTERNATE;
213 }
214 return sRet;
215 }
216
217
218
219
220
221
222
223
224 protected void createFormatOfferings(CourseOfferingCreateWrapper wrapper){
225 ContextInfo contextInfo = ContextUtils.createDefaultContextInfo();
226 for (FormatOfferingWrapper foWrapper : wrapper.getFormatOfferingWrappers()) {
227 if (!foWrapper.isJointOffering()){
228 foWrapper.getFormatOfferingInfo().setStateKey(LuiServiceConstants.LUI_FO_STATE_DRAFT_KEY);
229 foWrapper.getFormatOfferingInfo().setTypeKey(LuiServiceConstants.FORMAT_OFFERING_TYPE_KEY);
230 foWrapper.getFormatOfferingInfo().setTermId(wrapper.getCourseOfferingInfo().getTermId());
231 foWrapper.getFormatOfferingInfo().setCourseOfferingId(wrapper.getCourseOfferingInfo().getId());
232 try {
233
234 CourseOfferingViewHelperUtil.addActivityOfferingTypesToFormatOffering(foWrapper.getFormatOfferingInfo(), wrapper.getCourse(), getTypeService(), contextInfo);
235 FormatOfferingInfo createdFormatOffering = getCourseOfferingService().createFormatOffering(wrapper.getCourseOfferingInfo().getId(), foWrapper.getFormatId(), foWrapper.getFormatOfferingInfo().getTypeKey(), foWrapper.getFormatOfferingInfo(), contextInfo);
236
237 foWrapper.setFormatOfferingInfo(createdFormatOffering);
238 } catch (Exception e) {
239 throw new RuntimeException(e);
240 }
241 }
242 }
243 }
244
245
246
247
248
249
250
251 protected void createJointCOs(CourseOfferingCreateWrapper wrapper) throws Exception {
252 LOG.debug("Creating Offerings for the joint courses.");
253 ContextInfo contextInfo = ContextUtils.createDefaultContextInfo();
254 for (JointCourseWrapper jointWrapper : wrapper.getJointCourses()){
255 if (jointWrapper.isSelectedToJointlyOfferred()){
256 LOG.debug("Creating offerings for the joint course " + jointWrapper.getCourseCode());
257 CourseOfferingInfo coInfo = createCourseOfferingInfo(wrapper.getTerm().getId(), jointWrapper.getCourseInfo(), StringUtils.EMPTY, new CourseOfferingInfo());
258 for (FormatOfferingWrapper foWrapper : jointWrapper.getFormatOfferingWrappers()){
259 foWrapper.getFormatOfferingInfo().setStateKey(LuiServiceConstants.LUI_FO_STATE_DRAFT_KEY);
260 foWrapper.getFormatOfferingInfo().setTypeKey(LuiServiceConstants.FORMAT_OFFERING_TYPE_KEY);
261 foWrapper.getFormatOfferingInfo().setTermId(wrapper.getCourseOfferingInfo().getTermId());
262 foWrapper.getFormatOfferingInfo().setCourseOfferingId(coInfo.getId());
263 try {
264 CourseOfferingViewHelperUtil.addActivityOfferingTypesToFormatOffering(foWrapper.getFormatOfferingInfo(), jointWrapper.getCourseInfo(), getTypeService(), contextInfo);
265 FormatOfferingInfo createdFormatOffering = getCourseOfferingService().createFormatOffering(coInfo.getId(), foWrapper.getFormatOfferingInfo().getFormatId(), foWrapper.getFormatOfferingInfo().getTypeKey(), foWrapper.getFormatOfferingInfo(), contextInfo);
266 foWrapper.setFormatOfferingInfo(createdFormatOffering);
267 } catch (Exception e) {
268 throw new RuntimeException(e);
269 }
270 }
271 }
272 }
273 }
274
275
276
277
278
279
280
281
282 public void loadCourseJointInfos(CourseOfferingCreateWrapper wrapper, String viewId)
283 throws Exception {
284
285 List<CourseJointInfo> joints = wrapper.getCourse().getJoints();
286 wrapper.setShowJointOption(!joints.isEmpty());
287 wrapper.setJointCourseCodes(wrapper.getCourse().getCode());
288
289 Map<String,String> permissionDetails = new HashMap<String,String>();
290 Map<String,String> roleQualifications = new HashMap<String,String>();
291 String principalId = GlobalVariables.getUserSession().getPerson().getPrincipalId();
292
293 ContextInfo contextInfo = ContextUtils.createDefaultContextInfo();
294
295 for (CourseJointInfo joint : joints) {
296
297 JointCourseWrapper jointCourseWrapper = new JointCourseWrapper();
298 CourseInfo jointCourse = getCourseService().getCourse(joint.getCourseId(),contextInfo);
299 jointCourseWrapper.setCourseJointInfo(joint);
300 jointCourseWrapper.setCourseInfo(jointCourse);
301
302 List<CourseOfferingInfo> cos = getCourseOfferingService().getCourseOfferingsByCourseAndTerm(joint.getCourseId(),wrapper.getTerm().getId(),contextInfo);
303
304 if (!cos.isEmpty()){
305 LOG.debug("For the joint course " + jointCourse.getCode() + ", it already has the offerings created.");
306 jointCourseWrapper.setAlreadyOffered(true);
307 }
308
309 for (CourseOfferingInfo co : cos) {
310 List<FormatOfferingInfo> formatOfferings = getCourseOfferingService().getFormatOfferingsByCourseOffering(co.getId(),contextInfo);
311 for (FormatOfferingInfo formatOffering : formatOfferings) {
312 FormatOfferingWrapper foWrapper = new FormatOfferingWrapper();
313 foWrapper.setCourseCode(co.getCourseOfferingCode());
314 foWrapper.setFormatOfferingInfo(formatOffering);
315 CourseInfo courseInfo = getCourseService().getCourse(co.getCourseId(),contextInfo);
316 foWrapper.setFormatInfo(getFormatInfo(courseInfo,formatOffering.getFormatId()));
317 foWrapper.setActivitesUI(getActivityTypeNames(foWrapper.getFormatInfo()));
318 foWrapper.setGradeRosterUI(super.getTypeName(formatOffering.getGradeRosterLevelTypeKey()));
319 foWrapper.setFinalExamUI(super.getTypeName(formatOffering.getFinalExamLevelTypeKey()));
320 wrapper.getCopyFromFormats().add(foWrapper);
321 }
322 }
323
324
325 List<String> orgIds = jointCourse.getUnitsContentOwner();
326 if(orgIds != null && !orgIds.isEmpty()){
327 String orgIDs = "";
328 for (String orgId : orgIds) {
329 orgIDs = orgIDs + orgId + ",";
330 }
331 if (orgIDs.length() > 0) {
332 roleQualifications.put("offeringAdminOrgId", orgIDs.substring(0, orgIDs.length() - 1));
333 }
334 }
335 roleQualifications.put(PermissionServiceConstants.SUBJECT_AREA_ATTR_DEFINITION, jointCourse.getSubjectArea());
336 permissionDetails.put(KimConstants.AttributeConstants.VIEW_ID, viewId);
337 permissionDetails.put(KimConstants.AttributeConstants.ACTION_EVENT, "createNewCO");
338 jointCourseWrapper.setEnableCreateNewCOActionLink(false);
339 if(permissionService.isAuthorizedByTemplate(principalId, "KS-ENR", KimConstants.PermissionTemplateNames.PERFORM_ACTION, permissionDetails, roleQualifications)){
340 jointCourseWrapper.setEnableCreateNewCOActionLink(true);
341 }
342
343 wrapper.getJointCourses().add(jointCourseWrapper);
344 }
345
346 }
347
348
349
350
351
352
353 public void addFormatOffering(CourseOfferingCreateWrapper wrapper){
354
355 FormatOfferingWrapper addLine = wrapper.getAddLineFormatWrapper();
356
357 FormatInfo formatToBeAdded = getFormatInfo(wrapper.getCourse(), addLine.getFormatId());
358
359 for (JointCourseWrapper joint : wrapper.getJointCourses()){
360 if (joint.isSelectedToJointlyOfferred()){
361 FormatOfferingWrapper foForJoint = new FormatOfferingWrapper();
362 foForJoint.setJointOffering(true);
363 foForJoint.setJointCreateWrapper(joint);
364 foForJoint.setCourseCode(joint.getCourseCode());
365 foForJoint.setFinalExamLevelTypeKey(addLine.getFinalExamLevelTypeKey());
366 foForJoint.setGradeRosterLevelTypeKey(addLine.getGradeRosterLevelTypeKey());
367 foForJoint.setGradeRosterUI(getTypeName(addLine.getGradeRosterLevelTypeKey()));
368 foForJoint.setFinalExamUI(getTypeName(addLine.getFinalExamLevelTypeKey()));
369
370
371 FormatInfo formatInfo = getMatchingFormatInfo(joint.getCourseInfo(), formatToBeAdded);
372 if (formatInfo == null){
373 GlobalVariables.getMessageMap().putInfo("KS-Catalog-FormatOfferingSubSection-New", RiceKeyConstants.ERROR_CUSTOM,"There is no matching format to be added for joint course " + joint.getCourseCode());
374 } else {
375 foForJoint.setFormatInfo(formatInfo);
376 foForJoint.setFormatId(formatInfo.getId());
377 foForJoint.setActivitesUI(getActivityTypeNames(formatInfo));
378
379 wrapper.getFormatOfferingWrappers().add(0,foForJoint);
380 joint.getFormatOfferingWrappers().add(foForJoint);
381 }
382 }
383 }
384
385 FormatInfo formatInfo = getFormatInfo(wrapper.getCourse(), addLine.getFormatId());
386 addLine.setActivitesUI(getActivityTypeNames(formatInfo));
387 addLine.setFormatInfo(formatInfo);
388 addLine.setCourseCode(wrapper.getCourse().getCode());
389 wrapper.getFormatOfferingWrappers().add(0,addLine);
390 wrapper.setAddLineFormatWrapper(new FormatOfferingWrapper());
391 }
392
393
394
395
396
397
398
399 public void copyJointFormatOfferings(CourseOfferingCreateWrapper wrapper){
400
401
402 for(FormatOfferingWrapper foWrapper : wrapper.getCopyFromFormats()){
403
404 if (foWrapper.isSelectedToCopy()){
405
406 FormatInfo matchedFormat = getMatchingFormatInfo(wrapper.getCourse(),foWrapper.getFormatInfo());
407 boolean shouldCreateFO = true;
408
409 if (matchedFormat != null){
410
411 for (FormatOfferingWrapper existingFormat : wrapper.getFormatOfferingWrappers()){
412 if (StringUtils.equals(existingFormat.getFormatId(),matchedFormat.getId())){
413 shouldCreateFO = false;
414 GlobalVariables.getMessageMap().putError("KS-Catalog-FormatOfferingSubSection-New", RiceKeyConstants.ERROR_CUSTOM,"Already selected format exists for the course " + wrapper.getCourse().getCode());
415 break;
416 }
417 }
418 }
419
420 if (shouldCreateFO){
421 FormatOfferingWrapper newFormatOffering = new FormatOfferingWrapper(matchedFormat,wrapper.getCourse().getCode(),null);
422 newFormatOffering.setGradeRosterLevelTypeKey(foWrapper.getGradeRosterLevelTypeKey());
423 newFormatOffering.setFinalExamLevelTypeKey(foWrapper.getFinalExamLevelTypeKey());
424
425 newFormatOffering.setActivitesUI(foWrapper.getActivitesUI());
426 wrapper.getFormatOfferingWrappers().add(0,newFormatOffering);
427 }
428
429
430 for (JointCourseWrapper jointWrapper : wrapper.getJointCourses()){
431 if (jointWrapper.isSelectedToJointlyOfferred()){
432
433 matchedFormat = getMatchingFormatInfo(jointWrapper.getCourseInfo(),foWrapper.getFormatInfo());
434
435 shouldCreateFO = true;
436
437 if (matchedFormat != null){
438 for (FormatOfferingWrapper existingFormat : wrapper.getFormatOfferingWrappers()){
439 if (StringUtils.equals(existingFormat.getFormatId(),matchedFormat.getId())){
440 shouldCreateFO = false;
441 GlobalVariables.getMessageMap().putError("KS-Catalog-FormatOfferingSubSection-New", RiceKeyConstants.ERROR_CUSTOM,"Already selected format exists for the joint course " + jointWrapper.getCourseInfo().getCode());
442 break;
443 }
444 }
445 if (shouldCreateFO){
446 FormatOfferingWrapper newFormatOffering = new FormatOfferingWrapper(matchedFormat,jointWrapper.getCourseCode(),jointWrapper);
447 newFormatOffering.setGradeRosterLevelTypeKey(foWrapper.getGradeRosterLevelTypeKey());
448 newFormatOffering.setFinalExamLevelTypeKey(foWrapper.getFinalExamLevelTypeKey());
449
450 newFormatOffering.setActivitesUI(foWrapper.getActivitesUI());
451 jointWrapper.getFormatOfferingWrappers().add(newFormatOffering);
452 wrapper.getFormatOfferingWrappers().add(0,newFormatOffering);
453 }
454 }
455 }
456 }
457 }
458 }
459 }
460
461
462
463
464
465
466
467 private String getActivityTypeNames(FormatInfo formatInfo){
468
469 ContextInfo contextInfo = ContextUtils.createDefaultContextInfo();
470 StringBuffer activities = new StringBuffer();
471
472 try {
473 List<ActivityInfo> activityInfos = formatInfo.getActivities();
474 for (ActivityInfo activityInfo : activityInfos) {
475 TypeInfo activityType = getTypeService().getType(activityInfo.getTypeKey(), contextInfo);
476 activities.append(activityType.getName() + "/");
477 }
478 } catch (Exception e) {
479 throw new RuntimeException(e);
480 }
481
482 return StringUtils.removeEnd(activities.toString(),"/");
483 }
484
485
486
487
488
489
490
491
492 private FormatInfo getFormatInfo(CourseInfo courseInfo, String formatId){
493 for (FormatInfo formatInfo : courseInfo.getFormats()){
494 if (StringUtils.equals(formatInfo.getId(),formatId)){
495 return formatInfo;
496 }
497 }
498 return null;
499 }
500
501
502
503
504
505
506
507
508
509
510 @Override
511 public void processCollectionDeleteLine(View view, Object model, String collectionPath, int lineIndex){
512 Collection<Object> collection = ObjectPropertyUtils.getPropertyValue(model, collectionPath);
513 FormatOfferingWrapper deleteLine = (FormatOfferingWrapper)((List<Object>) collection).get(lineIndex);
514 if (deleteLine.isJointOffering()){
515 deleteLine.getJointCreateWrapper().getFormatOfferingWrappers().remove(deleteLine);
516 }
517 ((List<Object>) collection).remove(lineIndex);
518 }
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533 public FormatInfo getMatchingFormatInfo(CourseInfo courseInfoToSearch, FormatInfo formatInfoToMatchWith){
534 for (FormatInfo searchFormat : courseInfoToSearch.getFormats()){
535 if (StringUtils.equalsIgnoreCase(formatInfoToMatchWith.getTypeKey(),searchFormat.getTypeKey())){
536 if (!formatInfoToMatchWith.getActivities().isEmpty() && formatInfoToMatchWith.getActivities().size() == searchFormat.getActivities().size()){
537 boolean isMatchFound = true;
538 for (ActivityInfo activityInfo : formatInfoToMatchWith.getActivities()){
539 if (!isMatchingJointActivityFound(searchFormat,activityInfo)){
540 isMatchFound = false;
541 break;
542 }
543 }
544 if (isMatchFound){
545 return searchFormat;
546 }
547 }
548 }
549 }
550 return null;
551 }
552
553
554
555
556
557
558
559
560
561 private boolean isMatchingJointActivityFound(FormatInfo jointCourseFormat, ActivityInfo activityInfo){
562 for (ActivityInfo activityFromJointCourse : jointCourseFormat.getActivities()){
563 if (!StringUtils.equals(activityInfo.getTypeKey(),activityFromJointCourse.getTypeKey())){
564 return false;
565 }
566 }
567 return true;
568 }
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593 public List<String> retrieveCourseCodes(String targetTermCode, String catalogCourseCode) throws InvalidParameterException, MissingParameterException, PermissionDeniedException, OperationFailedException {
594
595 List<String> results = new ArrayList<String>();
596
597 if(catalogCourseCode == null || catalogCourseCode.isEmpty()) return results;
598
599 catalogCourseCode = catalogCourseCode.toUpperCase();
600
601 MultiKey cacheKey = new MultiKey(targetTermCode+"retrieveCourseCodes", catalogCourseCode);
602
603
604 if(catalogCourseCode.length() == 1){
605 Element cachedResult = getCacheManager().getCache(CACHE_NAME).get(cacheKey);
606
607 Object result;
608 if (cachedResult == null) {
609 result = _retrieveCourseCodes(targetTermCode, catalogCourseCode);
610 getCacheManager().getCache(CACHE_NAME).put(new Element(cacheKey, result));
611 results = (List<String>)result;
612 } else {
613 results = (List<String>)cachedResult.getValue();
614 }
615 }else{
616 Element cachedResult = getCacheManager().getCache(CACHE_NAME).get(cacheKey);
617
618 if (cachedResult == null) {
619
620
621
622 for(String courseCode : retrieveCourseCodes(targetTermCode, catalogCourseCode.substring(0,catalogCourseCode.length()-1))){
623
624 if(courseCode.startsWith(catalogCourseCode)){
625 results.add(courseCode);
626 }
627 }
628
629 getCacheManager().getCache(CACHE_NAME).put(new Element(cacheKey, results));
630 } else {
631 results = (List<String>)cachedResult.getValue();
632 }
633 }
634
635 return results;
636 }
637
638
639
640
641
642
643 private List<String> _retrieveCourseCodes(String targetTermCode, String catalogCourseCode) throws InvalidParameterException, MissingParameterException, PermissionDeniedException, OperationFailedException {
644
645 List<String> rList = new ArrayList<String>();
646 ContextInfo context = ContextUtils.createDefaultContextInfo();
647
648
649 List<AtpInfo> atps = getAtpService().getAtpsByCode(targetTermCode, context);
650 if(atps == null || atps.size() != 1){
651 return rList;
652 }
653
654
655 SearchRequestInfo request = new SearchRequestInfo("lu.search.courseCodes");
656 request.addParam("lu.queryParam.startsWith.cluCode", catalogCourseCode);
657 request.addParam("lu.queryParam.luOptionalType", CluServiceConstants.CREDIT_COURSE_LU_TYPE_KEY);
658 request.addParam("lu.queryParam.luOptionalGreaterThanEqualExpirDate", DateFormatters.QUERY_SERVICE_TIMESTAMP_FORMATTER.format(atps.get(0).getStartDate()));
659 request.addParam("lu.queryParam.luOptionalLessThanEqualEffectDate", DateFormatters.QUERY_SERVICE_TIMESTAMP_FORMATTER.format(atps.get(0).getEndDate()));
660 request.setSortColumn("lu.resultColumn.cluOfficialIdentifier.cluCode");
661
662 SearchResultInfo results = getCluService().search(request, context);
663 for(SearchResultRow row:results.getRows()){
664 for(SearchResultCell cell:row.getCells()){
665 if("lu.resultColumn.cluOfficialIdentifier.cluCode".equals(cell.getKey())){
666 rList.add(cell.getValue());
667 }
668 }
669 }
670 return rList;
671 }
672
673 private CluService getCluService() {
674 if(cluService == null){
675 cluService = CourseOfferingResourceLoader.loadCluService();
676 }
677 return cluService;
678 }
679
680 private AtpService getAtpService() {
681 if(atpService == null){
682 atpService = CourseOfferingResourceLoader.loadAtpService();
683 }
684 return atpService;
685 }
686
687 public class CourseCodeSuggestResults{
688
689 private String catalogCourseCode;
690
691 public CourseCodeSuggestResults() {
692 super();
693 }
694
695 public CourseCodeSuggestResults(String catalogCourseCode) {
696 this();
697 this.catalogCourseCode = catalogCourseCode;
698 }
699
700 public String getCatalogCourseCode() {
701 return catalogCourseCode;
702 }
703
704 public void setCatalogCourseCode(String catalogCourseCode) {
705 this.catalogCourseCode = catalogCourseCode;
706 }
707 }
708
709 private static PermissionService getPermissionService() {
710 if(permissionService==null){
711 permissionService = KimApiServiceLocator.getPermissionService();
712 }
713 return permissionService;
714 }
715
716 public CacheManager getCacheManager() {
717 if(cacheManager == null){
718
719 cacheManager = CacheManager.getCacheManager("ks-ehcache");
720 }
721 return cacheManager;
722 }
723
724 public void setCacheManager(CacheManager cacheManager) {
725 this.cacheManager = cacheManager;
726 }
727 }