Source code

001/*
002 * Copyright 2014 The Kuali Foundation Licensed under the
003 * Educational Community License, Version 2.0 (the "License"); you may
004 * not use this file except in compliance with the License. You may
005 * obtain a copy of the License at
006 *
007 * http://www.osedu.org/licenses/ECL-2.0
008 *
009 * Unless required by applicable law or agreed to in writing,
010 * software distributed under the License is distributed on an "AS IS"
011 * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
012 * or implied. See the License for the specific language governing
013 * permissions and limitations under the License.
014 */
015package org.kuali.student.ap.coursesearch.service.impl;
016
017import org.apache.commons.collections.CollectionUtils;
018import org.apache.commons.lang.StringUtils;
019import org.kuali.rice.krad.uif.UifConstants;
020import org.kuali.rice.krad.uif.container.GroupBase;
021import org.kuali.rice.krad.uif.service.impl.ViewHelperServiceImpl;
022import org.kuali.rice.krad.uif.widget.Disclosure;
023import org.kuali.rice.krad.web.form.UifFormBase;
024import org.kuali.student.ap.academicplan.dto.PlanItemInfo;
025import org.kuali.student.ap.academicplan.infc.LearningPlan;
026import org.kuali.student.ap.academicplan.infc.PlanItem;
027import org.kuali.student.ap.coursesearch.CreditsFormatter;
028import org.kuali.student.ap.coursesearch.dataobject.ActivityFormatDetailsWrapper;
029import org.kuali.student.ap.coursesearch.dataobject.ActivityOfferingDetailsWrapper;
030import org.kuali.student.ap.coursesearch.dataobject.CourseOfferingDetailsWrapper;
031import org.kuali.student.ap.coursesearch.dataobject.CourseTermDetailsWrapper;
032import org.kuali.student.ap.coursesearch.dataobject.FormatOfferingInfoWrapper;
033import org.kuali.student.ap.coursesearch.dataobject.PlannedRegistrationGroupDetailsWrapper;
034import org.kuali.student.ap.coursesearch.form.CourseSectionDetailsDialogForm;
035import org.kuali.student.ap.coursesearch.form.CourseSectionDetailsForm;
036import org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService;
037import org.kuali.student.ap.coursesearch.util.CourseDetailsUtil;
038import org.kuali.student.ap.framework.config.KsapFrameworkServiceLocator;
039import org.kuali.student.ap.framework.context.CourseSearchConstants;
040import org.kuali.student.ap.framework.context.PlanConstants;
041import org.kuali.student.ap.framework.util.KsapHelperUtil;
042import org.kuali.student.ap.planner.service.impl.PlanEventViewHelperServiceImpl;
043import org.kuali.student.common.collection.KSCollectionUtils;
044import org.kuali.student.common.util.security.ContextUtils;
045import org.kuali.student.enrollment.courseoffering.dto.ActivityOfferingInfo;
046import org.kuali.student.enrollment.courseoffering.dto.FormatOfferingInfo;
047import org.kuali.student.enrollment.courseoffering.dto.OfferingInstructorInfo;
048import org.kuali.student.enrollment.courseoffering.dto.RegistrationGroupInfo;
049import org.kuali.student.enrollment.courseoffering.infc.CourseOffering;
050import org.kuali.student.enrollment.courseseatcount.infc.SeatCount;
051import org.kuali.student.r2.common.dto.ContextInfo;
052import org.kuali.student.r2.common.dto.TimeOfDayInfo;
053import org.kuali.student.r2.common.exceptions.DoesNotExistException;
054import org.kuali.student.r2.common.exceptions.InvalidParameterException;
055import org.kuali.student.r2.common.exceptions.MissingParameterException;
056import org.kuali.student.r2.common.exceptions.OperationFailedException;
057import org.kuali.student.r2.common.exceptions.PermissionDeniedException;
058import org.kuali.student.r2.common.util.TimeOfDayHelper;
059import org.kuali.student.r2.common.util.constants.LuiServiceConstants;
060import org.kuali.student.r2.core.acal.dto.TermInfo;
061import org.kuali.student.r2.core.acal.infc.Term;
062import org.kuali.student.r2.core.class1.type.dto.TypeInfo;
063import org.kuali.student.r2.core.room.dto.BuildingInfo;
064import org.kuali.student.r2.core.room.dto.RoomInfo;
065import org.kuali.student.r2.core.scheduling.constants.SchedulingServiceConstants;
066import org.kuali.student.r2.core.scheduling.dto.ScheduleComponentInfo;
067import org.kuali.student.r2.core.scheduling.dto.ScheduleInfo;
068import org.kuali.student.r2.core.scheduling.dto.TimeSlotInfo;
069import org.kuali.student.r2.core.search.dto.SearchRequestInfo;
070import org.kuali.student.r2.core.search.dto.SearchResultRowInfo;
071import org.kuali.student.r2.lum.course.infc.Course;
072import org.slf4j.Logger;
073import org.slf4j.LoggerFactory;
074
075import javax.json.Json;
076import javax.json.JsonArrayBuilder;
077import javax.json.JsonObjectBuilder;
078import java.util.ArrayList;
079import java.util.Collection;
080import java.util.Collections;
081import java.util.Comparator;
082import java.util.HashMap;
083import java.util.LinkedHashMap;
084import java.util.List;
085import java.util.Map;
086import java.util.UUID;
087
088/**
089 * {@inheritDoc}
090 */
091public class CourseDetailsViewHelperServiceImpl extends PlanEventViewHelperServiceImpl implements CourseDetailsViewHelperService {
092    private static final Logger LOG = LoggerFactory.getLogger(CourseDetailsViewHelperServiceImpl.class);
093
094    /**
095     * {@inheritDoc}
096     */
097    @Override
098    public void loadCourseSectionDetails(UifFormBase form, String courseId)  {
099        load((CourseSectionDetailsForm) form, courseId);
100    }
101
102    /**
103     * Load information on the course and its offerings into the form
104     *
105     * @param form - Page form to load information onto
106     * @param courseId - Id of the course being loaded
107     */
108    private void load(CourseSectionDetailsForm form, String courseId)  {
109        Course courseInfo = KsapFrameworkServiceLocator.getCourseHelper().getCurrentVersionOfCourse(courseId);
110        form.setCourseTitle(courseInfo.getCourseTitle());
111        form.setCourseCode(courseInfo.getCode());
112        List<String> termIds = KsapFrameworkServiceLocator.getCourseHelper().getScheduledTermsForCourse(courseInfo);
113        form.setCourseTermDetailsWrappers(getScheduledTerms(termIds, courseInfo.getVersion().getVersionIndId()));
114    }
115
116    /**
117     * Load data for terms with scheduled course offerings for the course
118     *
119     * @param scheduledTermsList - List of term ids
120     * @param versionIndId - Version independent Id of the course data is being loaded for
121     * @return A list of filled in terms to display
122     */
123    private List<CourseTermDetailsWrapper> getScheduledTerms(List<String> scheduledTermsList, String versionIndId)  {
124
125        List<CourseTermDetailsWrapper> courseTermDetailsList = new ArrayList<CourseTermDetailsWrapper>();
126
127        //Return only the scheduled terms
128        if (scheduledTermsList != null && scheduledTermsList.size() > 0) {
129
130            List<TermInfo> scheduledTerms;
131            try {
132                scheduledTerms = KsapFrameworkServiceLocator.getAcademicCalendarService().getTermsByIds(scheduledTermsList, KsapFrameworkServiceLocator.getContext().getContextInfo());
133            } catch (DoesNotExistException e) {
134                throw new IllegalArgumentException("ATP lookup error", e);
135            } catch (InvalidParameterException e) {
136                throw new IllegalArgumentException("ATP lookup error", e);
137            } catch (MissingParameterException e) {
138                throw new IllegalArgumentException("ATP lookup error", e);
139            } catch (OperationFailedException e) {
140                throw new IllegalStateException("ATP lookup error", e);
141            } catch (PermissionDeniedException e) {
142                throw new IllegalStateException("ATP lookup error", e);
143            }
144
145            //sort scheduledTermsListIds
146            List<Term> terms = new ArrayList<Term>(scheduledTerms);
147            List<Term> scheduledTermsListSorted = sortTerms(terms);
148
149            // Create and load information of the course offerings for the term
150            List<String> courseIds = new ArrayList<String>();
151
152            // Get all versions of the course
153            courseIds.addAll(KsapFrameworkServiceLocator.getCourseHelper().getAllCourseIdsByVersionIndependentId(versionIndId));
154            Map<String, List<CourseOfferingDetailsWrapper>> courseOfferingsByTerm = processCourseOfferingsByTerm(courseIds, terms);
155
156            // Create the term details wrapper and load data for it.
157            for (Term scheduledTermId : scheduledTermsListSorted) {
158
159                CourseTermDetailsWrapper courseTerm = new CourseTermDetailsWrapper();
160                courseTerm.setTermName(scheduledTermId.getName());
161                courseTerm.setTermId(scheduledTermId.getId());
162                courseTerm.setCourseOfferingDetailsWrappers(courseOfferingsByTerm.get(scheduledTermId.getId()));
163
164                courseTermDetailsList.add(courseTerm);
165            }
166        }
167
168        return courseTermDetailsList;
169    }
170
171    /**
172     * {@inheritDoc}
173     * This implementation is sorting by the date that the Soc was released/published
174     */
175    @Override
176    public List<Term> sortTerms(List<Term> terms) {
177        return KsapFrameworkServiceLocator.getTermHelper().sortTermsBySocReleaseDate(terms, false);
178    }
179
180    /**
181     * Comparator implementation so that I can sort CourseOfferingInfo objects by the course offering code
182     */
183    public class CourseOfferingInfoComparator implements Comparator<CourseOffering> {
184
185        @Override
186        public int compare(CourseOffering o1, CourseOffering o2) {
187            return o1.getCourseOfferingCode().compareTo(o2.getCourseOfferingCode());
188        }
189    }
190
191    /**
192     * Comparator implementation so that I can sort ActivityOfferingInfo objects by the activity code
193     */
194    public class ActivityOfferingInfoComparator implements Comparator<ActivityOfferingInfo> {
195
196        @Override
197        public int compare(ActivityOfferingInfo o1, ActivityOfferingInfo o2) {
198            return o1.getActivityCode().compareTo(o2.getActivityCode());
199        }
200    }
201
202    /**
203     * {@inheritDoc}
204     */
205    @Override
206    public Map<String, List<CourseOfferingDetailsWrapper>> processCourseOfferingsByTerm(List<String> courseIds, List<Term> terms) {
207        List<CourseOffering> courseOfferings = KsapFrameworkServiceLocator.getCourseHelper().getCourseOfferingsForCoursesAndTerms(courseIds, terms);
208        Collections.sort(courseOfferings, new CourseOfferingInfoComparator());
209        Map<String, List<CourseOfferingDetailsWrapper>> map = new HashMap<String, List<CourseOfferingDetailsWrapper>>();
210        ContextInfo contextInfo = KsapFrameworkServiceLocator.getContext().getContextInfo();
211
212        for (CourseOffering offering : courseOfferings) {
213            String termId = offering.getTermId();
214            List<CourseOfferingDetailsWrapper> offeringsByTerm = map.get(termId);
215            if (offeringsByTerm == null)
216                offeringsByTerm = new ArrayList<CourseOfferingDetailsWrapper>();
217
218            List<String> validRegGroups = getValidRegGroupIds(offering.getId(), new HashMap<Object, Object>());
219            List<String> validRegGroupsToRemain = getValidRegGroupIdsToRemain(offering.getId(), new HashMap<Object, Object>());
220
221            List<String> validFormatOfferings = new ArrayList<String>();
222            List<String> validActivities = new ArrayList<String>();
223            List<String> validActivitiesToRemain = new ArrayList<String>();
224
225            // Get valid activities that are of reg groups able to be added
226            for(String id : validRegGroups){
227                List<String> activityIds = new ArrayList<String>();
228                List<String> formatIds = new ArrayList<String>();
229                try {
230                    SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
231                            .KSAP_COURSE_SEARCH_AO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
232                    request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
233                    List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
234                            KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
235                    for( SearchResultRowInfo row : rows){
236                        activityIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
237                                .ACTIVITY_OFFERING_ID));
238                    }
239
240                    request = new SearchRequestInfo(CourseSearchConstants
241                            .KSAP_COURSE_SEARCH_FO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
242                    request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
243                    rows = KsapFrameworkServiceLocator.getSearchService().search(request,
244                            KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
245                    for( SearchResultRowInfo row : rows){
246                        formatIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
247                                .FORMAT_OFFERING_ID));
248                    }
249                } catch (InvalidParameterException e) {
250                    throw new IllegalArgumentException("Lui Service lookup error", e);
251                } catch (MissingParameterException e) {
252                    throw new IllegalArgumentException("Lui Service lookup error", e);
253                } catch (OperationFailedException e) {
254                    throw new IllegalArgumentException("Lui Service lookup error", e);
255                } catch (PermissionDeniedException e) {
256                    throw new IllegalArgumentException("Lui Service lookup error", e);
257                }
258                if(activityIds != null && !activityIds.isEmpty()){
259                    validActivities.addAll(activityIds);
260                }
261
262                if(formatIds != null && !formatIds.isEmpty()){
263                    validFormatOfferings.addAll(formatIds);
264                }
265            }
266
267            // Get valid activities to keep showing on the page
268            for(String id : validRegGroupsToRemain){
269                List<String> activityIds = new ArrayList<String>();
270                try {
271                    SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
272                            .KSAP_COURSE_SEARCH_AO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
273                    request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
274                    List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
275                            KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
276                    for( SearchResultRowInfo row : rows){
277                        activityIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
278                                .ACTIVITY_OFFERING_ID));
279                    }
280                } catch (InvalidParameterException e) {
281                    throw new IllegalArgumentException("Lui Service lookup error", e);
282                } catch (MissingParameterException e) {
283                    throw new IllegalArgumentException("Lui Service lookup error", e);
284                } catch (OperationFailedException e) {
285                    throw new IllegalArgumentException("Lui Service lookup error", e);
286                } catch (PermissionDeniedException e) {
287                    throw new IllegalArgumentException("Lui Service lookup error", e);
288                }
289                if(activityIds != null && !activityIds.isEmpty()){
290                    validActivitiesToRemain.addAll(activityIds);
291                }
292            }
293
294            CourseOfferingDetailsWrapper courseOfferingDetailsWrapper = new CourseOfferingDetailsWrapper(offering);
295            List<FormatOfferingInfo> formatOfferings = null;
296            try {
297                formatOfferings = KsapFrameworkServiceLocator.getCourseOfferingService().getFormatOfferingsByCourseOffering(offering.getId(), contextInfo);
298                List<FormatOfferingInfoWrapper> formatOfferingWrappers = new ArrayList<FormatOfferingInfoWrapper>(formatOfferings.size());
299                //Figure out if the CO is a variable credit course
300                boolean isCourseOfferingVariableCredit = isVariableCreditCourse(offering);
301
302                courseOfferingDetailsWrapper.setVariableCredit(isCourseOfferingVariableCredit);
303
304                Map<String, Map<String, List<ActivityOfferingDetailsWrapper>>>
305                        aosByFormat = getAOData(offering.getId(),validActivities, validActivitiesToRemain, isCourseOfferingVariableCredit);
306
307                List<PlannedRegistrationGroupDetailsWrapper> plannedActivityOfferings = new ArrayList<PlannedRegistrationGroupDetailsWrapper>();
308
309                for (FormatOfferingInfo formatOffering : formatOfferings) {
310
311                    //Ignore non-offered FO's
312                    if (!LuiServiceConstants.LUI_FO_STATE_OFFERED_KEY.equalsIgnoreCase(formatOffering.getStateKey()))
313                        continue;
314
315                    FormatOfferingInfoWrapper formatOfferingInfo = new FormatOfferingInfoWrapper(formatOffering, courseOfferingDetailsWrapper.getCourseOfferingCode());
316                    formatOfferingInfo.setValidFormat(validFormatOfferings.contains(formatOfferingInfo.getFormatOfferingId()));
317
318                    formatOfferingInfo.setVariableCredit(isCourseOfferingVariableCredit);
319
320                    List<ActivityFormatDetailsWrapper> activityFormatDetailsWrappers = new ArrayList<ActivityFormatDetailsWrapper>();
321                    Map<String, List<ActivityOfferingDetailsWrapper>> aosByTypeMap = aosByFormat.get(formatOfferingInfo.getFormatOfferingId());
322
323                    if (aosByTypeMap != null) {
324                        List<ActivityOfferingDetailsWrapper> tempActivityOfferingDetailWrappers = new ArrayList<ActivityOfferingDetailsWrapper>();
325                        for (Map.Entry<String, List<ActivityOfferingDetailsWrapper>> aosByType : aosByTypeMap.entrySet()) {
326                            //TypeService is cached, so this should be safe to have inside the loop here
327                            TypeInfo typeInfo = KsapFrameworkServiceLocator.getTypeService().getType(aosByType.getKey(), contextInfo);
328                            ActivityFormatDetailsWrapper activityFormatDetailsWrapper = new ActivityFormatDetailsWrapper(
329                                    termId, offering.getCourseOfferingCode(), formatOfferingInfo.getFormatOfferingId(), typeInfo.getName(), typeInfo.getKey());
330
331                            activityFormatDetailsWrapper.setActivityOfferingDetailsWrappers(aosByType.getValue());
332                            activityFormatDetailsWrappers.add(activityFormatDetailsWrapper);
333
334                            tempActivityOfferingDetailWrappers.addAll(aosByType.getValue());
335
336                        }
337                        plannedActivityOfferings.addAll(getPlannedPlannedRegistrationGroups(termId, tempActivityOfferingDetailWrappers));
338                    }
339
340                    formatOfferingInfo.setActivityFormatDetailsWrappers(activityFormatDetailsWrappers);
341                    formatOfferingWrappers.add(formatOfferingInfo);
342
343                }
344                Collections.sort(formatOfferingWrappers);
345                courseOfferingDetailsWrapper.setFormatOfferingInfoWrappers(formatOfferingWrappers);
346                courseOfferingDetailsWrapper.setPlannedActivityDetailsWrappers(plannedActivityOfferings);
347            } catch (DoesNotExistException e) {
348                throw new IllegalArgumentException("FO lookup error", e);
349            } catch (InvalidParameterException e) {
350                throw new IllegalArgumentException("FO lookup error", e);
351            } catch (MissingParameterException e) {
352                throw new IllegalArgumentException("FO lookup error", e);
353            } catch (OperationFailedException e) {
354                throw new IllegalArgumentException("FO lookup error", e);
355            } catch (PermissionDeniedException e) {
356                throw new IllegalArgumentException("FO lookup error", e);
357            }
358
359            offeringsByTerm.add(courseOfferingDetailsWrapper);
360            map.put(termId, offeringsByTerm);
361        }
362
363        return map;
364    }
365
366    /**
367     * {@inheritDoc}
368     */
369    @Override
370    public ActivityOfferingDetailsWrapper convertAOInfoToWrapper(ActivityOfferingInfo aoInfo, boolean isCourseOfferingVariableCredit, Map<String, FormatOfferingInfo> formatOfferingInfoMap)  {
371        ActivityOfferingDetailsWrapper wrapper = new ActivityOfferingDetailsWrapper(aoInfo, false, true);
372        ContextInfo contextInfo = KsapFrameworkServiceLocator.getContext().getContextInfo();
373
374        int firstValue = 0;
375
376        FormatOfferingInfo fo = null;
377        try {
378            fo = formatOfferingInfoMap.get(aoInfo.getFormatOfferingId());
379            if (fo == null) {
380                fo = KsapFrameworkServiceLocator.getCourseOfferingService().getFormatOffering(aoInfo.getFormatOfferingId(), contextInfo);
381                formatOfferingInfoMap.put(aoInfo.getFormatOfferingId(), fo);
382            }
383        } catch (DoesNotExistException e) {
384            throw new IllegalArgumentException("CO Service lookup error", e);
385        } catch (InvalidParameterException e) {
386            throw new IllegalArgumentException("CO Service lookup error", e);
387        } catch (MissingParameterException e) {
388            throw new IllegalArgumentException("CO Service lookup error", e);
389        } catch (OperationFailedException e) {
390            throw new IllegalArgumentException("CO Service lookup error", e);
391        } catch (PermissionDeniedException e) {
392            throw new IllegalArgumentException("CO Service lookup error", e);
393        }
394
395        TypeInfo typeInfo = null;
396        try {
397            typeInfo = KsapFrameworkServiceLocator.getTypeService().getType(aoInfo.getTypeKey(), contextInfo);
398        } catch (DoesNotExistException e) {
399            throw new IllegalArgumentException("Type Service lookup error", e);
400        } catch (InvalidParameterException e) {
401            throw new IllegalArgumentException("Type Service lookup error", e);
402        } catch (MissingParameterException e) {
403            throw new IllegalArgumentException("Type Service lookup error", e);
404        } catch (OperationFailedException e) {
405            throw new IllegalArgumentException("Type Service lookup error", e);
406        } catch (PermissionDeniedException e) {
407            throw new IllegalArgumentException("Type Service lookup error", e);
408        }
409
410        wrapper.setActivityFormatName(typeInfo.getName());
411        if (fo.getActivityOfferingTypeKeys().size()>1) {
412            wrapper.setSingleFormatOffering(false);
413        }else{
414            List<RegistrationGroupInfo> regGroups = null;
415            try {
416                regGroups = KsapFrameworkServiceLocator.getCourseOfferingService().getRegistrationGroupsByActivityOffering(aoInfo.getId(),contextInfo);
417            } catch (DoesNotExistException e) {
418                throw new IllegalArgumentException("CO Service lookup error", e);
419            } catch (InvalidParameterException e) {
420                throw new IllegalArgumentException("CO Service lookup error", e);
421            } catch (MissingParameterException e) {
422                throw new IllegalArgumentException("CO Service lookup error", e);
423            } catch (OperationFailedException e) {
424                throw new IllegalArgumentException("CO Service lookup error", e);
425            } catch (PermissionDeniedException e) {
426                throw new IllegalArgumentException("CO Service lookup error", e);
427            }
428            RegistrationGroupInfo regGroup;
429            try{
430                regGroup = KSCollectionUtils.getRequiredZeroElement(regGroups);
431                wrapper.setRegGroupCode(regGroup.getName());
432                wrapper.setRegGroupId(regGroup.getId());
433            }catch(OperationFailedException e){
434                throw new IllegalArgumentException("Multiple Registration Groups Found for Single Format Activity Offering",e);
435            }
436        }
437
438        //From Bonnie: we need to better understand firstInstructor vs.multiple instructors cases -- pull in the logic from manage CO
439        OfferingInstructorInfo displayInstructor = findDisplayInstructor(aoInfo.getInstructors());
440
441        if (displayInstructor != null) {
442            wrapper.setFirstInstructorDisplayName(displayInstructor.getPersonName());
443            wrapper.setInstructorName(displayInstructor.getPersonName());
444        }
445
446        //for multiple instructor display
447        List<OfferingInstructorInfo> instructorInfos = aoInfo.getInstructors();
448        if (instructorInfos != null) {
449            for (OfferingInstructorInfo offeringInstructorInfo : instructorInfos) {
450                wrapper.setInstructorDisplayNames(offeringInstructorInfo.getPersonName(), true);
451            }
452        }
453
454        //This section is to display either schedule actuals assume that when an AO is offered, actuals are always available
455        if (aoInfo.getScheduleIds() != null && aoInfo.getScheduleIds().size() > 0) {
456            //FIXME: Use display object once we get the TBA with ScheduleComponentDisplay
457            List<ScheduleInfo> scheduleInfoList = null;
458            try {
459                scheduleInfoList = KsapFrameworkServiceLocator.getSchedulingService().getSchedulesByIds(aoInfo.getScheduleIds(), contextInfo);
460            } catch (DoesNotExistException e) {
461                throw new IllegalArgumentException("Scheduling Service lookup error", e);
462            } catch (InvalidParameterException e) {
463                throw new IllegalArgumentException("Scheduling Service lookup error", e);
464            } catch (MissingParameterException e) {
465                throw new IllegalArgumentException("Scheduling Service lookup error", e);
466            } catch (OperationFailedException e) {
467                throw new IllegalArgumentException("Scheduling Service lookup error", e);
468            } catch (PermissionDeniedException e) {
469                throw new IllegalArgumentException("Scheduling Service lookup error", e);
470            }
471
472            if (!scheduleInfoList.isEmpty()) {
473                for (ScheduleInfo scheduleInfo : scheduleInfoList) {
474                    if (!scheduleInfo.getScheduleComponents().isEmpty()) {
475
476                        for (ScheduleComponentInfo scheduleComponentInfo : scheduleInfo.getScheduleComponents()) {
477
478                            String roomId = scheduleComponentInfo.getRoomId();
479                            // JIRA Fix : KSENROLL-8726. Added isEmpty check
480                            TimeSlotInfo timeSlotInfo = null;
481                            try {
482                                timeSlotInfo = KsapFrameworkServiceLocator.getSchedulingService().getTimeSlot(scheduleComponentInfo.getTimeSlotIds().isEmpty() ? StringUtils.EMPTY : scheduleComponentInfo.getTimeSlotIds().get(firstValue), contextInfo);
483                            } catch (DoesNotExistException e) {
484                                throw new IllegalArgumentException("Scheduling Service lookup error", e);
485                            } catch (InvalidParameterException e) {
486                                throw new IllegalArgumentException("Scheduling Service lookup error", e);
487                            } catch (MissingParameterException e) {
488                                throw new IllegalArgumentException("Scheduling Service lookup error", e);
489                            } catch (OperationFailedException e) {
490                                throw new IllegalArgumentException("Scheduling Service lookup error", e);
491                            } catch (PermissionDeniedException e) {
492                                throw new IllegalArgumentException("Scheduling Service lookup error", e);
493                            }
494
495                            updateScheduleToAOWrapperForDisplay(wrapper, scheduleComponentInfo.getIsTBA(), roomId, timeSlotInfo);
496
497                        }
498
499                    }
500                }
501            }
502
503        }
504        wrapper.setClassUrl(aoInfo.getActivityOfferingURL());
505
506        List<String> aoRequisites = CourseDetailsUtil.getActivityOfferingRequisites(aoInfo);
507
508
509        if (aoRequisites.size()>0)
510            wrapper.setHasActivityOfferingRequisites(true);
511
512        wrapper.setInPlan(false);
513
514        try {
515            SeatCount seatCount = KsapFrameworkServiceLocator.getCourseSeatCountService()
516                    .getSeatCountForActivityOffering(aoInfo.getId(), contextInfo);
517            if(seatCount!=null && seatCount.getAvailableSeats() != null){
518                wrapper.setCurrentEnrollment(seatCount.getAvailableSeats());
519            }else{
520                LOG.error("Unable to get seat counts as returned value is null for Activity: "+aoInfo.getActivityId());
521                wrapper.setCurrentEnrollment(0);
522            }
523
524        } catch (DoesNotExistException e) {
525            throw new IllegalArgumentException("Academic Plan Service lookup error", e);
526        } catch (InvalidParameterException e) {
527            throw new IllegalArgumentException("Academic Plan Service lookup error", e);
528        } catch (MissingParameterException e) {
529            throw new IllegalArgumentException("Academic Plan Service lookup error", e);
530        } catch (OperationFailedException e) {
531            throw new IllegalArgumentException("Academic Plan Service lookup error", e);
532        } catch (PermissionDeniedException e) {
533            throw new IllegalArgumentException("Academic Plan Service lookup error", e);
534        }
535
536        wrapper.setVariableCredit(isCourseOfferingVariableCredit);
537        return wrapper;
538
539    }
540
541    /**
542     * This is the finalizeMethodToCall which builds the disclosure widgets.
543     * This is really a workaround until KULRICE-9003 gets addressed, allowing me to use #parentLine in the
544     * layoutManager.lineGroupPrototype.disclosure properties.
545     * @param disclosure The disclosure component that we are working in
546     * @param model The form backing object
547     */
548    public void determineDisclosureRendering(Disclosure disclosure, Object model) {
549        CourseOfferingDetailsWrapper courseOfferingDetailsWrapper = (CourseOfferingDetailsWrapper)disclosure.getContext().get(UifConstants.ContextVariableNames.LINE);
550        GroupBase parentGroup = (GroupBase)disclosure.getContext().get(UifConstants.ContextVariableNames.PARENT);
551        GroupBase grandparent = (GroupBase)parentGroup.getContext().get(UifConstants.ContextVariableNames.PARENT);
552        CourseTermDetailsWrapper courseTermDetailsWrapper = (CourseTermDetailsWrapper)grandparent.getContext().get(UifConstants.ContextVariableNames.LINE);
553
554        int size = courseTermDetailsWrapper.getCourseOfferingDetailsWrappers().size();
555
556        if (size <= 1)
557            disclosure.setRender(false);
558
559        // Set the id based off of the term id and course offering code
560        disclosure.setId(courseTermDetailsWrapper.getTermId() + "_" + courseOfferingDetailsWrapper.getCourseOfferingCode());
561    }
562
563    /**
564     * Validates the Reg groups by:
565     * List of selected AOs
566     * Status in the plan
567     *
568     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#getValidRegGroupIds(String, java.util.Map)
569     */
570    @Override
571    public List<String> getValidRegGroupIds(String courseOfferingId, Map<Object,Object> additionalRestrictions){
572        // Retrieve reg groups for the Course Offering
573        List<String> regGroupIds = new ArrayList<String>();
574        try {
575            SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants.KSAP_COURSE_SEARCH_OFFERED_REG_GROUP_IDS_BY_CO_ID_KEY);
576            request.addParam(CourseSearchConstants.SearchParameters.COURSE_OFFERING_ID, courseOfferingId);
577            List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
578                    KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
579            for( SearchResultRowInfo row : rows){
580                regGroupIds.add(
581                        KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns.REG_GROUP_ID));
582            }
583        } catch (InvalidParameterException e) {
584            throw new IllegalArgumentException("CO lookup error", e);
585        } catch (MissingParameterException e) {
586            throw new IllegalArgumentException("CO lookup error", e);
587        } catch (OperationFailedException e) {
588            throw new IllegalArgumentException("CO lookup error", e);
589        } catch (PermissionDeniedException e) {
590            throw new IllegalArgumentException("CO lookup error", e);
591        }
592
593        // Validate Reg Groups based on if they are already in plan
594        regGroupIds = getValidRegGroupsFilteredByPlan(regGroupIds);
595
596        // Validate Reg Groups based on selected AOs
597        List<String> selectedActivities = (List<String>) additionalRestrictions.get("selectedActivities");
598        regGroupIds = getValidRegGroupsFilteredBySelectedActivities(regGroupIds, selectedActivities);
599
600        //Validate Offered - Shouldn't be needed since only offered reg groups are added to the page.
601
602        return regGroupIds;
603    }
604
605    /**
606     * Validates the Reg groups by:
607     * Status in the plan
608     *
609     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#getValidRegGroupIdsToRemain(String, java.util.Map)
610     */
611    @Override
612    public List<String> getValidRegGroupIdsToRemain(String courseOfferingId, Map<Object,Object> additionalRestrictions){
613        ContextInfo contextInfo = KsapFrameworkServiceLocator.getContext().getContextInfo();
614
615        // Retrieve reg groups for the Course Offering
616        List<String> regGroupIds = new ArrayList<String>();
617        try {
618            SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants.KSAP_COURSE_SEARCH_OFFERED_REG_GROUP_IDS_BY_CO_ID_KEY);
619            request.addParam(CourseSearchConstants.SearchParameters.COURSE_OFFERING_ID, courseOfferingId);
620            List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
621                    contextInfo).getRows();
622            for( SearchResultRowInfo row : rows){
623                regGroupIds.add(
624                        KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns.REG_GROUP_ID));
625            }
626        } catch (InvalidParameterException e) {
627            throw new IllegalArgumentException("CO lookup error", e);
628        } catch (MissingParameterException e) {
629            throw new IllegalArgumentException("CO lookup error", e);
630        } catch (OperationFailedException e) {
631            throw new IllegalArgumentException("CO lookup error", e);
632        } catch (PermissionDeniedException e) {
633            throw new IllegalArgumentException("CO lookup error", e);
634        }
635
636        // Validate Reg Groups based on if they are already in plan
637        regGroupIds = getValidRegGroupsFilteredByPlan(regGroupIds);
638
639
640        return regGroupIds;
641    }
642
643    /**
644     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#createAddSectionEvent(String, String, String, String, java.util.List, javax.json.JsonObjectBuilder)
645     */
646    @Override
647    public JsonObjectBuilder createAddSectionEvent(String termId, String courseOfferingCode, String courseOfferingId, String formatOfferingId, List<ActivityOfferingDetailsWrapper> activities, JsonObjectBuilder eventList){
648        JsonObjectBuilder addEvent = Json.createObjectBuilder();
649        addEvent.add("courseOfferingId", courseOfferingId);
650        addEvent.add("termId", termId.replace(".", "-"));
651        addEvent.add("courseOfferingCode", courseOfferingCode);
652        addEvent.add("formatOfferingId", formatOfferingId);
653        addEvent.add("uid", UUID.randomUUID().toString());
654
655        // Create json array of activity to add and add it to event
656        String regGroupCode="";
657        JsonArrayBuilder activityEvents = Json.createArrayBuilder();
658        for(ActivityOfferingDetailsWrapper activity : activities){
659            JsonObjectBuilder activityEvent = Json.createObjectBuilder();
660            String instructor = "";
661            String days = "";
662            String time = "";
663            String location = "";
664            String classUrl = "";
665
666            // activities in the reg group will have the same reg group code.
667            regGroupCode=activity.getRegGroupCode();
668
669            // if activity value is null use empty string
670            if(activity.getInstructorName()!=null) instructor = activity.getInstructorName();
671            if(activity.getDays()!=null) days = activity.getDays();
672            if(activity.getTime()!=null) time = activity.getTime();
673            if(activity.getLocation()!=null) location = activity.getLocation();
674            if(activity.getClassUrl()!=null) classUrl = activity.getClassUrl();
675
676            // Add data to json for activity
677            activityEvent.add("activityOfferingId", activity.getActivityOfferingId());
678            activityEvent.add("activityFormatName", activity.getActivityFormatName());
679            activityEvent.add("activityOfferingCode", activity.getActivityOfferingCode());
680
681            activityEvent.add("instructor", instructor);
682            activityEvent.add("days",days);
683            activityEvent.add("time", time);
684            activityEvent.add("location", location);
685            activityEvent.add("currentEnrollment", activity.getCurrentEnrollment());
686            activityEvent.add("maxEnrollment", activity.getMaxEnrollment());
687            activityEvent.add("honors", activity.isHonors());
688            activityEvent.add("classUrl", classUrl);
689            JsonArrayBuilder jsonArrayBuilder = Json.createArrayBuilder();
690
691            activityEvent.add("activityOfferingRequisites", activity.isHasActivityOfferingRequisites());
692            activityEvents.add(activityEvent);
693        }
694        addEvent.add("activities", activityEvents);
695        addEvent.add("regGroupCode", regGroupCode);
696
697        eventList.add("COURSE_SECTION_ADDED", addEvent);
698        return eventList;
699    }
700
701    /**
702     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#createFilterValidRegGroupsEvent
703     */
704    @Override
705    public JsonObjectBuilder createFilterValidRegGroupsEvent(String termId, String courseOfferingCode,
706            String formatOfferingId, List<String> regGroups, JsonObjectBuilder eventList,
707            Map<Object, Object> additionalRestrictions){
708        JsonObjectBuilder filterEvent = Json.createObjectBuilder();
709        filterEvent.add("termId", termId.replace(".", "-"));
710        filterEvent.add("courseOfferingCode", courseOfferingCode);
711        filterEvent.add("formatOfferingId", formatOfferingId);
712
713        // Deconstruct reg groups into list of AO and FO ids
714        List<String> validFormatOfferings = new ArrayList<String>();
715        List<String> validActivities = new ArrayList<String>();
716
717        boolean singleRegGroupIdentified=false;
718        for(String id : regGroups){
719            List<String> activityIds = new ArrayList<>();
720            List<String> formatIds = new ArrayList<>();
721            try {
722                SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
723                        .KSAP_COURSE_SEARCH_AO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
724                request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
725                List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
726                        KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
727                boolean hasSelectedActivities=false;
728                for( SearchResultRowInfo row : rows){
729                    String activityId = KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
730                            .ACTIVITY_OFFERING_ID);
731                    activityIds.add(activityId);
732
733                    //Determine if any activities of a single reg group have been selected
734                    if (regGroups.size()==1 && additionalRestrictions !=null
735                       && additionalRestrictions.get("selectedActivities")!=null
736                       && ((List<String>) additionalRestrictions.get("selectedActivities")).contains(activityId))
737                        singleRegGroupIdentified=true;
738                }
739
740                request = new SearchRequestInfo(CourseSearchConstants
741                        .KSAP_COURSE_SEARCH_FO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
742                request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
743                rows = KsapFrameworkServiceLocator.getSearchService().search(request,
744                        KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
745                for( SearchResultRowInfo row : rows){
746                    formatIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
747                            .FORMAT_OFFERING_ID));
748                }
749            } catch (InvalidParameterException e) {
750                throw new IllegalArgumentException("Lui Service lookup error", e);
751            } catch (MissingParameterException e) {
752                throw new IllegalArgumentException("Lui Service lookup error", e);
753            } catch (OperationFailedException e) {
754                throw new IllegalArgumentException("Lui Service lookup error", e);
755            } catch (PermissionDeniedException e) {
756                throw new IllegalArgumentException("Lui Service lookup error", e);
757            }
758            if(activityIds != null && !activityIds.isEmpty()){
759                validActivities.addAll(activityIds);
760            }
761            if(formatIds != null && !formatIds.isEmpty()){
762                validFormatOfferings.addAll(formatIds);
763            }
764        }
765
766        //Send single regGroupId identified (i.e. selected) event
767        if(singleRegGroupIdentified){
768            try {
769                filterEvent.add("regGroupId",KSCollectionUtils.getRequiredZeroElement(regGroups));
770            } catch (OperationFailedException e) {
771                throw new IllegalArgumentException("Failure retrieving registration group", e);
772            }
773        }else{
774            filterEvent.add("regGroupId","");
775        }
776
777        // Create json array of valid activity ids and add it to event
778        JsonArrayBuilder activities = Json.createArrayBuilder();
779        for(String activity : validActivities){
780            activities.add(activity);
781
782        }
783        filterEvent.add("activities", activities);
784
785        // Create json array of valid format ids and add it to event
786        JsonArrayBuilder formats = Json.createArrayBuilder();
787        for(String format : validFormatOfferings){
788            formats.add(format);
789
790        }
791        filterEvent.add("formatOfferings", formats);
792
793        eventList.add("FILTER_COURSE_OFFERING", filterEvent);
794        return eventList;
795    }
796
797    /**
798     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#createFilterValidRegGroupsForRemovalEvent(String, String, String, java.util.List, javax.json.JsonObjectBuilder)
799     */
800    @Override
801    public JsonObjectBuilder createFilterValidRegGroupsForRemovalEvent(String termId, String courseOfferingCode, String formatOfferingId, List<String> regGroupIds, JsonObjectBuilder eventList) {
802        JsonObjectBuilder filterEvent = Json.createObjectBuilder();
803        filterEvent.add("termId", termId.replace(".", "-"));
804        filterEvent.add("courseOfferingCode", courseOfferingCode);
805        filterEvent.add("formatOfferingId", formatOfferingId);
806
807        // Deconstruct reg groups into list of AO and FO ids
808        List<String> validActivities = new ArrayList<String>();
809        for(String id : regGroupIds){
810            List<String> activityIds = new ArrayList<>();
811            try {
812                SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
813                        .KSAP_COURSE_SEARCH_AO_IDS_BY_OFFERED_REG_GROUP_ID_KEY);
814                request.addParam(CourseSearchConstants.SearchParameters.REG_GROUP_ID, id);
815                List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
816                        KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
817                for( SearchResultRowInfo row : rows){
818                    activityIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
819                            .ACTIVITY_OFFERING_ID));
820                }
821            } catch (InvalidParameterException e) {
822                throw new IllegalArgumentException("Lui Service lookup error", e);
823            } catch (MissingParameterException e) {
824                throw new IllegalArgumentException("Lui Service lookup error", e);
825            } catch (OperationFailedException e) {
826                throw new IllegalArgumentException("Lui Service lookup error", e);
827            } catch (PermissionDeniedException e) {
828                throw new IllegalArgumentException("Lui Service lookup error", e);
829            }
830            if(activityIds != null && !activityIds.isEmpty()){
831                validActivities.addAll(activityIds);
832            }
833        }
834
835        // Create json array of valid activity ids and add it to event
836        JsonArrayBuilder activities = Json.createArrayBuilder();
837        for(String activity : validActivities){
838            activities.add(activity);
839
840        }
841        filterEvent.add("activities", activities);
842
843        eventList.add("FILTER_COURSE_OFFERING_FOR_REMOVAL", filterEvent);
844        return eventList;
845    }
846
847    /**
848     * @see org.kuali.student.ap.coursesearch.service.CourseDetailsViewHelperService#setupActivityRequisitesDialog(String, org.kuali.student.ap.coursesearch.form.CourseSectionDetailsDialogForm)
849     */
850    @Override
851    public CourseSectionDetailsDialogForm setupActivityRequisitesDialog(String activityOfferingId, CourseSectionDetailsDialogForm form){
852        // Fill in addition information needed by the add dialog
853        ActivityOfferingInfo activity = null;
854        try {
855            activity = KsapFrameworkServiceLocator.getCourseOfferingService().getActivityOffering(activityOfferingId, KsapFrameworkServiceLocator.getContext().getContextInfo());
856        } catch (DoesNotExistException e) {
857            throw new IllegalArgumentException("CO Service lookup error", e);
858        } catch (InvalidParameterException e) {
859            throw new IllegalArgumentException("CO Service lookup error", e);
860        } catch (MissingParameterException e) {
861            throw new IllegalArgumentException("CO Service lookup error", e);
862        } catch (OperationFailedException e) {
863            throw new IllegalArgumentException("CO Service lookup error", e);
864        } catch (PermissionDeniedException e) {
865            throw new IllegalArgumentException("CO Service lookup error", e);
866        }
867        form.setCourseOfferingCode(activity.getCourseOfferingCode());
868        form.setCourseOfferingTitle(activity.getCourseOfferingTitle());
869
870        // Retrieve a map of requisites for the activity offerings
871        Map<String,List<String>> requisitesMap = CourseDetailsUtil.getActivityOfferingRequisitesMap(activity);
872
873        // Fill in the different types of requisites from the map
874        if(requisitesMap.containsKey(CourseDetailsUtil.PREREQUISITE_KEY)){
875            form.setPrerequisites(requisitesMap.get(CourseDetailsUtil.PREREQUISITE_KEY));
876        }else{
877            form.setPrerequisites(new ArrayList<String>());
878        }
879        if(requisitesMap.containsKey(CourseDetailsUtil.COREQUISITE_KEY)){
880            form.setCorequisites(requisitesMap.get(CourseDetailsUtil.COREQUISITE_KEY));
881        }else{
882            form.setCorequisites(new ArrayList<String>());
883        }
884        if(requisitesMap.containsKey(CourseDetailsUtil.ANTIREQUISITE_KEY)){
885            form.setAntirequisites(requisitesMap.get(CourseDetailsUtil.ANTIREQUISITE_KEY));
886        }else{
887            form.setAntirequisites(new ArrayList<String>());
888        }
889
890        return form;
891    }
892
893    /**
894     * Filters a list of registration groups based on a list of activity offering ids
895     *
896     * @param regGroupIds - List of registration ids to filter
897     * @param selectedActivities - List of activity ids to be found in valid reg groups
898     * @return A list of filtered registration groups
899     */
900    private List<String> getValidRegGroupsFilteredBySelectedActivities(
901            List<String> regGroupIds, List<String> selectedActivities){
902        // If no activities are sent skip filtering
903        if(selectedActivities != null && !selectedActivities.isEmpty()){
904            List<String> regGroupIdsFromSelectedAOs = new ArrayList<String>();
905            for(String activityId : selectedActivities){
906                try {
907                    SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
908                            .KSAP_COURSE_SEARCH_OFFERED_REG_GROUP_IDS_BY_AO_ID_KEY);
909                    request.addParam(CourseSearchConstants.SearchParameters.ACTIVITY_OFFERING_ID, activityId);
910                    List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
911                            KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
912                    List<String> tempIds = new ArrayList<>();
913                    for( SearchResultRowInfo row : rows){
914                        tempIds.add(KsapHelperUtil.getCellValue(row, CourseSearchConstants.SearchResultColumns
915                                .REG_GROUP_ID));
916                    }
917                    if(regGroupIdsFromSelectedAOs.isEmpty()){
918                        regGroupIdsFromSelectedAOs.addAll(tempIds);
919                    }else{
920                        regGroupIdsFromSelectedAOs= (List<String>)CollectionUtils.intersection(regGroupIdsFromSelectedAOs,tempIds);
921                    }
922                } catch (InvalidParameterException e) {
923                    throw new IllegalArgumentException("Lui Service lookup error", e);
924                } catch (MissingParameterException e) {
925                    throw new IllegalArgumentException("Lui Service lookup error", e);
926                } catch (OperationFailedException e) {
927                    throw new IllegalArgumentException("Lui Service lookup error", e);
928                } catch (PermissionDeniedException e) {
929                    throw new IllegalArgumentException("Lui Service lookup error", e);
930                }
931            }
932            List<String> validAOGroups = new ArrayList<String>();
933            for(String id : regGroupIds){
934                if(regGroupIdsFromSelectedAOs.contains(id)){
935                    validAOGroups.add(id);
936                }
937            }
938
939            regGroupIds = validAOGroups;
940        }
941        return regGroupIds;
942    }
943
944    /**
945     * Filter a list of registration groups based on if it is already in the default learning plan
946     *
947     * @param regGroupIds - The list of registration ids to filter
948     * @return A list of filtered reg groups not already in plan
949     */
950    private List<String> getValidRegGroupsFilteredByPlan(List<String> regGroupIds){
951        LearningPlan learningPlan = KsapFrameworkServiceLocator.getPlanHelper().getDefaultLearningPlan();
952        List<String> validGroupIds = new ArrayList<String>();
953        for(String id : regGroupIds){
954            //Check if there exist a plan item in the plan for the reg group
955            try {
956                List<PlanItemInfo> item = KsapFrameworkServiceLocator.getAcademicPlanService()
957                        .getPlanItemsInPlanByRefObjectIdByRefObjectType(learningPlan.getId(), id,
958                                PlanConstants.REG_GROUP_TYPE, KsapFrameworkServiceLocator.getContext().getContextInfo());
959                if(item ==null || item.isEmpty()){
960                    // If plan item does not exist reg group is valid
961                    validGroupIds.add(id);
962                }
963            } catch (InvalidParameterException e) {
964                throw new IllegalArgumentException("AP lookup error", e);
965            } catch (MissingParameterException e) {
966                throw new IllegalArgumentException("AP lookup error", e);
967            } catch (OperationFailedException e) {
968                throw new IllegalArgumentException("AP lookup error", e);
969            } catch (PermissionDeniedException e) {
970                throw new IllegalArgumentException("AP lookup error", e);
971            }
972        }
973        return validGroupIds;
974    }
975
976    /**
977     * Finds the information on the primary instructor from a list of instructors
978     *
979     * @param instructors - List of instructors participating in activity
980     * @return Information on the primary instructor from the list
981     */
982    private OfferingInstructorInfo findDisplayInstructor(List<OfferingInstructorInfo> instructors) {
983        OfferingInstructorInfo result = null;
984
985        // If list of instructors is empty return null
986        if (instructors != null && !instructors.isEmpty()) {
987
988            // Build the display name for the Instructor
989            Collection<OfferingInstructorInfo> highestInstEffortInstructors = new ArrayList<OfferingInstructorInfo>();
990            float highestInstEffortComparison = 0f;
991
992            // find instructors with highest participation from the list
993            for (OfferingInstructorInfo instructor : instructors) {
994
995                // Only instructors with participation are considered
996                if (instructor.getPercentageEffort() != null) {
997
998                    // If participation is higher than current list, reset with higher participation instructor
999                    if (instructor.getPercentageEffort() > highestInstEffortComparison) {
1000                        highestInstEffortInstructors.clear();
1001                        highestInstEffortComparison = instructor.getPercentageEffort();
1002                        highestInstEffortInstructors.add(instructor);
1003                    }
1004
1005                    // If participation is equal to current highest add instructor to current list
1006                    else if (instructor.getPercentageEffort() == highestInstEffortComparison) {
1007                        highestInstEffortInstructors.add(instructor);
1008                    }
1009                }
1010            }
1011
1012            // Select instructor
1013            if(highestInstEffortInstructors.isEmpty()){
1014                return result;
1015            }else if (highestInstEffortInstructors.size() == 1) {
1016                // If only one participate return first
1017                result = highestInstEffortInstructors.iterator().next();
1018            } else {
1019
1020                // If multiple instructors with highest participation get first alphabetically
1021                List<String> names = new ArrayList<String>(highestInstEffortInstructors.size());
1022                Map<String, OfferingInstructorInfo> nameMap = new HashMap<String, OfferingInstructorInfo>(highestInstEffortInstructors.size());
1023                for (OfferingInstructorInfo oiInfo : highestInstEffortInstructors) {
1024                    names.add(oiInfo.getPersonName());
1025                    nameMap.put(oiInfo.getPersonName(), oiInfo);
1026                }
1027                Collections.sort(names);
1028                result = nameMap.get(names.get(0));
1029            }
1030        }
1031
1032        return result;
1033    }
1034
1035    /**
1036     * Add room and schedule information to an existing Activity Offering wrapper
1037     *
1038     * @param aoWrapper - Activity to update
1039     * @param isTBA - If information schedule status is TBA
1040     * @param roomId - Id of the room location
1041     * @param timeSlot - The time slot
1042     */
1043    private void updateScheduleToAOWrapperForDisplay(ActivityOfferingDetailsWrapper aoWrapper, Boolean isTBA, String roomId, TimeSlotInfo timeSlot) {
1044        RoomInfo roomInfo = null;
1045        if (StringUtils.isNotBlank(roomId)) {
1046            try {
1047                roomInfo = KsapFrameworkServiceLocator.getRoomService().getRoom(roomId, ContextUtils.createDefaultContextInfo());
1048            } catch (DoesNotExistException e) {
1049                throw new IllegalArgumentException("Room Service lookup error", e);
1050            } catch (InvalidParameterException e) {
1051                throw new IllegalArgumentException("Room Service lookup error", e);
1052            } catch (MissingParameterException e) {
1053                throw new IllegalArgumentException("Room Service lookup error", e);
1054            } catch (OperationFailedException e) {
1055                throw new IllegalArgumentException("Room Service lookup error", e);
1056            } catch (PermissionDeniedException e) {
1057                throw new IllegalArgumentException("Room Service lookup error", e);
1058            }
1059        }
1060        updateScheduleToAOWrapperForDisplay(aoWrapper, isTBA, roomInfo, timeSlot);
1061    }
1062
1063    /**
1064     * Update an activity wrapper to include scheduling information
1065     *
1066     * @param aoWrapper - Activity wraper being updated
1067     * @param isTBA - If activity scheduling data is TBA
1068     * @param roomInfo - Room informationto load
1069     * @param timeSlot - Time slot information to load
1070     */
1071    private void updateScheduleToAOWrapperForDisplay(ActivityOfferingDetailsWrapper aoWrapper, Boolean isTBA,
1072                                                     RoomInfo roomInfo, TimeSlotInfo timeSlot) {
1073        // Update time slot information
1074        if (timeSlot != null) {
1075
1076            TimeOfDayInfo startTime = timeSlot.getStartTime();
1077            TimeOfDayInfo endTime = timeSlot.getEndTime();
1078            List<Integer> days = timeSlot.getWeekdays();
1079
1080            if ((startTime != null && startTime.getHour() != null) && (endTime != null && endTime.getHour() != null)) {
1081                aoWrapper.setTime(TimeOfDayHelper.makeFormattedTimeForAOSchedules(startTime) + " - " + TimeOfDayHelper.makeFormattedTimeForAOSchedules(endTime));
1082            }
1083
1084            if (days != null && days.size() > 0) {
1085                aoWrapper.setDays(getDays(days));
1086            }
1087        }
1088
1089        // Update room information
1090        if (roomInfo != null && StringUtils.isNotBlank(roomInfo.getBuildingId())) {
1091
1092            BuildingInfo buildingInfo = null;
1093            try {
1094                buildingInfo = KsapFrameworkServiceLocator.getRoomService().getBuilding(roomInfo.getBuildingId(), KsapFrameworkServiceLocator.getContext().getContextInfo());
1095            } catch (DoesNotExistException e) {
1096                throw new IllegalArgumentException("Room Service lookup error", e);
1097            } catch (InvalidParameterException e) {
1098                throw new IllegalArgumentException("Room Service lookup error", e);
1099            } catch (MissingParameterException e) {
1100                throw new IllegalArgumentException("Room Service lookup error", e);
1101            } catch (OperationFailedException e) {
1102                throw new IllegalArgumentException("Room Service lookup error", e);
1103            } catch (PermissionDeniedException e) {
1104                throw new IllegalArgumentException("Room Service lookup error", e);
1105            }
1106            aoWrapper.setLocation(buildingInfo.getBuildingCode() + " " + roomInfo.getRoomCode());
1107
1108        }
1109    }
1110
1111    /**
1112     * Finds the already planned registration group and creates the details for them
1113     *
1114     * @param termId - Id of the course offering being loaded
1115     * @param activities - List of activities for the course offering
1116     * @return A populated list of planned registration groups
1117     */
1118    private List<PlannedRegistrationGroupDetailsWrapper> getPlannedPlannedRegistrationGroups(String termId,
1119            List<ActivityOfferingDetailsWrapper> activities){
1120
1121        // Get registration group plan items
1122        String learningPlanId = KsapFrameworkServiceLocator.getPlanHelper().getDefaultLearningPlan().getId();
1123        List<PlanItem> regItems = new ArrayList<PlanItem>();
1124        List<RegistrationGroupInfo> regGroups = null;
1125        List<PlanItem> items = KsapFrameworkServiceLocator.getPlanHelper().getPlanItems(learningPlanId);
1126        for(PlanItem item : items){
1127            if(!item.getRefObjectType().equals(PlanConstants.REG_GROUP_TYPE)){
1128                continue;
1129            }
1130            if(!item.getPlanTermIds().contains(termId)){
1131                continue;
1132            }
1133            regItems.add(item);
1134        }
1135
1136
1137
1138        List<String> ids = new ArrayList<String>();
1139        for(PlanItem item : regItems){
1140            ids.add(item.getRefObjectId());
1141        }
1142
1143        // Get registration groups from plan items
1144        try {
1145            regGroups = KsapFrameworkServiceLocator.getCourseOfferingService().getRegistrationGroupsByIds(
1146                    ids,KsapFrameworkServiceLocator.getContext().getContextInfo());
1147        } catch (DoesNotExistException e) {
1148            throw new IllegalArgumentException("CO service lookup error", e);
1149        } catch (InvalidParameterException e) {
1150            throw new IllegalArgumentException("CO service lookup error", e);
1151        } catch (MissingParameterException e) {
1152            throw new IllegalArgumentException("CO service lookup error", e);
1153        } catch (OperationFailedException e) {
1154            throw new IllegalArgumentException("CO service lookup error", e);
1155        } catch (PermissionDeniedException e) {
1156            throw new IllegalArgumentException("CO service lookup error", e);
1157        }
1158
1159        // Load planned registration group details
1160        List<PlannedRegistrationGroupDetailsWrapper> plannedRegistrationGroupDetailsWrappers = new ArrayList<PlannedRegistrationGroupDetailsWrapper>();
1161        for(RegistrationGroupInfo regGroup : regGroups){
1162
1163            //ignore non-offered Reg Groups
1164            if (!LuiServiceConstants.REGISTRATION_GROUP_OFFERED_STATE_KEY.equals(regGroup.getStateKey())) continue;
1165
1166            PlannedRegistrationGroupDetailsWrapper plannedRegistrationGroup = new PlannedRegistrationGroupDetailsWrapper();
1167            plannedRegistrationGroup.setRegGroupCode(regGroup.getName());
1168            for(String id : regGroup.getActivityOfferingIds()){
1169                for(ActivityOfferingDetailsWrapper activityOfferingDetailsWrapper : activities){
1170                    if(activityOfferingDetailsWrapper.getActivityOfferingId().equals(id)){
1171                        // Set activity in plan status
1172                        activityOfferingDetailsWrapper.setInPlan(true);
1173                        plannedRegistrationGroup.addActivities(activityOfferingDetailsWrapper);
1174                        break;
1175                    }
1176                }
1177            }
1178            // If no activities are filled then it is a bad registration group and don't add it to the list
1179            if(plannedRegistrationGroup.getActivities() == null || plannedRegistrationGroup.getActivities().isEmpty()) continue;
1180
1181            Collections.sort(plannedRegistrationGroup.getActivities(),new Comparator<ActivityOfferingDetailsWrapper>(){
1182                @Override
1183                public int compare(ActivityOfferingDetailsWrapper a1, ActivityOfferingDetailsWrapper a2){
1184                    if(a1.getFormatIndex() == a2.getFormatIndex()) return 0;
1185                    if(a1.getFormatIndex() > a2.getFormatIndex()) return 1;
1186                    return -1;
1187                }
1188            });
1189
1190            plannedRegistrationGroupDetailsWrappers.add(plannedRegistrationGroup);
1191        }
1192
1193        return plannedRegistrationGroupDetailsWrappers;
1194    }
1195
1196    /**
1197     * Loads the activity data for a CO and then creates a map to group it by the activity type and format offerings
1198     * @param courseOfferingId - Id of the CO activities are being retrieved for
1199     * @param validActivityOfferings - List of valid AO ids based on the registration groups available
1200     * @param isCourseOfferingVariableCredit - Flag indicating if the course offering is a variable credit course
1201     * @return - The activity offerings grouped by there format id and then grouped related format type
1202     */
1203    private Map<String, Map<String, List<ActivityOfferingDetailsWrapper>>> getAOData(String courseOfferingId, List<String> validActivityOfferings, List<String> validActivityOfferingsToRemain, boolean isCourseOfferingVariableCredit) {
1204        Map<String, Map<String, List<ActivityOfferingDetailsWrapper>>> aoMapByFormatName = new HashMap<String, Map<String, List<ActivityOfferingDetailsWrapper>>>();
1205        List<ActivityOfferingInfo>  activityOfferings = new ArrayList<>();
1206
1207        // Retrieve and sort all activities for the CO
1208        try {
1209            List<ActivityOfferingInfo>  activityOfferingsTemp = KsapFrameworkServiceLocator
1210                    .getCourseOfferingService().getActivityOfferingsByCourseOffering(courseOfferingId, KsapFrameworkServiceLocator.getContext().getContextInfo());
1211
1212            for (ActivityOfferingInfo ao : activityOfferingsTemp) {
1213                SearchRequestInfo request = new SearchRequestInfo(CourseSearchConstants
1214                        .KSAP_COURSE_SEARCH_OFFERED_REG_GROUP_IDS_BY_AO_ID_KEY);
1215                request.addParam(CourseSearchConstants.SearchParameters.ACTIVITY_OFFERING_ID, ao.getId());
1216                List<SearchResultRowInfo> rows = KsapFrameworkServiceLocator.getSearchService().search(request,
1217                        KsapFrameworkServiceLocator.getContext().getContextInfo()).getRows();
1218                if (!rows.isEmpty()) {
1219                    activityOfferings.add(ao);
1220                }
1221            }
1222
1223            Collections.sort(activityOfferings, new ActivityOfferingInfoComparator());
1224
1225        } catch (DoesNotExistException e) {
1226            throw new IllegalArgumentException("AO lookup error", e);
1227        } catch (InvalidParameterException e) {
1228            throw new IllegalArgumentException("AO lookup error", e);
1229        } catch (MissingParameterException e) {
1230            throw new IllegalArgumentException("AO lookup error", e);
1231        } catch (OperationFailedException e) {
1232            throw new IllegalArgumentException("AO lookup error", e);
1233        } catch (PermissionDeniedException e) {
1234            throw new IllegalArgumentException("AO lookup error", e);
1235        }
1236
1237        Map<String, FormatOfferingInfo> formatOfferingInfoMap = new HashMap<String, FormatOfferingInfo>();
1238        for (ActivityOfferingInfo activityOffering : activityOfferings) {
1239            if (activityOffering.getStateKey().equals(LuiServiceConstants.LUI_AO_STATE_OFFERED_KEY)) {
1240                // Retrieve current group by the format id, if entry is missing create it
1241                Map<String, List<ActivityOfferingDetailsWrapper>> aosByFormat = aoMapByFormatName.get(activityOffering.getFormatOfferingId());
1242                if (aosByFormat == null) {
1243                    aosByFormat = new LinkedHashMap<String, List<ActivityOfferingDetailsWrapper>>();
1244                }
1245
1246                // Convert into wrapper used on page
1247                ActivityOfferingDetailsWrapper wrapper = convertAOInfoToWrapper(activityOffering, isCourseOfferingVariableCredit, formatOfferingInfoMap);
1248
1249                // Retrieve current group by the format type, if entry is missing create it
1250                String typeKey = activityOffering.getTypeKey();
1251                List<ActivityOfferingDetailsWrapper> aosByType = aosByFormat.get(typeKey);
1252                if (aosByType == null) {
1253                    aosByType = new ArrayList<ActivityOfferingDetailsWrapper>();
1254                }
1255
1256                // Set whether activity is considered  valid
1257                wrapper.setValidActivity(validActivityOfferings.contains(wrapper.getActivityOfferingId()));
1258                wrapper.setValidActivityToRemain(validActivityOfferingsToRemain.contains(wrapper.getActivityOfferingId()));
1259
1260                //Add entry into map
1261                aosByType.add(wrapper);
1262                aosByFormat.put(typeKey, aosByType);
1263
1264                String keys[] = aosByFormat.keySet().toArray(new String[aosByFormat.keySet().size()]);
1265                for(int i = 0; i<keys.length; i++){
1266                    if(typeKey.equals(keys[i])){
1267                        wrapper.setFormatIndex(i);
1268                    }
1269                }
1270
1271                aoMapByFormatName.put(activityOffering.getFormatOfferingId(), aosByFormat);
1272            }
1273        }
1274        return aoMapByFormatName;
1275    }
1276
1277
1278    /**
1279     * Converts a list of integer representations of a list of day into a string based
1280     * If translation is needed outside this class move into a common util
1281     *
1282     * @param intList - The list of day ints to translate
1283     * @return String value of the day list
1284     */
1285    private String getDays(List<Integer> intList) {
1286
1287        StringBuilder sb = new StringBuilder();
1288        if (intList == null) return sb.toString();
1289
1290        for (Integer d : intList) {
1291            sb.append(convertIntoDays(d));
1292        }
1293        return sb.toString();
1294    }
1295
1296    /**
1297     * Converts a integer representation of a day into a string based on the SchedulingService
1298     * If translation is needed outside this class move into a common util
1299     *
1300     * @param day - The day int to translate
1301     * @return String value of the day
1302     */
1303    private String convertIntoDays(int day) {
1304        String dayOfWeek;
1305        switch (day) {
1306            case 1:
1307                dayOfWeek = SchedulingServiceConstants.SUNDAY_TIMESLOT_DAY_CODE;
1308                break;
1309            case 2:
1310                dayOfWeek = SchedulingServiceConstants.MONDAY_TIMESLOT_DAY_CODE;
1311                break;
1312            case 3:
1313                dayOfWeek = SchedulingServiceConstants.TUESDAY_TIMESLOT_DAY_CODE;
1314                break;
1315            case 4:
1316                dayOfWeek = SchedulingServiceConstants.WEDNESDAY_TIMESLOT_DAY_CODE;
1317                break;
1318            case 5:
1319                dayOfWeek = SchedulingServiceConstants.THURSDAY_TIMESLOT_DAY_CODE;
1320                break;
1321            case 6:
1322                dayOfWeek = SchedulingServiceConstants.FRIDAY_TIMESLOT_DAY_CODE;
1323                break;
1324            case 7:
1325                dayOfWeek = SchedulingServiceConstants.SATURDAY_TIMESLOT_DAY_CODE;
1326                break;
1327            default:
1328                dayOfWeek = StringUtils.EMPTY;
1329        }
1330        return dayOfWeek;
1331    }
1332
1333    @Override
1334    /**
1335     * {@inheritDoc}
1336     */
1337    public boolean isVariableCreditCourse(CourseOffering courseOffering) {
1338
1339        CreditsFormatter.Range range = KsapFrameworkServiceLocator.getCourseHelper().getCreditsFormatter().getRange(courseOffering);
1340
1341        if(range.getMultiple()!=null && !range.getMultiple().isEmpty()) return true;
1342        return !range.getMax().equals(range.getMin());
1343    }
1344
1345}