Coverage Report - org.kuali.student.enrollment.class2.grading.service.impl.GradingServiceImpl
 
Classes in this File Line Coverage Branch Coverage Complexity
GradingServiceImpl
0%
0/270
0%
0/90
2.465
 
 1   
 package org.kuali.student.enrollment.class2.grading.service.impl;
 2   
 
 3   
 import org.apache.commons.lang.StringUtils;
 4   
 import org.kuali.rice.krad.util.GlobalVariables;
 5   
 import org.kuali.student.common.util.UUIDHelper;
 6   
 import org.kuali.student.enrollment.class2.grading.assembler.GradeValuesGroupAssembler;
 7   
 import org.kuali.student.enrollment.class2.grading.service.assembler.GradeRosterAssembler;
 8   
 import org.kuali.student.enrollment.class2.grading.service.assembler.GradeRosterEntryAssembler;
 9   
 import org.kuali.student.enrollment.courseoffering.dto.CourseOfferingInfo;
 10   
 import org.kuali.student.enrollment.courseoffering.service.CourseOfferingService;
 11   
 import org.kuali.student.enrollment.courseregistration.service.CourseRegistrationService;
 12   
 import org.kuali.student.enrollment.grading.dto.GradeRosterEntryInfo;
 13   
 import org.kuali.student.enrollment.grading.dto.GradeRosterInfo;
 14   
 import org.kuali.student.enrollment.grading.dto.GradeValuesGroupInfo;
 15   
 import org.kuali.student.enrollment.grading.service.GradingService;
 16   
 import org.kuali.student.enrollment.lpr.dto.LprRosterEntryInfo;
 17   
 import org.kuali.student.enrollment.lpr.dto.LprRosterInfo;
 18   
 import org.kuali.student.enrollment.lpr.dto.LuiPersonRelationInfo;
 19   
 import org.kuali.student.enrollment.lpr.service.LuiPersonRelationService;
 20   
 import org.kuali.student.enrollment.lrr.dto.LearningResultRecordInfo;
 21   
 import org.kuali.student.enrollment.lrr.service.LearningResultRecordService;
 22   
 import org.kuali.student.enrollment.lui.service.LuiService;
 23   
 import org.kuali.student.r2.common.assembler.AssemblyException;
 24   
 import org.kuali.student.r2.common.dto.*;
 25   
 import org.kuali.student.r2.common.exceptions.*;
 26   
 import org.kuali.student.r2.common.util.constants.LrcServiceConstants;
 27   
 import org.kuali.student.r2.common.util.constants.LrrServiceConstants;
 28   
 import org.kuali.student.r2.common.util.constants.LuiPersonRelationServiceConstants;
 29   
 import org.kuali.student.r2.common.util.constants.LuiServiceConstants;
 30   
 import org.kuali.student.r2.lum.lrc.dto.ResultValueInfo;
 31   
 import org.kuali.student.r2.lum.lrc.dto.ResultValuesGroupInfo;
 32   
 import org.kuali.student.r2.lum.lrc.service.LRCService;
 33   
 
 34   
 import javax.jws.WebParam;
 35   
 import java.util.*;
 36   
 import org.kuali.student.r2.core.type.dto.TypeInfo;
 37   
 
 38  0 
 public class GradingServiceImpl implements GradingService {
 39   
     private LuiPersonRelationService lprService;
 40   
     private CourseOfferingService courseOfferingService;
 41   
     private LRCService lrcService;
 42   
     private LearningResultRecordService lrrService;
 43   
     private LuiService luiService;
 44   
     private GradeRosterAssembler gradeRosterAssembler;
 45   
     private GradeRosterEntryAssembler gradeRosterEntryAssembler;
 46   
     private GradeValuesGroupAssembler gradeValuesGroupAssembler;
 47   
     private CourseRegistrationService courseRegistrationService;
 48   
 
 49   
     /**
 50   
      * This method returns the TypeInfo for a given grade roster type key.
 51   
      *
 52   
      * @param gradeRosterTypeKey
 53   
      *            Key of the type
 54   
      * @param context
 55   
      *            Context information containing the principalId and locale
 56   
      *            information about the caller of service operation
 57   
      * @return Information about the Type
 58   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 59   
      *             gradeRosterTypeKey not found
 60   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 61   
      *             invalid gradeRosterTypeKey
 62   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 63   
      *             missing gradeRosterTypeKey
 64   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 65   
      *             unable to complete request
 66   
      */
 67   
     @Override
 68   
     public TypeInfo getGradeRosterType(@WebParam(name = "gradeRosterTypeKey") String gradeRosterTypeKey,
 69   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 70   
             MissingParameterException, OperationFailedException {
 71  0 
         return null; // TODO implement method.
 72   
     }
 73   
 
 74   
     /**
 75   
      * Retrieve information about a grade roster
 76   
      *
 77   
      * @param gradeRosterId
 78   
      * @param context
 79   
      *            Context information containing the principalId and locale
 80   
      *            information about the caller of service operation
 81   
      * @return
 82   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 83   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 84   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 85   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 86   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 87   
      *             authorization failure
 88   
      */
 89   
     @Override
 90   
     public GradeRosterInfo getGradeRoster(@WebParam(name = "gradeRosterId") String gradeRosterId,
 91   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 92   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 93  0 
         return null; // TODO implement method.
 94   
     }
 95   
 
 96   
     /**
 97   
      * Retrieve information about grade rosters by grader and term
 98   
      *
 99   
      * @param graderId
 100   
      * @param termId
 101   
      * @param context
 102   
      *            Context information containing the principalId and locale
 103   
      *            information about the caller of service operation
 104   
      * @return
 105   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 106   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 107   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 108   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 109   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 110   
      *             authorization failure
 111   
      */
 112   
     @Override
 113   
     public List<GradeRosterInfo> getGradeRostersByGraderAndTerm(@WebParam(name = "graderId") String graderId,
 114   
             @WebParam(name = "termId") String termId, @WebParam(name = "context") ContextInfo context)
 115   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 116   
             OperationFailedException, PermissionDeniedException {
 117  0 
         return null; // TODO implement method.
 118   
     }
 119   
 
 120   
     /**
 121   
      * Retrieves rosters of final grades for a course offering
 122   
      *
 123   
      * @param courseOfferingId
 124   
      * @param context
 125   
      *            Context information containing the principalId and locale
 126   
      *            information about the caller of service operation
 127   
      * @return
 128   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 129   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 130   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 131   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 132   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 133   
      *             authorization failure
 134   
      */
 135   
     @Override
 136   
     public List<GradeRosterInfo> getFinalGradeRostersForCourseOffering(
 137   
             @WebParam(name = "courseOfferingId") String courseOfferingId,
 138   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 139   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 140  0 
         List<GradeRosterInfo> gradeRosterInfos = new ArrayList<GradeRosterInfo>();
 141   
 
 142  0 
         List<LprRosterInfo> lprRosters = lprService.getLprRostersByLuiAndType(courseOfferingId, LuiPersonRelationServiceConstants.LPRROSTER_COURSE_FINAL_GRADEROSTER_TYPE_KEY, context);
 143  0 
         for (LprRosterInfo lprRoster : lprRosters) {
 144  0 
             GradeRosterInfo gradeRosterInfo = assembleGradeRoster(lprRoster, context);
 145  0 
             gradeRosterInfos.add(gradeRosterInfo);
 146  0 
         }
 147   
 
 148  0 
         return gradeRosterInfos;
 149   
     }
 150   
 
 151   
     /**
 152   
      * Retrieves rosters of final grade by actvity offerings
 153   
      *
 154   
      * @param activityOfferingId
 155   
      * @param context
 156   
      *            Context information containing the principalId and locale
 157   
      *            information about the caller of service operation
 158   
      * @return
 159   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 160   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 161   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 162   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 163   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 164   
      *             authorization failure
 165   
      */
 166   
     @Override
 167   
     public List<GradeRosterInfo> getFinalGradeRostersForActivityOffering(
 168   
             @WebParam(name = "activityOfferingId") String activityOfferingId,
 169   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 170   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 171  0 
         return null; // TODO implement method.
 172   
     }
 173   
 
 174   
     /**
 175   
      * Retrieves all rosters for an activity offering
 176   
      *
 177   
      * @param activityOfferingId
 178   
      * @param context
 179   
      *            Context information containing the principalId and locale
 180   
      *            information about the caller of service operation
 181   
      * @return
 182   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 183   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 184   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 185   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 186   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 187   
      *             authorization failure
 188   
      */
 189   
     @Override
 190   
     public List<GradeRosterInfo> getGradeRostersForActivityOffering(
 191   
             @WebParam(name = "activityOfferingId") String activityOfferingId,
 192   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 193   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 194  0 
         return null; // TODO implement method.
 195   
     }
 196   
 
 197   
     /**
 198   
      * Build an interim roster of given type. Roster type should be used to
 199   
      * figure out which students from the activity offerings will be in the
 200   
      * roster
 201   
      *
 202   
      * @param activityOfferingIds
 203   
      * @param rosterTypeKey
 204   
      * @param context
 205   
      *            Context information containing the principalId and locale
 206   
      *            information about the caller of service operation
 207   
      * @return
 208   
      * @throws org.kuali.student.r2.common.exceptions.AlreadyExistsException
 209   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 210   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 211   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 212   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 213   
      *             authorization failure
 214   
      */
 215   
     @Override
 216   
     public GradeRosterInfo buildInterimGradeRosterByType(
 217   
             @WebParam(name = "courseOfferingId") String courseOfferingId,
 218   
             @WebParam(name = "activityOfferingIds") List<String> activityOfferingIds,
 219   
             @WebParam(name = "rosterTypeKey") String rosterTypeKey, @WebParam(name = "context") ContextInfo context)
 220   
             throws AlreadyExistsException, InvalidParameterException, MissingParameterException,
 221   
             OperationFailedException, PermissionDeniedException {
 222  0 
         return null; // TODO implement method.
 223   
     }
 224   
 
 225   
     /**
 226   
      * Update interim grade roster information
 227   
      *
 228   
      * @param gradeRoster
 229   
      * @param context
 230   
      *            Context information containing the principalId and locale
 231   
      *            information about the caller of service operation
 232   
      * @return
 233   
      * @throws org.kuali.student.r2.common.exceptions.DataValidationErrorException
 234   
      *             One or more values invalid for this operation
 235   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 236   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 237   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 238   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 239   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 240   
      *             authorization failure
 241   
      * @throws org.kuali.student.r2.common.exceptions.VersionMismatchException
 242   
      */
 243   
     @Override
 244   
     public GradeRosterInfo updateInterimGradeRoster(@WebParam(name = "gradeRoster") GradeRosterInfo gradeRoster,
 245   
             @WebParam(name = "context") ContextInfo context) throws DataValidationErrorException,
 246   
             DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
 247   
             PermissionDeniedException, VersionMismatchException {
 248  0 
         return null; // TODO implement method.
 249   
     }
 250   
 
 251   
     /**
 252   
      * Delete an interim grade roster
 253   
      *
 254   
      * @param gradeRosterId
 255   
      * @param context
 256   
      *            Context information containing the principalId and locale
 257   
      *            information about the caller of service operation
 258   
      * @return
 259   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 260   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 261   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 262   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 263   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 264   
      *             authorization failure
 265   
      */
 266   
     @Override
 267   
     public StatusInfo deleteInterimGradeRoster(@WebParam(name = "gradeRosterId") String gradeRosterId,
 268   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 269   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 270  0 
         return null; // TODO implement method.
 271   
     }
 272   
 
 273   
     /**
 274   
      * Update state of final grade roster. Only state can be changed for the
 275   
      * final grade roster. Final grade submission is tracked through state
 276   
      * change on the roster.
 277   
      *
 278   
      * @param gradeRosterId
 279   
      * @param stateKey
 280   
      * @param context
 281   
      *            Context information containing the principalId and locale
 282   
      *            information about the caller of service operation
 283   
      * @return
 284   
      * @throws org.kuali.student.r2.common.exceptions.DataValidationErrorException
 285   
      *             One or more values invalid for this operation
 286   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 287   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 288   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 289   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 290   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 291   
      *             authorization failure
 292   
      * @throws org.kuali.student.r2.common.exceptions.VersionMismatchException
 293   
      */
 294   
     @Override
 295   
     public GradeRosterInfo updateFinalGradeRosterState(@WebParam(name = "gradeRosterId") String gradeRosterId,
 296   
             @WebParam(name = "newStateKey") String stateKey, @WebParam(name = "context") ContextInfo context)
 297   
             throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,
 298   
             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {
 299   
 
 300  0 
         LprRosterInfo lprRosterInfo = lprService.getLprRoster(gradeRosterId,context);
 301  0 
         lprRosterInfo.setStateKey(stateKey);
 302   
 
 303   
         GradeRosterInfo returnRoster;
 304   
         try {
 305  0 
             LprRosterInfo newRoster = lprService.updateLprRoster(gradeRosterId,lprRosterInfo,context);
 306  0 
             returnRoster = assembleGradeRoster(newRoster,context);
 307  0 
         } catch (ReadOnlyException e) {
 308  0 
             throw new RuntimeException(e);
 309  0 
         }
 310   
 
 311   
         //Update LRR State
 312  0 
         List<LprRosterEntryInfo> rosterEntryInfoList = lprService.getLprRosterEntriesForRoster(lprRosterInfo.getId(),context);
 313  0 
         List<String> lprIds = new ArrayList();
 314  0 
         for (LprRosterEntryInfo entryInfo : rosterEntryInfoList) {
 315  0 
             lprIds.add(entryInfo.getLprId());
 316   
         }
 317   
 
 318  0 
         List<LearningResultRecordInfo> learningResultRecordInfoList = lrrService.getLearningResultRecordsForLprIds(lprIds,context);
 319  0 
         for (LearningResultRecordInfo learningResultRecordInfo : learningResultRecordInfoList) {
 320   
             //process only saved state entries (Skipping deleted state)
 321  0 
             if (StringUtils.equals(learningResultRecordInfo.getStateKey(),LrrServiceConstants.RESULT_RECORD_SAVED_STATE_KEY)){
 322  0 
                 learningResultRecordInfo.setStateKey(LrrServiceConstants.RESULT_RECORD_SUBMITTED_STATE_KEY);
 323  0 
                 lrrService.updateLearningResultRecord(learningResultRecordInfo.getId(),learningResultRecordInfo,context);
 324   
             }
 325   
         }
 326   
 
 327  0 
         return returnRoster;
 328   
     }
 329   
 
 330   
     /**
 331   
      * Validate a grade roster information
 332   
      *
 333   
      * @param gradeRoster
 334   
      * @param context
 335   
      *            Context information containing the principalId and locale
 336   
      *            information about the caller of service operation
 337   
      * @return
 338   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 339   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 340   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 341   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 342   
      */
 343   
     @Override
 344   
     public List<ValidationResultInfo> validateGradeRoster(@WebParam(name = "gradeRoster") GradeRosterInfo gradeRoster,
 345   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 346   
             MissingParameterException, OperationFailedException {
 347  0 
         return null; // TODO implement method.
 348   
     }
 349   
 
 350   
     /**
 351   
      * Retrieve information about a grade roster entry
 352   
      *
 353   
      * @param gradeRosterEntryId
 354   
      * @param context
 355   
      *            Context information containing the principalId and locale
 356   
      *            information about the caller of service operation
 357   
      * @return
 358   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 359   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 360   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 361   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 362   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 363   
      *             authorization failure
 364   
      */
 365   
     @Override
 366   
     public GradeRosterEntryInfo getGradeRosterEntry(@WebParam(name = "gradeRosterEntryId") String gradeRosterEntryId,
 367   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 368   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 369  0 
         return null; // TODO implement method.
 370   
     }
 371   
 
 372   
     /**
 373   
      * Retrieve a list of grade roster entries based on their Ids. The method
 374   
      * should fail if there is an error in retrieving any id from the list.
 375   
      *
 376   
      * @param gradeRosterEntryIds
 377   
      * @param context
 378   
      *            Context information containing the principalId and locale
 379   
      *            information about the caller of service operation
 380   
      * @return
 381   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 382   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 383   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 384   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 385   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 386   
      *             authorization failure
 387   
      */
 388   
     @Override
 389   
     public List<GradeRosterEntryInfo> getGradeRosterEntriesByIds(
 390   
             @WebParam(name = "gradeRosterEntryIds") List<String> gradeRosterEntryIds,
 391   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 392   
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 393   
 
 394   
 
 395  0 
         List<LprRosterEntryInfo> entries = lprService.getLprRosterEntriesByIds(gradeRosterEntryIds, context);
 396  0 
         return assembleGradeRosterEntries(entries, context);
 397   
     }
 398   
 
 399   
     /**
 400   
      * Retrieve grade roster entries by roster
 401   
      *
 402   
      * @param gradeRosterId
 403   
      * @param context
 404   
      *            Context information containing the principalId and locale
 405   
      *            information about the caller of service operation
 406   
      * @return
 407   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 408   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 409   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 410   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 411   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 412   
      *             authorization failure
 413   
      */
 414   
     @Override
 415   
     public List<GradeRosterEntryInfo> getGradeRosterEntriesByRosterId(
 416   
             @WebParam(name = "gradeRosterId") String gradeRosterId, @WebParam(name = "context") ContextInfo context)
 417   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 418   
             OperationFailedException, PermissionDeniedException {
 419  0 
         List<LprRosterEntryInfo> entries = lprService.getLprRosterEntriesForRoster(gradeRosterId, context);
 420  0 
         return assembleGradeRosterEntries(entries, context);
 421   
     }
 422   
 
 423   
     /**
 424   
      * This method ...
 425   
      *
 426   
      * @param studentId
 427   
      * @param courseOfferingId
 428   
      * @param context
 429   
      *            Context information containing the principalId and locale
 430   
      *            information about the caller of service operation
 431   
      * @return
 432   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 433   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 434   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 435   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 436   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 437   
      *             authorization failure
 438   
      */
 439   
     @Override
 440   
     public GradeRosterEntryInfo getFinalGradeForStudentInCourseOffering(@WebParam(name = "studentId") String studentId,
 441   
             @WebParam(name = "courseOfferingId") String courseOfferingId,
 442   
             @WebParam(name = "context") ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 443   
             MissingParameterException, OperationFailedException, PermissionDeniedException, DisabledIdentifierException {
 444   
 
 445   
 
 446  0 
         List<LprRosterInfo> lprRosters = lprService.getLprRostersByLuiAndType(courseOfferingId, LuiPersonRelationServiceConstants.LPRROSTER_COURSE_FINAL_GRADEROSTER_TYPE_KEY, context);
 447  0 
         Map<String, LprRosterEntryInfo> lprIdToRosterEntryMap = new HashMap<String, LprRosterEntryInfo>();
 448  0 
         for (LprRosterInfo lprRoster : lprRosters) {
 449  0 
             String rosterId = lprRoster.getId();
 450  0 
             List<LprRosterEntryInfo> rosterEntries = lprService.getLprRosterEntriesForRoster(rosterId, context);
 451  0 
             for (LprRosterEntryInfo rosterEntry : rosterEntries) {
 452  0 
                 String lprId = rosterEntry.getLprId();
 453  0 
                 lprIdToRosterEntryMap.put(lprId, rosterEntry);
 454  0 
             }
 455  0 
         }
 456   
 
 457  0 
         List<LuiPersonRelationInfo> lprs = lprService.getLprsByPersonAndLui(studentId, courseOfferingId, context);
 458  0 
         LuiPersonRelationInfo lpr = lprs.get(0); // TODO throw exception if null?
 459  0 
         LprRosterEntryInfo entry = lprIdToRosterEntryMap.get(lpr.getId());
 460   
 
 461  0 
         return assembleGradeRosterEntry(entry, context);
 462   
     }
 463   
 
 464   
     /**
 465   
      * This method ...
 466   
      *
 467   
      * @param gradeRosterEntry
 468   
      * @param gradeRosterId
 469   
      * @param context
 470   
      *            Context information containing the principalId and locale
 471   
      *            information about the caller of service operation
 472   
      * @return
 473   
      * @throws org.kuali.student.r2.common.exceptions.AlreadyExistsException
 474   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 475   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 476   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 477   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 478   
      *             authorization failure
 479   
      */
 480   
     @Override
 481   
     public GradeRosterEntryInfo addEntrytoInterimRoster(
 482   
             @WebParam(name = "gradeRosterEntry") GradeRosterEntryInfo gradeRosterEntry,
 483   
             @WebParam(name = "gradeRosterId") String gradeRosterId, @WebParam(name = "context") ContextInfo context)
 484   
             throws AlreadyExistsException, InvalidParameterException, MissingParameterException,
 485   
             OperationFailedException, PermissionDeniedException {
 486  0 
         return null; // TODO implement method.
 487   
     }
 488   
 
 489   
     /**
 490   
      * This method ...
 491   
      *
 492   
      * @param gradeRosterEntryId
 493   
      * @param gradeRosterId
 494   
      * @param context
 495   
      *            Context information containing the principalId and locale
 496   
      *            information about the caller of service operation
 497   
      * @return
 498   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 499   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 500   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 501   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 502   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 503   
      *             authorization failure
 504   
      */
 505   
     @Override
 506   
     public StatusInfo removeEntryFromInterimRoster(@WebParam(name = "gradeRosterEntryId") String gradeRosterEntryId,
 507   
             @WebParam(name = "gradeRosterId") String gradeRosterId, @WebParam(name = "context") ContextInfo context)
 508   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 509   
             OperationFailedException, PermissionDeniedException {
 510  0 
         return null; // TODO implement method.
 511   
     }
 512   
 
 513   
     /**
 514   
      * This method ...
 515   
      *
 516   
      * @param gradeRosterEntryId
 517   
      * @param assignedGradeKey
 518   
      * @param context
 519   
      *            Context information containing the principalId and locale
 520   
      *            information about the caller of service operation
 521   
      * @return
 522   
      * @throws org.kuali.student.r2.common.exceptions.DataValidationErrorException
 523   
      *             One or more values invalid for this operation
 524   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 525   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 526   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 527   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 528   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 529   
      *             authorization failure
 530   
      * @throws org.kuali.student.r2.common.exceptions.VersionMismatchException
 531   
      */
 532   
     @Override
 533   
     public boolean updateGrade(@WebParam(name = "gradeRosterEntryId") String gradeRosterEntryId,
 534   
             @WebParam(name = "assignedGrade") String assignedGradeKey, @WebParam(name = "context") ContextInfo context)
 535   
             throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,
 536   
             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {
 537   
 
 538  0 
         List<String> lprRosterEntryIds = new ArrayList();
 539  0 
         lprRosterEntryIds.add(gradeRosterEntryId);
 540   
 
 541  0 
         List<LprRosterEntryInfo> entryInfoList = lprService.getLprRosterEntriesByIds(lprRosterEntryIds,context);
 542  0 
         if (entryInfoList.isEmpty()){
 543  0 
             throw new DoesNotExistException("Lpr Roster Entry not exists for the id " + gradeRosterEntryId);
 544   
         }
 545   
 
 546  0 
         LprRosterEntryInfo entryInfo = entryInfoList.get(0);
 547  0 
         List<String> lprIds = new ArrayList();
 548  0 
         lprIds.add(entryInfo.getLprId());
 549   
 
 550  0 
         List<LearningResultRecordInfo> learningResultRecordInfoList = lrrService.getLearningResultRecordsForLprIds(lprIds,context);
 551   
 
 552   
         //If an entry not exists for a student, create one
 553  0 
         if ((learningResultRecordInfoList == null || learningResultRecordInfoList.isEmpty()) && StringUtils.isNotBlank(assignedGradeKey)){
 554  0 
             LearningResultRecordInfo lrrInfo = constructLearningResultRecordInfo(entryInfo, assignedGradeKey);
 555   
             try{
 556  0 
                 lrrService.createLearningResultRecord(lrrInfo,context);
 557  0 
                 return true;
 558  0 
             }catch(AlreadyExistsException e){
 559  0 
                 throw new OperationFailedException("Someone updated the grade. Please refresh to get the latest",e);
 560   
             }
 561   
         }
 562   
 
 563  0 
         for (LearningResultRecordInfo lrrInfo : learningResultRecordInfoList){
 564  0 
             if (StringUtils.equals(LrrServiceConstants.RESULT_RECORD_FINAL_GRADE_ASSIGNED_TYPE_KEY, lrrInfo.getTypeKey())){
 565  0 
                 if (!StringUtils.equals(LrrServiceConstants.RESULT_RECORD_DELETED_STATE_KEY,lrrInfo.getStateKey())){
 566  0 
                      if (StringUtils.isBlank(assignedGradeKey)){
 567  0 
                         StatusInfo status = lrrService.deleteLearningResultRecord(lrrInfo.getId(),context);
 568  0 
                         return status.getIsSuccess();
 569   
                     }else{
 570  0 
                         lrrInfo.setStateKey(LrrServiceConstants.RESULT_RECORD_SAVED_STATE_KEY);//If cancelled before
 571  0 
                         lrrInfo.setResultValueKey(assignedGradeKey);
 572  0 
                         lrrService.updateLearningResultRecord(lrrInfo.getId(),lrrInfo,context);
 573  0 
                         return true;
 574   
                     }
 575   
                 }
 576   
             }
 577   
         }
 578   
 
 579   
         //Create a new LRR as there are no active LRRs found
 580  0 
         if (StringUtils.isNotBlank(assignedGradeKey)){
 581  0 
             LearningResultRecordInfo newLrr = constructLearningResultRecordInfo(entryInfo, assignedGradeKey);
 582   
             try{
 583  0 
                 lrrService.createLearningResultRecord(newLrr,context);
 584  0 
                 return true;
 585  0 
             }catch(AlreadyExistsException e){
 586  0 
                 throw new OperationFailedException("Someone updated the grade. Please refresh to get the latest",e);
 587   
             }
 588   
         }
 589   
 
 590  0 
         return false;
 591   
     }
 592   
 
 593   
     private LearningResultRecordInfo constructLearningResultRecordInfo(LprRosterEntryInfo entryInfo, String assignedGradeKey){
 594  0 
         LearningResultRecordInfo lrrInfo = new LearningResultRecordInfo();
 595  0 
         lrrInfo.setId(UUIDHelper.genStringUUID());
 596  0 
         lrrInfo.setLprId(entryInfo.getLprId());
 597  0 
         lrrInfo.setName("LRR for " + entryInfo.getLprId());
 598  0 
         lrrInfo.setStateKey(LrrServiceConstants.RESULT_RECORD_SAVED_STATE_KEY);
 599  0 
         lrrInfo.setTypeKey(LrrServiceConstants.RESULT_RECORD_FINAL_GRADE_ASSIGNED_TYPE_KEY);
 600   
 
 601   
         //FIXME: Hardcoded for core slice
 602  0 
         List<String> resultSource = new ArrayList();
 603  0 
         resultSource.add("ResultSource-Sample1");
 604  0 
         lrrInfo.setResultSourceIds(resultSource);
 605   
 
 606  0 
         lrrInfo.setResultValueKey(assignedGradeKey);
 607  0 
         MetaInfo meta = new MetaInfo();
 608  0 
         meta.setCreateId(GlobalVariables.getUserSession().getPrincipalId());
 609  0 
         meta.setCreateTime(new Date());
 610  0 
         lrrInfo.setMeta(meta);
 611   
 
 612  0 
         return lrrInfo;
 613   
     }
 614   
 
 615   
     /**
 616   
      * This method ...
 617   
      *
 618   
      * @param gradeRosterEntryId
 619   
      * @param assignedGradeKey
 620   
      * @param context
 621   
      *            Context information containing the principalId and locale
 622   
      *            information about the caller of service operation
 623   
      * @return
 624   
      * @throws org.kuali.student.r2.common.exceptions.DataValidationErrorException
 625   
      *             One or more values invalid for this operation
 626   
      * @throws org.kuali.student.r2.common.exceptions.DoesNotExistException
 627   
      * @throws org.kuali.student.r2.common.exceptions.InvalidParameterException
 628   
      * @throws org.kuali.student.r2.common.exceptions.MissingParameterException
 629   
      * @throws org.kuali.student.r2.common.exceptions.OperationFailedException
 630   
      * @throws org.kuali.student.r2.common.exceptions.PermissionDeniedException
 631   
      *             authorization failure
 632   
      * @throws org.kuali.student.r2.common.exceptions.VersionMismatchException
 633   
      */
 634   
     @Override
 635   
     public boolean updateCredit(@WebParam(name = "gradeRosterEntryId") String gradeRosterEntryId,
 636   
             @WebParam(name = "creditsEarned") String assignedGradeKey, @WebParam(name = "context") ContextInfo context)
 637   
             throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,
 638   
             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {
 639  0 
         return false; // TODO implement method.
 640   
     }
 641   
 
 642   
     @Override
 643   
     public List<GradeValuesGroupInfo> getGradeGroupsByKeyList(List<String> gradeGroupKeyList, ContextInfo context)
 644   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 645   
             OperationFailedException, PermissionDeniedException {
 646   
 
 647  0 
         List<ResultValuesGroupInfo> resultValuesGroupInfos = lrcService.getResultValuesGroupsByIds(gradeGroupKeyList, context);
 648  0 
         List<GradeValuesGroupInfo> gradeValuesGroupInfos = new ArrayList<GradeValuesGroupInfo>();
 649   
 
 650  0 
         for(ResultValuesGroupInfo resultValuesGroupInfo : resultValuesGroupInfos){
 651  0 
             List<ResultValueInfo> resultValueInfos = lrcService.getResultValuesByIds(resultValuesGroupInfo.getResultValueKeys(),context);
 652   
             try {
 653  0 
                 gradeValuesGroupInfos.add(gradeValuesGroupAssembler.assemble(resultValuesGroupInfo,resultValueInfos,context));
 654  0 
             } catch (AssemblyException e) {
 655  0 
                 throw new OperationFailedException("AssemblyException : " + e.getMessage());
 656  0 
             }
 657  0 
         }
 658   
 
 659  0 
         return gradeValuesGroupInfos;
 660   
     }
 661   
 
 662   
     @Override
 663   
     public boolean updateNumberGrade(String gradeRosterEntryId, String numberGradeValue, ContextInfo context)
 664   
             throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,
 665   
             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {
 666   
         // TODO sambit - THIS METHOD NEEDS JAVADOCS
 667  0 
         return false;
 668   
     }
 669   
 
 670   
     private GradeRosterInfo assembleGradeRoster(LprRosterInfo lprRosterInfo, ContextInfo context) throws InvalidParameterException, MissingParameterException, DoesNotExistException, PermissionDeniedException, OperationFailedException {
 671  0 
         Map<String, LprRosterEntryInfo> lprIdToRosterEntriesMap = new HashMap<String, LprRosterEntryInfo>();
 672  0 
         List<String> graderIds = new ArrayList<String>();
 673  0 
         List<String> lprRosterEntryIds = new ArrayList<String>();
 674   
 
 675  0 
         List<LprRosterEntryInfo> lprRosterEntries = lprService.getLprRosterEntriesForRoster(lprRosterInfo.getId(), context);
 676  0 
         for (LprRosterEntryInfo lprRosterEntry : lprRosterEntries) {
 677  0 
             String lprId = lprRosterEntry.getLprId();
 678  0 
             lprIdToRosterEntriesMap.put(lprId, lprRosterEntry);
 679  0 
         }
 680   
 
 681  0 
         List<String> lprIds = new ArrayList<String>(lprIdToRosterEntriesMap.keySet());
 682  0 
         List<LuiPersonRelationInfo> lprInfos = lprService.getLprsByIds(lprIds, context);
 683  0 
         for (LuiPersonRelationInfo lprInfo : lprInfos) {
 684  0 
             String lprInfoType = lprInfo.getTypeKey();
 685  0 
             if (LuiPersonRelationServiceConstants.INSTRUCTOR_MAIN_TYPE_KEY.equals(lprInfoType)) {
 686  0 
                 graderIds.add(lprInfo.getPersonId());
 687  0 
             } else if (LuiPersonRelationServiceConstants.REGISTRANT_TYPE_KEY.equals(lprInfoType)) {
 688  0 
                 LprRosterEntryInfo lprRosterEntryInfo = lprIdToRosterEntriesMap.get(lprInfo.getId());
 689  0 
                 lprRosterEntryIds.add(lprRosterEntryInfo.getId());
 690   
             }
 691  0 
         }
 692   
 
 693  0 
         String courseOfferingId = null;
 694  0 
         List<String> activityOfferingIds = null;
 695   
 
 696  0 
         List<String> associatedLuiIds = lprRosterInfo.getAssociatedLuiIds();
 697   
 
 698  0 
         if (associatedLuiIds == null || associatedLuiIds.size() ==  0) {
 699  0 
             throw new OperationFailedException("LPR Roster does not contain any associated LUI IDs.");
 700  0 
         } else if (associatedLuiIds.size() ==  1) {
 701  0 
             CourseOfferingInfo courseOffering = courseOfferingService.getCourseOffering(associatedLuiIds.get(0), context);
 702  0 
             courseOfferingId = courseOffering.getId();
 703  0 
             activityOfferingIds = new ArrayList<String>();
 704  0 
         } else if (associatedLuiIds.size() >  1) {
 705  0 
             activityOfferingIds = associatedLuiIds;
 706   
 
 707  0 
             List<String> relatedLuis = luiService.getLuiIdsByLuiAndRelationType(activityOfferingIds.get(0), LuiServiceConstants.LUI_LUI_RELATION_DELIVEREDVIA_TYPE_KEY, context);
 708  0 
             if (relatedLuis == null || relatedLuis.size() != 1) {
 709  0 
                 throw new OperationFailedException("The provided activity offering is not related to 1 and only 1 course offering.");
 710   
             }
 711  0 
             courseOfferingId = relatedLuis.get(0);
 712   
         }
 713   
 
 714  0 
         GradeRosterInfo gradeRosterInfo = gradeRosterAssembler.assemble(lprRosterInfo, lprRosterEntryIds, graderIds, courseOfferingId, activityOfferingIds, context);
 715  0 
         return gradeRosterInfo;
 716   
     }
 717   
 
 718   
     private List<GradeRosterEntryInfo> assembleGradeRosterEntries(List<LprRosterEntryInfo> entries, ContextInfo context)
 719   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 720   
 
 721   
         //FIXME : This method needs some code refactoring
 722   
 
 723  0 
         final String STUDENT_ID = "studentId";
 724  0 
         final String ACTIVITY_OFFERING_ID = "activityOfferingId";
 725  0 
         final String ASSIGNED_GRADE = "assignedGrade";
 726  0 
         final String ADMINISTRATIVE_GRADE = "administrativeGrade";
 727  0 
         final String CREDITS_EARNED = "creditsEarned";
 728  0 
         final String CALCULATED_GRADE = "calculatedGrade";
 729  0 
         final String GRADING_OPTION = "gradingOption";
 730   
 
 731  0 
         List<GradeRosterEntryInfo> gradeRosterEntryInfos = new ArrayList<GradeRosterEntryInfo>();
 732  0 
         Map<LprRosterEntryInfo, Map<String, String>> entryKeysMap = new HashMap<LprRosterEntryInfo, Map<String, String>>();
 733   
 
 734  0 
         Map<String, LprRosterEntryInfo> lprIdToEntryMap = new HashMap<String, LprRosterEntryInfo>();
 735  0 
         for (LprRosterEntryInfo lprRosterEntryInfo : entries) {
 736  0 
             lprIdToEntryMap.put(lprRosterEntryInfo.getLprId(), lprRosterEntryInfo);
 737  0 
             entryKeysMap.put(lprRosterEntryInfo, new HashMap<String, String>());
 738   
         }
 739   
 
 740  0 
         List<String> lprIds = new ArrayList(lprIdToEntryMap.keySet());
 741  0 
         List<LuiPersonRelationInfo> lprs = lprService.getLprsByIds(lprIds, context);
 742   
 
 743  0 
         Map<String,List> lprToGradeOptions = new HashMap();
 744   
 
 745  0 
         for (LuiPersonRelationInfo lpr : lprs) {
 746  0 
             Map<String, String> entryAttributes = entryKeysMap.get(lprIdToEntryMap.get(lpr.getId()));
 747  0 
             entryAttributes.put(STUDENT_ID, lpr.getPersonId());
 748  0 
             entryAttributes.put(ACTIVITY_OFFERING_ID, lpr.getLuiId());
 749   
 
 750  0 
             CourseOfferingInfo courseOfferingInfo = courseOfferingService.getCourseOffering(lpr.getLuiId(),context);
 751   
 
 752  0 
             if (courseOfferingInfo == null){
 753  0 
                 throw new OperationFailedException("Could not find course offering " + lpr.getLuiId());
 754   
             }
 755   
 
 756  0 
             lprToGradeOptions.put(lpr.getId(),courseOfferingInfo.getGradingOptionIds());
 757   
 
 758  0 
         }
 759   
 
 760  0 
         List<LearningResultRecordInfo> lrrs = lrrService.getLearningResultRecordsForLprIds(lprIds, context);
 761  0 
         Map<LearningResultRecordInfo, String> lrrToLprIdMap = new HashMap<LearningResultRecordInfo, String>();
 762  0 
         List<String> resultValueKeys = new ArrayList<String>();
 763  0 
         List<LearningResultRecordInfo> filteredLrrs = new ArrayList();
 764   
 
 765  0 
         for (LearningResultRecordInfo lrr : lrrs) {
 766   
             //Skip deleted LRR
 767  0 
             if (!StringUtils.equals(lrr.getStateKey(),LrrServiceConstants.RESULT_RECORD_DELETED_STATE_KEY)){
 768  0 
                 lrrToLprIdMap.put(lrr, lrr.getLprId());
 769  0 
                 if (StringUtils.isNotBlank(lrr.getResultValueKey())){
 770  0 
                     resultValueKeys.add(lrr.getResultValueKey());
 771  0 
                     filteredLrrs.add(lrr);
 772   
                 }
 773   
             }
 774   
         }
 775   
 
 776  0 
         List<ResultValueInfo> resultValues = lrcService.getResultValuesByIds(resultValueKeys, context);
 777  0 
         for (int i = 0; i < resultValues.size(); i++) {
 778  0 
             LearningResultRecordInfo lrr = filteredLrrs.get(i);
 779  0 
             ResultValueInfo resultValue = resultValues.get(i);
 780  0 
             String lprId = lrrToLprIdMap.get(lrr);
 781  0 
             LprRosterEntryInfo entry = lprIdToEntryMap.get(lprId);
 782  0 
             Map<String, String> entryAttributes = entryKeysMap.get(entry);
 783   
 
 784  0 
             String resultValuetypeKey = resultValue.getTypeKey();
 785  0 
             String entryAttributesKey = null;
 786  0 
             if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_GRADE.equals(resultValuetypeKey)) {
 787  0 
                 entryAttributesKey = ASSIGNED_GRADE;
 788  0 
             } else if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_ADMIN_GRADE.equals(resultValuetypeKey)) {
 789  0 
                 entryAttributesKey = ADMINISTRATIVE_GRADE;
 790  0 
             } else if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_CREDIT.equals(resultValuetypeKey)) {
 791  0 
                 entryAttributesKey = CREDITS_EARNED;
 792   
             } else if (false) { //"".equals(resultValuetypeKey)) { // TODO need type value for calculated grade
 793   
                 entryAttributesKey = CALCULATED_GRADE;
 794   
             }
 795   
 
 796  0 
             if (entryAttributesKey != null) {
 797  0 
                 entryAttributes.put(entryAttributesKey, resultValue.getKey());
 798   
             }
 799   
         }
 800   
 
 801  0 
         for (LprRosterEntryInfo lprRosterEntry : entryKeysMap.keySet()) {
 802  0 
             Map<String, String> entryAttributes = entryKeysMap.get(lprRosterEntry);
 803  0 
             String studentId = entryAttributes.get(STUDENT_ID);
 804  0 
             String activityOfferingId = entryAttributes.get(ACTIVITY_OFFERING_ID);
 805  0 
             String assignedGradeKey = entryAttributes.get(ASSIGNED_GRADE);
 806  0 
             String calculatedGradeKey = entryAttributes.get(CALCULATED_GRADE);
 807  0 
             String administrativeGradeKey = entryAttributes.get(ADMINISTRATIVE_GRADE);
 808  0 
             String creditsEarnedKey = entryAttributes.get(CREDITS_EARNED);
 809  0 
             List gradingOptionKey = lprToGradeOptions.get(lprRosterEntry.getLprId());
 810   
 
 811  0 
             GradeRosterEntryInfo gradeRosterEntry = gradeRosterEntryAssembler.assemble(lprRosterEntry, studentId, activityOfferingId, assignedGradeKey, calculatedGradeKey, administrativeGradeKey, creditsEarnedKey, gradingOptionKey , context);
 812  0 
             gradeRosterEntryInfos.add(gradeRosterEntry);
 813  0 
         }
 814   
 
 815  0 
         return gradeRosterEntryInfos;
 816   
     }
 817   
 
 818   
     private GradeRosterEntryInfo assembleGradeRosterEntry(LprRosterEntryInfo lprRosterEntry, ContextInfo context)
 819   
             throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 820   
 
 821   
         String studentId;
 822   
         String activityOfferingId;
 823  0 
         String assignedGradeKey = null;
 824  0 
         String administrativeGradeKey = null;
 825  0 
         String creditsEarnedKey = null;
 826  0 
         String calculatedGradeKey = null;
 827  0 
         List<String> gradingOptionKeys = new ArrayList<String>();
 828   
 
 829  0 
         String lprId = lprRosterEntry.getLprId();
 830  0 
         LuiPersonRelationInfo lpr = lprService.getLpr(lprId, context);
 831   
 
 832  0 
         studentId = lpr.getPersonId();
 833  0 
         activityOfferingId = lpr.getLuiId();
 834   
 
 835   
         // TODO Get grading options from courseRegistration instead of courseOffering.
 836  0 
         CourseOfferingInfo courseOfferingInfo = courseOfferingService.getCourseOffering(lpr.getLuiId(),context);
 837  0 
         gradingOptionKeys.addAll(courseOfferingInfo.getGradingOptionIds());
 838   
 
 839  0 
         List<LearningResultRecordInfo> lrrs = lrrService.getLearningResultRecordsForLpr(lprId);
 840  0 
         List<String> resultValueKeys = new ArrayList<String>();
 841   
 
 842  0 
         for (LearningResultRecordInfo lrr : lrrs) {
 843   
             //Skip deleted LRR
 844  0 
             if (StringUtils.isBlank(lrr.getResultValueKey()) ||
 845   
                     StringUtils.equals(lrr.getStateKey(),LrrServiceConstants.RESULT_RECORD_DELETED_STATE_KEY)) {
 846  0 
                 lrrs.remove(lrr);
 847   
             } else {
 848  0 
                 resultValueKeys.add(lrr.getResultValueKey());
 849   
             }
 850   
         }
 851   
 
 852  0 
         List<ResultValueInfo> resultValues = lrcService.getResultValuesByIds(resultValueKeys, context);
 853  0 
         for (int i = 0; i < resultValues.size(); i++) {
 854  0 
             ResultValueInfo resultValue = resultValues.get(i);
 855  0 
             String resultValuetypeKey = resultValue.getTypeKey();
 856  0 
             if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_GRADE.equals(resultValuetypeKey)) {
 857  0 
                 assignedGradeKey = resultValue.getKey();
 858  0 
             } else if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_ADMIN_GRADE.equals(resultValuetypeKey)) {
 859  0 
                 administrativeGradeKey = resultValue.getKey();
 860  0 
             } else if (LrcServiceConstants.RESULT_SCALE_TYPE_KEY_CREDIT.equals(resultValuetypeKey)) {
 861  0 
                 creditsEarnedKey = resultValue.getKey();
 862   
             } else if (false) { //"".equals(resultValuetypeKey)) { // TODO need type value for calculated grade
 863   
                 calculatedGradeKey = resultValue.getKey();
 864   
             }
 865   
         }
 866   
 
 867  0 
         GradeRosterEntryInfo gradeRosterEntry = gradeRosterEntryAssembler.assemble(lprRosterEntry, studentId, activityOfferingId, assignedGradeKey, calculatedGradeKey, administrativeGradeKey, creditsEarnedKey, gradingOptionKeys , context);
 868   
 
 869  0 
         return gradeRosterEntry;
 870   
     }
 871   
 
 872   
     public LuiPersonRelationService getLprService() {
 873  0 
         return lprService;
 874   
     }
 875   
 
 876   
     public void setLprService(LuiPersonRelationService lprService) {
 877  0 
         this.lprService = lprService;
 878  0 
     }
 879   
 
 880   
     public CourseOfferingService getCourseOfferingService() {
 881  0 
         return courseOfferingService;
 882   
     }
 883   
 
 884   
     public void setCourseOfferingService(CourseOfferingService courseOfferingService) {
 885  0 
         this.courseOfferingService = courseOfferingService;
 886  0 
     }
 887   
 
 888   
     public LRCService getLrcService() {
 889  0 
         return lrcService;
 890   
     }
 891   
 
 892   
     public void setLrcService(LRCService lrcService) {
 893  0 
         this.lrcService = lrcService;
 894  0 
     }
 895   
 
 896   
     public LearningResultRecordService getLrrService() {
 897  0 
         return lrrService;
 898   
     }
 899   
 
 900   
     public void setLrrService(LearningResultRecordService lrrService) {
 901  0 
         this.lrrService = lrrService;
 902  0 
     }
 903   
 
 904   
     public LuiService getLuiService() {
 905  0 
         return luiService;
 906   
     }
 907   
 
 908   
     public void setLuiService(LuiService luiService) {
 909  0 
         this.luiService = luiService;
 910  0 
     }
 911   
 
 912   
     public GradeRosterAssembler getGradeRosterAssembler() {
 913  0 
         return gradeRosterAssembler;
 914   
     }
 915   
 
 916   
     public void setGradeRosterAssembler(GradeRosterAssembler gradeRosterAssembler) {
 917  0 
         this.gradeRosterAssembler = gradeRosterAssembler;
 918  0 
     }
 919   
 
 920   
     public GradeRosterEntryAssembler getGradeRosterEntryAssembler() {
 921  0 
         return gradeRosterEntryAssembler;
 922   
     }
 923   
 
 924   
     public void setGradeRosterEntryAssembler(GradeRosterEntryAssembler gradeRosterEntryAssembler) {
 925  0 
         this.gradeRosterEntryAssembler = gradeRosterEntryAssembler;
 926  0 
     }
 927   
 
 928   
     public GradeValuesGroupAssembler getGradeValuesGroupAssembler() {
 929  0 
         return gradeValuesGroupAssembler;
 930   
     }
 931   
 
 932   
     public void setGradeValuesGroupAssembler(GradeValuesGroupAssembler gradeValuesGroupAssembler) {
 933  0 
         this.gradeValuesGroupAssembler = gradeValuesGroupAssembler;
 934  0 
     }
 935   
 
 936   
     public CourseRegistrationService getCourseRegistrationService() {
 937  0 
         return courseRegistrationService;
 938   
     }
 939   
 
 940   
     public void setCourseRegistrationService(CourseRegistrationService courseRegistrationService) {
 941  0 
         this.courseRegistrationService = courseRegistrationService;
 942  0 
     }
 943   
 }
Report generated by Cobertura 1.9.4.1 on 5/23/12 8:08 AM.