Coverage Report - org.kuali.student.enrollment.courseregistration.service.CourseRegistrationServiceDecorator
 
Classes in this File Line Coverage Branch Coverage Complexity
CourseRegistrationServiceDecorator
0%
0/68
0%
0/2
1.032
 
 1  
 package org.kuali.student.enrollment.courseregistration.service;
 2  
 
 3  
 import java.util.List;
 4  
 
 5  
 import org.kuali.rice.core.api.criteria.QueryByCriteria;
 6  
 import org.kuali.student.enrollment.courseoffering.dto.RegistrationGroupInfo;
 7  
 import org.kuali.student.enrollment.courseregistration.dto.ActivityRegistrationInfo;
 8  
 import org.kuali.student.enrollment.courseregistration.dto.CourseRegistrationInfo;
 9  
 import org.kuali.student.enrollment.courseregistration.dto.RegGroupRegistrationInfo;
 10  
 import org.kuali.student.enrollment.courseregistration.dto.RegRequestInfo;
 11  
 import org.kuali.student.enrollment.courseregistration.dto.RegResponseInfo;
 12  
 import org.kuali.student.enrollment.coursewaitlist.dto.CourseWaitlistEntryInfo;
 13  
 import org.kuali.student.enrollment.grading.dto.LoadInfo;
 14  
 import org.kuali.student.r2.common.dto.ContextInfo;
 15  
 import org.kuali.student.r2.common.dto.DateRangeInfo;
 16  
 import org.kuali.student.r2.common.dto.StatusInfo;
 17  
 import org.kuali.student.r2.common.dto.ValidationResultInfo;
 18  
 import org.kuali.student.r2.common.exceptions.AlreadyExistsException;
 19  
 import org.kuali.student.r2.common.exceptions.DataValidationErrorException;
 20  
 import org.kuali.student.r2.common.exceptions.DisabledIdentifierException;
 21  
 import org.kuali.student.r2.common.exceptions.DoesNotExistException;
 22  
 import org.kuali.student.r2.common.exceptions.InvalidParameterException;
 23  
 import org.kuali.student.r2.common.exceptions.MissingParameterException;
 24  
 import org.kuali.student.r2.common.exceptions.OperationFailedException;
 25  
 import org.kuali.student.r2.common.exceptions.PermissionDeniedException;
 26  
 import org.kuali.student.r2.common.exceptions.VersionMismatchException;
 27  
 
 28  
 public class CourseRegistrationServiceDecorator implements CourseRegistrationService {
 29  
 
 30  
     private CourseRegistrationService nextDecorator;
 31  
 
 32  0
     public CourseRegistrationServiceDecorator() {
 33  0
     }
 34  
 
 35  0
     public CourseRegistrationServiceDecorator(CourseRegistrationService nextDecorator) {
 36  0
         this.nextDecorator = nextDecorator;
 37  0
     }
 38  
 
 39  
     public CourseRegistrationService getNextDecorator() throws OperationFailedException {
 40  0
         if (null == nextDecorator) {
 41  0
             throw new OperationFailedException("Misconfigured application: nextDecorator is null");
 42  
         }
 43  0
         return nextDecorator;
 44  
     }
 45  
 
 46  
     public void setNextDecorator(CourseRegistrationService nextDecorator) {
 47  0
         this.nextDecorator = nextDecorator;
 48  0
     }
 49  
 
 50  
     @Override
 51  
     public  List<ValidationResultInfo> checkStudentEligibility(String studentId, ContextInfo context) throws DoesNotExistException,
 52  
             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 53  0
         return getNextDecorator().checkStudentEligibility(studentId, context);
 54  
     }
 55  
 
 56  
     @Override
 57  
     public List<org.kuali.student.r2.common.dto.ValidationResultInfo> checkStudentEligibilityForTerm(String studentId,
 58  
             String termId, ContextInfo context) throws InvalidParameterException, MissingParameterException,
 59  
             OperationFailedException, PermissionDeniedException {
 60  0
         return getNextDecorator().checkStudentEligibilityForTerm(studentId, termId, context);
 61  
     }
 62  
 
 63  
     @Override
 64  
     public List<DateRangeInfo> getAppointmentWindows(String studentId, String termId, ContextInfo context)
 65  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 66  
             PermissionDeniedException {
 67  0
         return getNextDecorator().getAppointmentWindows(studentId, termId, context);
 68  
     }
 69  
 
 70  
     @Override
 71  
     public List<org.kuali.student.r2.common.dto.ValidationResultInfo> checkStudentEligibiltyForCourseOffering(
 72  
             String studentId, String courseOfferingId, ContextInfo context) throws InvalidParameterException,
 73  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 74  0
         return getNextDecorator().checkStudentEligibiltyForCourseOffering(studentId, courseOfferingId, context);
 75  
     }
 76  
 
 77  
     @Override
 78  
     public List<org.kuali.student.r2.common.dto.ValidationResultInfo> checkStudentEligibiltyForRegGroup(
 79  
             String studentId, String regGroupId, ContextInfo context) throws InvalidParameterException,
 80  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 81  0
         return getNextDecorator().checkStudentEligibiltyForRegGroup(studentId, regGroupId, context);
 82  
     }
 83  
 
 84  
     @Override
 85  
     public List<RegistrationGroupInfo> getEligibleRegGroupsForStudentInCourseOffering(String studentId,
 86  
             String courseOfferingId, ContextInfo context) throws InvalidParameterException, MissingParameterException,
 87  
             OperationFailedException, PermissionDeniedException {
 88  0
         return getNextDecorator().getEligibleRegGroupsForStudentInCourseOffering(studentId, courseOfferingId, context);
 89  
     }
 90  
 
 91  
     @Override
 92  
     public LoadInfo calculateCreditLoadForTerm(String studentId, String termId, ContextInfo context)
 93  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 94  
             PermissionDeniedException {
 95  0
         return getNextDecorator().calculateCreditLoadForTerm(studentId, termId, context);
 96  
     }
 97  
 
 98  
     @Override
 99  
     public LoadInfo calculateCreditLoadForRegRequest(String studentId, RegRequestInfo regRequestInfo,
 100  
             ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,
 101  
             PermissionDeniedException {
 102  0
         return getNextDecorator().calculateCreditLoadForRegRequest(studentId, regRequestInfo, context);
 103  
     }
 104  
 
 105  
     @Override
 106  
     public Integer getAvailableSeatsForCourseOffering(String courseOfferingId, ContextInfo context)
 107  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 108  
             PermissionDeniedException {
 109  0
         return getNextDecorator().getAvailableSeatsForCourseOffering(courseOfferingId, context);
 110  
     }
 111  
 
 112  
     @Override
 113  
     public Integer getAvailableSeatsForRegGroup(String regGroupId, ContextInfo context)
 114  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 115  
             PermissionDeniedException {
 116  0
         return getNextDecorator().getAvailableSeatsForRegGroup(regGroupId, context);
 117  
     }
 118  
 
 119  
     @Override
 120  
     public Integer getAvailableSeatsForStudentInRegGroup(String studentId, String regGroupId, ContextInfo context)
 121  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 122  
             PermissionDeniedException {
 123  0
         return getNextDecorator().getAvailableSeatsForStudentInRegGroup(studentId, regGroupId, context);
 124  
     }
 125  
 
 126  
     @Override
 127  
     public Integer getAvailableSeatsInSeatpool(String seatpoolId, ContextInfo context)
 128  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 129  
             PermissionDeniedException {
 130  0
         return getNextDecorator().getAvailableSeatsInSeatpool(seatpoolId, context);
 131  
     }
 132  
 
 133  
     @Override
 134  
     public RegRequestInfo createRegRequest(RegRequestInfo regRequestInfo, ContextInfo context)
 135  
             throws AlreadyExistsException, DataValidationErrorException, InvalidParameterException,
 136  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 137  0
         return getNextDecorator().createRegRequest(regRequestInfo, context);
 138  
     }
 139  
 
 140  
     @Override
 141  
     public RegRequestInfo updateRegRequest(String regRequestId, RegRequestInfo regRequestInfo, ContextInfo context)
 142  
             throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,
 143  
             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {
 144  0
         return getNextDecorator().updateRegRequest(regRequestId, regRequestInfo, context);
 145  
     }
 146  
 
 147  
     @Override
 148  
     public StatusInfo deleteRegRequest(String regRequestId, ContextInfo context) throws InvalidParameterException,
 149  
             MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException {
 150  0
         return getNextDecorator().deleteRegRequest(regRequestId, context);
 151  
     }
 152  
 
 153  
     @Override
 154  
     public List<ValidationResultInfo> validateRegRequest(RegRequestInfo regRequestInfo, ContextInfo context)
 155  
             throws DataValidationErrorException, InvalidParameterException, MissingParameterException,
 156  
             OperationFailedException, PermissionDeniedException {
 157  0
         return getNextDecorator().validateRegRequest(regRequestInfo, context);
 158  
     }
 159  
 
 160  
     @Override
 161  
     public List<ValidationResultInfo> verifyRegRequest(RegRequestInfo regRequestInfo, ContextInfo context)
 162  
             throws DataValidationErrorException, InvalidParameterException, MissingParameterException,
 163  
             OperationFailedException, PermissionDeniedException {
 164  0
         return getNextDecorator().verifyRegRequest(regRequestInfo, context);
 165  
     }
 166  
 
 167  
     @Override
 168  
     public RegResponseInfo verifySavedReqRequest(String regRequestId, ContextInfo context)
 169  
             throws DataValidationErrorException, InvalidParameterException, MissingParameterException,
 170  
             OperationFailedException, PermissionDeniedException {
 171  0
         return getNextDecorator().verifySavedReqRequest(regRequestId, context);
 172  
     }
 173  
 
 174  
     @Override
 175  
     public RegRequestInfo createRegRequestFromExisting(String existingRegRequestId, ContextInfo context)
 176  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 177  
             PermissionDeniedException, DoesNotExistException {
 178  0
         return getNextDecorator().createRegRequestFromExisting(existingRegRequestId, context);
 179  
     }
 180  
 
 181  
     @Override
 182  
     public RegResponseInfo submitRegRequest(String regRequestId, ContextInfo context) throws DoesNotExistException,
 183  
             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException,
 184  
             DataValidationErrorException, AlreadyExistsException {
 185  0
         return getNextDecorator().submitRegRequest(regRequestId, context);
 186  
     }
 187  
 
 188  
     @Override
 189  
     public StatusInfo cancelRegRequest(String regRequestId, ContextInfo context) throws DataValidationErrorException,
 190  
             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 191  0
         return getNextDecorator().cancelRegRequest(regRequestId, context);
 192  
     }
 193  
 
 194  
     @Override
 195  
     public List<RegRequestInfo> getRegRequestsByIds(List<String> regRequestIds, ContextInfo context)
 196  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 197  
             OperationFailedException, PermissionDeniedException {
 198  0
         return getNextDecorator().getRegRequestsByIds(regRequestIds, context);
 199  
     }
 200  
 
 201  
     @Override
 202  
     public List<RegRequestInfo> getRegRequestsForStudentByTerm(String studentId, String termId,
 203  
             List<String> requestStates, ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 204  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 205  0
         return getNextDecorator().getRegRequestsForStudentByTerm(studentId, termId, requestStates, context);
 206  
     }
 207  
 
 208  
     @Override
 209  
     public CourseWaitlistEntryInfo getCourseWaitlistEntry(String courseWaitlistEntryId, ContextInfo context)
 210  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 211  
             OperationFailedException, PermissionDeniedException {
 212  0
         return getNextDecorator().getCourseWaitlistEntry(courseWaitlistEntryId, context);
 213  
     }
 214  
 
 215  
     @Override
 216  
     public StatusInfo updateCourseWaitlistEntry(String courseWaitlistEntryId,
 217  
             CourseWaitlistEntryInfo courseWaitlistEntryInfo, ContextInfo context) throws DoesNotExistException,
 218  
             DataValidationErrorException, InvalidParameterException, MissingParameterException,
 219  
             OperationFailedException, PermissionDeniedException {
 220  0
         return getNextDecorator().updateCourseWaitlistEntry(courseWaitlistEntryId, courseWaitlistEntryInfo, context);
 221  
     }
 222  
 
 223  
     @Override
 224  
     public StatusInfo reorderCourseWaitlistEntries(List<String> courseWaitlistEntryIds, ContextInfo context)
 225  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 226  
             OperationFailedException, PermissionDeniedException {
 227  0
         return getNextDecorator().reorderCourseWaitlistEntries(courseWaitlistEntryIds, context);
 228  
     }
 229  
 
 230  
     @Override
 231  
     public StatusInfo insertCourseWaitlistEntryAtPosition(String courseWaitlistEntryId, Integer position,
 232  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 233  
             OperationFailedException, PermissionDeniedException {
 234  0
         return getNextDecorator().insertCourseWaitlistEntryAtPosition(courseWaitlistEntryId, position, context);
 235  
     }
 236  
 
 237  
     @Override
 238  
     public StatusInfo removeCourseWaitlistEntry(String courseWaitlistEntryId, ContextInfo context)
 239  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 240  
             OperationFailedException, PermissionDeniedException {
 241  0
         return getNextDecorator().removeCourseWaitlistEntry(courseWaitlistEntryId, context);
 242  
     }
 243  
 
 244  
     @Override
 245  
     public StatusInfo validateCourseWaitlistEntry(String validateTypeKey,
 246  
             CourseWaitlistEntryInfo courseWaitlistEntryInfo, ContextInfo context) throws DataValidationErrorException,
 247  
             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 248  0
         return getNextDecorator().validateCourseWaitlistEntry(validateTypeKey, courseWaitlistEntryInfo, context);
 249  
     }
 250  
 
 251  
     @Override
 252  
     public RegResponseInfo registerStudentFromWaitlist(String courseWaitlistEntryId, ContextInfo context)
 253  
             throws AlreadyExistsException, DataValidationErrorException, InvalidParameterException,
 254  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 255  0
         return getNextDecorator().registerStudentFromWaitlist(courseWaitlistEntryId, context);
 256  
     }
 257  
 
 258  
     @Override
 259  
     public List<CourseWaitlistEntryInfo> getCourseWaitlistEntriesForCourseOffering(String courseOfferingId,
 260  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 261  
             OperationFailedException, PermissionDeniedException {
 262  0
         return getNextDecorator().getCourseWaitlistEntriesForCourseOffering(courseOfferingId, context);
 263  
     }
 264  
 
 265  
     @Override
 266  
     public List<CourseWaitlistEntryInfo> getCourseWaitlistEntriesForRegGroup(String regGroupId, ContextInfo context)
 267  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 268  
             OperationFailedException, PermissionDeniedException {
 269  0
         return getNextDecorator().getCourseWaitlistEntriesForRegGroup(regGroupId, context);
 270  
     }
 271  
 
 272  
     @Override
 273  
     public List<CourseWaitlistEntryInfo> getCourseWaitlistEntriesForStudentInCourseOffering(String courseOfferingId,
 274  
             String studentId, ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 275  
             MissingParameterException, OperationFailedException, PermissionDeniedException {
 276  0
         return getNextDecorator().getCourseWaitlistEntriesForStudentInCourseOffering(courseOfferingId, studentId,
 277  
                 context);
 278  
     }
 279  
 
 280  
     @Override
 281  
     public CourseWaitlistEntryInfo getCourseWaitlistEntryForStudentInRegGroup(String regGroupId, String studentId,
 282  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 283  
             OperationFailedException, PermissionDeniedException {
 284  0
         return getNextDecorator().getCourseWaitlistEntryForStudentInRegGroup(regGroupId, studentId, context);
 285  
     }
 286  
 
 287  
     @Override
 288  
     public List<CourseWaitlistEntryInfo> getCourseWaitlistEntriesForStudentByTerm(String studentId, String termId,
 289  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 290  
             OperationFailedException, PermissionDeniedException {
 291  0
         return getNextDecorator().getCourseWaitlistEntriesForStudentByTerm(studentId, termId, context);
 292  
     }
 293  
 
 294  
     @Override
 295  
     public CourseRegistrationInfo getCourseRegistration(String courseRegistrationId, ContextInfo context)
 296  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 297  
             OperationFailedException, PermissionDeniedException {
 298  0
         return getNextDecorator().getCourseRegistration(courseRegistrationId, context);
 299  
     }
 300  
 
 301  
     @Override
 302  
     public List<CourseRegistrationInfo> getCourseRegistrationsByIds(List<String> courseRegistrationIds,
 303  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 304  
             OperationFailedException, PermissionDeniedException {
 305  0
         return getNextDecorator().getCourseRegistrationsByIds(courseRegistrationIds, context);
 306  
     }
 307  
 
 308  
     @Override
 309  
     public CourseRegistrationInfo getActiveCourseRegistrationForStudentByCourseOffering(String studentId,
 310  
             String courseOfferingId, ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 311  
             MissingParameterException, OperationFailedException, PermissionDeniedException, DisabledIdentifierException {
 312  0
         return getNextDecorator().getActiveCourseRegistrationForStudentByCourseOffering(studentId, courseOfferingId,
 313  
                 context);
 314  
     }
 315  
 
 316  
     @Override
 317  
     public List<CourseRegistrationInfo> getCourseRegistrationsForStudentByTerm(String studentId, String termId,
 318  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 319  
             OperationFailedException, PermissionDeniedException, DisabledIdentifierException {
 320  0
         return getNextDecorator().getCourseRegistrationsForStudentByTerm(studentId, termId, context);
 321  
     }
 322  
 
 323  
     @Override
 324  
     public List<CourseRegistrationInfo> getActiveCourseRegistrationsByCourseOfferingId(String courseOfferingId,
 325  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 326  
             OperationFailedException, PermissionDeniedException {
 327  0
         return getNextDecorator().getActiveCourseRegistrationsByCourseOfferingId(courseOfferingId, context);
 328  
     }
 329  
 
 330  
     @Override
 331  
     public List<RegRequestInfo> getRegRequestsForCourseRegistration(String courseRegistrationId, ContextInfo context)
 332  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 333  
             OperationFailedException, PermissionDeniedException {
 334  0
         return getNextDecorator().getRegRequestsForCourseRegistration(courseRegistrationId, context);
 335  
     }
 336  
 
 337  
     @Override
 338  
     public List<RegRequestInfo> getRegRequestsForCourseOffering(String courseOfferingId, ContextInfo context)
 339  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 340  
             OperationFailedException, PermissionDeniedException {
 341  0
         return getNextDecorator().getRegRequestsForCourseOffering(courseOfferingId, context);
 342  
     }
 343  
 
 344  
     @Override
 345  
     public List<RegRequestInfo> getRegRequestsForCourseOfferingByStudent(String courseOfferingId, String studentId,
 346  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 347  
             OperationFailedException, PermissionDeniedException {
 348  0
         return getNextDecorator().getRegRequestsForCourseOfferingByStudent(courseOfferingId, studentId, context);
 349  
     }
 350  
 
 351  
     @Override
 352  
     public List<CourseRegistrationInfo> searchForCourseRegistrations(QueryByCriteria criteria, ContextInfo context)
 353  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 354  
             PermissionDeniedException {
 355  0
         return getNextDecorator().searchForCourseRegistrations(criteria, context);
 356  
     }
 357  
 
 358  
     @Override
 359  
     public List<String> searchForCourseOfferingRegistrationIds(QueryByCriteria criteria, ContextInfo context)
 360  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 361  
             PermissionDeniedException {
 362  0
         return getNextDecorator().searchForCourseOfferingRegistrationIds(criteria, context);
 363  
     }
 364  
 
 365  
     @Override
 366  
     public List<ActivityRegistrationInfo> searchForActivityRegistrations(QueryByCriteria criteria, ContextInfo context)
 367  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 368  
             PermissionDeniedException {
 369  0
         return getNextDecorator().searchForActivityRegistrations(criteria, context);
 370  
     }
 371  
 
 372  
     @Override
 373  
     public List<String> searchForActivityRegistrationIds(QueryByCriteria criteria, ContextInfo context)
 374  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 375  
             PermissionDeniedException {
 376  0
         return getNextDecorator().searchForActivityRegistrationIds(criteria, context);
 377  
     }
 378  
 
 379  
     @Override
 380  
     public List<RegGroupRegistrationInfo> searchForRegGroupRegistrations(QueryByCriteria criteria, ContextInfo context)
 381  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 382  
             PermissionDeniedException {
 383  0
         return getNextDecorator().searchForRegGroupRegistrations(criteria, context);
 384  
     }
 385  
 
 386  
     @Override
 387  
     public List<String> searchForRegGroupRegistrationIds(QueryByCriteria criteria, ContextInfo context)
 388  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 389  
             PermissionDeniedException {
 390  0
         return getNextDecorator().searchForRegGroupRegistrationIds(criteria, context);
 391  
     }
 392  
 
 393  
     @Override
 394  
     public List<CourseWaitlistEntryInfo> searchForCourseWaitlistEntries(QueryByCriteria criteria, ContextInfo context)
 395  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 396  
             PermissionDeniedException {
 397  0
         return getNextDecorator().searchForCourseWaitlistEntries(criteria, context);
 398  
     }
 399  
 
 400  
     @Override
 401  
     public List<String> searchForCourseWaitlistEntryIds(QueryByCriteria criteria, ContextInfo context)
 402  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 403  
             PermissionDeniedException {
 404  0
         return getNextDecorator().searchForCourseWaitlistEntryIds(criteria, context);
 405  
     }
 406  
 
 407  
     @Override
 408  
     public RegRequestInfo getRegRequest(String regRequestId, ContextInfo context) throws DoesNotExistException,
 409  
             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
 410  0
         return getNextDecorator().getRegRequest(regRequestId, context);
 411  
     }
 412  
 
 413  
     @Override
 414  
     public StatusInfo deleteCourseWaitlistEntry(String courseWaitlistEntryId, ContextInfo context)
 415  
             throws InvalidParameterException, MissingParameterException, OperationFailedException,
 416  
             PermissionDeniedException {
 417  0
         return getNextDecorator().deleteCourseWaitlistEntry(courseWaitlistEntryId, context);
 418  
     }
 419  
 
 420  
     @Override
 421  
     public RegResponseInfo dropStudentsFromRegGroups(List<String> regGroupIds, ContextInfo context)
 422  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 423  
             OperationFailedException, PermissionDeniedException {
 424  0
         return getNextDecorator().dropStudentsFromRegGroups(regGroupIds, context);
 425  
     }
 426  
 
 427  
     @Override
 428  
     public RegResponseInfo moveStudentsBetweenRegGroups(String sourceRegGroupId, String destinationRegGroupId,
 429  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 430  
             OperationFailedException, PermissionDeniedException {
 431  0
         return getNextDecorator().moveStudentsBetweenRegGroups(sourceRegGroupId, destinationRegGroupId, context);
 432  
     }
 433  
 
 434  
     @Override
 435  
     public List<CourseRegistrationInfo> getCourseRegistrationsForStudentByCourseOffering(String studentId,
 436  
             String courseOfferingId, ContextInfo context) throws DoesNotExistException, InvalidParameterException,
 437  
             MissingParameterException, OperationFailedException, PermissionDeniedException, DisabledIdentifierException {
 438  0
         return getNextDecorator()
 439  
                 .getCourseRegistrationsForStudentByCourseOffering(studentId, courseOfferingId, context);
 440  
     }
 441  
 
 442  
     @Override
 443  
     public List<CourseRegistrationInfo> getDroppedCourseRegistrationsByCourseOfferingId(String courseOfferingId,
 444  
             ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 445  
             OperationFailedException, PermissionDeniedException {
 446  0
         return getNextDecorator().getDroppedCourseRegistrationsByCourseOfferingId(courseOfferingId, context);
 447  
     }
 448  
 
 449  
     @Override
 450  
     public List<CourseRegistrationInfo> getCourseRegistrationsForStudent(String studentId, ContextInfo context)
 451  
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
 452  
             OperationFailedException, PermissionDeniedException, DisabledIdentifierException {
 453  0
         return getNextDecorator().getCourseRegistrationsForStudent(studentId, context);
 454  
     }
 455  
 
 456  
 }