Coverage Report

Coverage Report - org.kuali.student.enrollment.courseoffering.infc.CourseOffering

Classes in this File

 /*
  * Copyright 2010 The Kuali Foundation 
  *
  * Licensed under the Educational Community License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the
  * License. You may obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.enrollment.courseoffering.infc;
 
 import org.kuali.student.r2.common.infc.IdNamelessEntity;
 import org.kuali.student.r2.common.infc.RichText;
 
 import java.util.List;
 
 /**
  * @author Kamal
  */
 
 public interface CourseOffering extends IdNamelessEntity{
 
     /**
      * A unique identifier assigned to all approved courses that exist
      * in the catalog This is not updatable once initialized.
      * 
      * @name Course Id
      * @readOnly
      * @required
      * @impl this maps the the version dependent id as the offering
      *       must point to one and only one version of the
      *       course. Maps to cluId in Lui.
      */
     public String getCourseId();
 
     /**
      * Academic term of course offering
      * 
      * @name Term Id
      * @readOnly on updates
      * @required
      * @impl set during the #createCourseOffering and then maps to
      *       the aptKey on the Lui
      */
     public String getTermId();
 
     /**
      * Custom Description for the course Offering.
      *
      * @name Course Offering Description
      */
     public RichText getDescr();
 
     /**
      * Identifies the number of a course as reflected in the course catalog.
      * This typically must be unique across all courses offered during that
      * term. If the user wants to create two separate offerings for the same
      * course they must modify this code to make it unique. For example: An
      * on-line offering of the course might have an "O" appended to it to
      * distinguish it from the face to face offering, i.e. ENG101 and ENG101O
      * Initially copied from the course catalog but then, depending on the
      * configuration it may be updatable. Often this field is configured so that
      * it is not not directly updatable but rather is calculated from it's two
      * constituent parts, the subject area and the course number suffix. For
      * example: Subject Area = "ENG" and Suffix = "101" then code = "ENG101"
      * 
      * @name Course Offering Code
      * @impl initialially this is copied from the course catalog code but then
      *       is subsequently stored in the lui as lui.officialIdentifier.code
      */
     public String getCourseOfferingCode();
 
     /**
      * Identifies the department and/subject code of the course as reflected in
      * the course catalog. Initially copied from the course catalog but then,
      * depending on the configuration it may be updatable. In most
      * configurations this should not be updatable. Often used in the
      * calculation of the courseCode
      * 
      * @name Subject Area
      * @impl initially copied from the canonical course but then stored in the
      *       Lui as lui.officialIdentifier.division
      */
     public String getSubjectArea();
 
     /**
      * A suffix of the course number as reflected in the college catalog. This
      * is the "number" portion of the course code. Initially copied from the
      * course catalog but then, depending on the configuration it may be
      * updatable. This field is often configured to be updatable but the updates
      * typically simply append something like an "O" for on-line to it to
      * differentiate multiple course offerings for the same course. Often used
      * in the calculation of the courseCode.
      * 
      * @name Course Number Suffix
      * @impl initially copied from the canonical course but then stored in the
      *       Lui as lui.officialIdentifier.suffixCode
      */
     public String getCourseNumberSuffix();
 
     /**
      * Name of the course used in the college catalog. Initially copied from the
      * course catalog but then, depending on the configuration it may be
      * updatable. For regular courses this is not generally allowed to be
      * updated on the offering, but for special topics courses this is often
      * overridden to capture the particular topic being taught offered this
      * term. Note: the configuration of the validation for titles is typically
      * restricted to exclude line breaks. This may have to be loosened as some
      * schools may want the particular topic to appear on a 2nd line. For
      * example: SPECIAL TOPICS: AN EXPLORATION OF DEEP SPACE ARTIFACTS
      * l
      * @name Course Title
      * @impl initially copied from the canonical course but then stored in the
      *       Lui as lui.officialIdentifier.longName
      */
     public String getCourseOfferingTitle();
 
     /**
      * Indicates that the entire course offering is an Honors Course ??? Is this
      * an enrollment restriction rule or a flag or both?
      * 
      * @name Is Honors Offering
      * @impl store in a generic lui luCodes type of field?
      */
     public Boolean getIsHonorsOffering();
 
     /**
      * Total maximum number of "seats" or enrollment slots that can be filled
      * for the offering. Calculated based on sum of all the maximum seats of
      * primary activity type offerings.
      * 
      * @name Maximum Enrollment
      * @impl maps to Lui.maximumEnrollment
      */
     public Integer getMaximumEnrollment();
 
     /**
      * Total minimum number of seats that must be filled for the offering not to
      * be canceled. Calculated based on sum of all the minimum seats of primary
      * activity type offerings
      * 
      * @name Minimum Enrollment
      * @impl maps to Lui.minimumEnrollment
      */
     public Integer getMinimumEnrollment();
 
     /**
      * The unique identifier of the other course offerings with which this
      * offering is joint-listed
      * 
      * @name Joint Offering Ids
      * @readOnly I think?
      * @impl Canonical might suggest offerings that can be jointly offered. This
      *       is stored as a luiluirelation of joint type
      */
     public List<String> getJointOfferingIds();
 
     /******** Assessment Information ***************/
     /**
      * The options/scales that indicate the allowable grades that can be
      * awarded. Typically the values here are constrained by the values on the
      * canonical course. If the value is set here then the Clu must have a
      * grading option set on the canonical activity. For example: an id might
      * point to Pass/Fail or Letter Graded option.
      * 
      * @name: Grading Option Ids
      * @impl these are actually Ids to ResultValuesGroup. Lui.resultOptionIds
      *       returns a list of resultOptions. Filter options with grading type
      *       and those should give the resultValueGroupIds
      */
     public List<String> getGradingOptionIds();
 
     /**
      * Type of credit of course offering. This field is initially copied from
      * the canonical course but then, depending on configuration, it may be
      * updated. TODO: figure out which of the credit options will be copied down
      * because the canonical has more than one! Often it is just a fixed single
      * value but a ResultValuesGroup could contain a range (with increments) or
      * even a discrete list of possible credit values.
      * 
      * @name Credit Options
      * @impl Lui.resultOptionIds returns a list of resultOptions. Filter option
      *       with credit type and that should give the resultValueGroup
      */
     public List<String> getCreditOptionIds();
 
 
 
     /******** Personnel Information *****************/
 
     /**
      * Instructors for this course offering TODO: find out if the canonical
      * instructors should be copied down
      * 
      * @name Instructors
      * @impl These are derived from Lui Person relations with instructor type
      */
     public List<? extends OfferingInstructor> getInstructors();
 
     /********* Organization Information **************/
 
     /**
      * Organization(s) that is responsible for administering the course delivery
      * - and all associated logistics - of the course Initially copied from the
      * canonical course then, depending on the configuration, updated This is
      * typically an academic department but could be for example the extended
      * studies office that is responsible for delivering the course even though
      * it's content is managed by an academic department.
      * 
      * @name Units Deployment
      * @impl initalized from canonical course units deployment but then stored
      *       in lui.unitsDeployment
      */
     public List<String> getUnitsDeploymentOrgIds();
 
     /**
      * Organization(s) that is responsible for the academic content of the
      * course as approved in its canonical form. This is the organization that
      * has oversight of the curriculum. This is typically an academic
      * department.
      * 
      * @name Units Content Owner
      * @readOnly on updates
      * @impl this is never updatable so it should just be grabbed from the
      *       canonical course and then stored in lui.unitsContentOwner
      */
     public List<String> getUnitsContentOwnerOrgIds();
 
 
 
     /*********** Waitlist *****************************/
 
     /*
      * TODO: Skip this section for core slice development
      */
 
     /**
      * Indicates whether a RegistrationGroup has a waitlist TODO: figure out how
      * to store this TODO: make sure we are consistent on how we spell Waitlist,
      * should be spelled Waitlist, or Wait List or Wait-List (as the
      * merriam-webster has it)
      * 
      * @name Has Waitlist
      * @impl not sure how to store this, it depends on how we end up
      *       implementing waitlists.
      */
     public Boolean getHasWaitlist();
 
     /**
      * Indicates the type of waitlist as it relates to processing students on
      * and off The three types predefined in kuali are Automatic, Semi-Automatic
      * and Manual TODO: Right not Waitlist types are not tied to any Waitlist
      * object so we need to define an "other key" to get the list of valid
      * values from the type service. TODO: Decide if we need a separate
      * getHasWaitList, perhaps no value in this field means no waitlist. TODO:
      * Cross validate with hasWaitlist
      * 
      * @name Waitlist Type Key
      * @impl TODO: decide if this this should be stored on the Lui or on a
      *       waitlist object?
      */
     public String getWaitlistTypeKey();
 
     /**
      *  Indicates the waitlist level, i.e., CourseOffering or ActivityOffering
      *
      * @name Waitlist Level Type Key
     */
 
     public String  getWaitlistLevelTypeKey();
 
   /************* Finances ***************************/
 
     /**
      * The primary source of funding for the offering.
      * 
      * @name Funding Source
      * @impl fyi "funding source" is an enumeration values are state support,
      *       self-support, contract funding
      */
     public String getFundingSource();
 
     /**
      * Flag indicating whether a course is eligible for Financial Aid. Derived
      * from course catalog (canonical) TODO: find a place to store this on the
      * canonical course because it does not currently exist there TODO: Decide
      * if this is really a rule or a CluSet or what?
      * 
      * @name Is Financial Aid Eligible
      * @impl TODO: decide where to store
      */
     public Boolean getIsFinancialAidEligible();
 
     /**
      * Is this Course Offering Financial aid eligible.  (why is this
      * here?) use getIsFinancialAidEligible().
      *
      * @name Financial Aid Eligible Flag
      */
     @Deprecated
     public Boolean getFinancialAidEligible();
 
     /**
      * Places where this Course offering is offered.
      *
      * @name Campus Locations
      */
     public List<String> getCampusLocations();
 
     /**
      * Is this a Honors Course offering
      *
      * @name Honors Flag
      */
     public Boolean getHonorsOffering();
 
     /**
      * Indicates the type of final exam ('STANDARD', 'ALTERNATE', 'NONE') to be given  for this format Offering, if any
      *
      * @name Final Exam Type
      */
     public String getFinalExamType();
 
     /**
      * Indicates whether the fee is at activity offering level or
      * course offering level. If true its at Activity Offering level,
      * if false its at CourseOffering level.
      *
      * @name Is Fee at Activity Offering
      */
     public Boolean getIsFeeAtActivityOffering();
 
     /**
      * Indicates whether the course offering has an evaluation.
      *
      * @name Is Evaluated
      */
     public Boolean getIsEvaluated();
 
     /**
      * Gets the Course Offering URL.
      *
      * @name Course Offering URL
      */
     public String getCourseOfferingURL();
 }

1		/*
2		* Copyright 2010 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the
5		* "License"); you may not use this file except in compliance with the
6		* License. You may obtain a copy of the License at
7		*
8		* http://www.osedu.org/licenses/ECL-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
13		* implied. See the License for the specific language governing
14		* permissions and limitations under the License.
15		*/
16
17		package org.kuali.student.enrollment.courseoffering.infc;
18
19		import org.kuali.student.r2.common.infc.IdNamelessEntity;
20		import org.kuali.student.r2.common.infc.RichText;
21
22		import java.util.List;
23
24		/**
25		* @author Kamal
26		*/
27
28		public interface CourseOffering extends IdNamelessEntity{
29
30		/**
31		* A unique identifier assigned to all approved courses that exist
32		* in the catalog This is not updatable once initialized.
33		*
34		* @name Course Id
35		* @readOnly
36		* @required
37		* @impl this maps the the version dependent id as the offering
38		* must point to one and only one version of the
39		* course. Maps to cluId in Lui.
40		*/
41		public String getCourseId();
42
43		/**
44		* Academic term of course offering
45		*
46		* @name Term Id
47		* @readOnly on updates
48		* @required
49		* @impl set during the #createCourseOffering and then maps to
50		* the aptKey on the Lui
51		*/
52		public String getTermId();
53
54		/**
55		* Custom Description for the course Offering.
56		*
57		* @name Course Offering Description
58		*/
59		public RichText getDescr();
60
61		/**
62		* Identifies the number of a course as reflected in the course catalog.
63		* This typically must be unique across all courses offered during that
64		* term. If the user wants to create two separate offerings for the same
65		* course they must modify this code to make it unique. For example: An
66		* on-line offering of the course might have an "O" appended to it to
67		* distinguish it from the face to face offering, i.e. ENG101 and ENG101O
68		* Initially copied from the course catalog but then, depending on the
69		* configuration it may be updatable. Often this field is configured so that
70		* it is not not directly updatable but rather is calculated from it's two
71		* constituent parts, the subject area and the course number suffix. For
72		* example: Subject Area = "ENG" and Suffix = "101" then code = "ENG101"
73		*
74		* @name Course Offering Code
75		* @impl initialially this is copied from the course catalog code but then
76		* is subsequently stored in the lui as lui.officialIdentifier.code
77		*/
78		public String getCourseOfferingCode();
79
80		/**
81		* Identifies the department and/subject code of the course as reflected in
82		* the course catalog. Initially copied from the course catalog but then,
83		* depending on the configuration it may be updatable. In most
84		* configurations this should not be updatable. Often used in the
85		* calculation of the courseCode
86		*
87		* @name Subject Area
88		* @impl initially copied from the canonical course but then stored in the
89		* Lui as lui.officialIdentifier.division
90		*/
91		public String getSubjectArea();
92
93		/**
94		* A suffix of the course number as reflected in the college catalog. This
95		* is the "number" portion of the course code. Initially copied from the
96		* course catalog but then, depending on the configuration it may be
97		* updatable. This field is often configured to be updatable but the updates
98		* typically simply append something like an "O" for on-line to it to
99		* differentiate multiple course offerings for the same course. Often used
100		* in the calculation of the courseCode.
101		*
102		* @name Course Number Suffix
103		* @impl initially copied from the canonical course but then stored in the
104		* Lui as lui.officialIdentifier.suffixCode
105		*/
106		public String getCourseNumberSuffix();
107
108		/**
109		* Name of the course used in the college catalog. Initially copied from the
110		* course catalog but then, depending on the configuration it may be
111		* updatable. For regular courses this is not generally allowed to be
112		* updated on the offering, but for special topics courses this is often
113		* overridden to capture the particular topic being taught offered this
114		* term. Note: the configuration of the validation for titles is typically
115		* restricted to exclude line breaks. This may have to be loosened as some
116		* schools may want the particular topic to appear on a 2nd line. For
117		* example: SPECIAL TOPICS: AN EXPLORATION OF DEEP SPACE ARTIFACTS
118		* l
119		* @name Course Title
120		* @impl initially copied from the canonical course but then stored in the
121		* Lui as lui.officialIdentifier.longName
122		*/
123		public String getCourseOfferingTitle();
124
125		/**
126		* Indicates that the entire course offering is an Honors Course ??? Is this
127		* an enrollment restriction rule or a flag or both?
128		*
129		* @name Is Honors Offering
130		* @impl store in a generic lui luCodes type of field?
131		*/
132		public Boolean getIsHonorsOffering();
133
134		/**
135		* Total maximum number of "seats" or enrollment slots that can be filled
136		* for the offering. Calculated based on sum of all the maximum seats of
137		* primary activity type offerings.
138		*
139		* @name Maximum Enrollment
140		* @impl maps to Lui.maximumEnrollment
141		*/
142		public Integer getMaximumEnrollment();
143
144		/**
145		* Total minimum number of seats that must be filled for the offering not to
146		* be canceled. Calculated based on sum of all the minimum seats of primary
147		* activity type offerings
148		*
149		* @name Minimum Enrollment
150		* @impl maps to Lui.minimumEnrollment
151		*/
152		public Integer getMinimumEnrollment();
153
154		/**
155		* The unique identifier of the other course offerings with which this
156		* offering is joint-listed
157		*
158		* @name Joint Offering Ids
159		* @readOnly I think?
160		* @impl Canonical might suggest offerings that can be jointly offered. This
161		* is stored as a luiluirelation of joint type
162		*/
163		public List<String> getJointOfferingIds();
164
165		/****** Assessment Information *************/
166		/**
167		* The options/scales that indicate the allowable grades that can be
168		* awarded. Typically the values here are constrained by the values on the
169		* canonical course. If the value is set here then the Clu must have a
170		* grading option set on the canonical activity. For example: an id might
171		* point to Pass/Fail or Letter Graded option.
172		*
173		* @name: Grading Option Ids
174		* @impl these are actually Ids to ResultValuesGroup. Lui.resultOptionIds
175		* returns a list of resultOptions. Filter options with grading type
176		* and those should give the resultValueGroupIds
177		*/
178		public List<String> getGradingOptionIds();
179
180		/**
181		* Type of credit of course offering. This field is initially copied from
182		* the canonical course but then, depending on configuration, it may be
183		* updated. TODO: figure out which of the credit options will be copied down
184		* because the canonical has more than one! Often it is just a fixed single
185		* value but a ResultValuesGroup could contain a range (with increments) or
186		* even a discrete list of possible credit values.
187		*
188		* @name Credit Options
189		* @impl Lui.resultOptionIds returns a list of resultOptions. Filter option
190		* with credit type and that should give the resultValueGroup
191		*/
192		public List<String> getCreditOptionIds();
193
194
195
196		/****** Personnel Information ***************/
197
198		/**
199		* Instructors for this course offering TODO: find out if the canonical
200		* instructors should be copied down
201		*
202		* @name Instructors
203		* @impl These are derived from Lui Person relations with instructor type
204		*/
205		public List<? extends OfferingInstructor> getInstructors();
206
207		/******* Organization Information ************/
208
209		/**
210		* Organization(s) that is responsible for administering the course delivery
211		* - and all associated logistics - of the course Initially copied from the
212		* canonical course then, depending on the configuration, updated This is
213		* typically an academic department but could be for example the extended
214		* studies office that is responsible for delivering the course even though
215		* it's content is managed by an academic department.
216		*
217		* @name Units Deployment
218		* @impl initalized from canonical course units deployment but then stored
219		* in lui.unitsDeployment
220		*/
221		public List<String> getUnitsDeploymentOrgIds();
222
223		/**
224		* Organization(s) that is responsible for the academic content of the
225		* course as approved in its canonical form. This is the organization that
226		* has oversight of the curriculum. This is typically an academic
227		* department.
228		*
229		* @name Units Content Owner
230		* @readOnly on updates
231		* @impl this is never updatable so it should just be grabbed from the
232		* canonical course and then stored in lui.unitsContentOwner
233		*/
234		public List<String> getUnitsContentOwnerOrgIds();
235
236
237
238		/********* Waitlist ***************************/
239
240		/*
241		* TODO: Skip this section for core slice development
242		*/
243
244		/**
245		* Indicates whether a RegistrationGroup has a waitlist TODO: figure out how
246		* to store this TODO: make sure we are consistent on how we spell Waitlist,
247		* should be spelled Waitlist, or Wait List or Wait-List (as the
248		* merriam-webster has it)
249		*
250		* @name Has Waitlist
251		* @impl not sure how to store this, it depends on how we end up
252		* implementing waitlists.
253		*/
254		public Boolean getHasWaitlist();
255
256		/**
257		* Indicates the type of waitlist as it relates to processing students on
258		* and off The three types predefined in kuali are Automatic, Semi-Automatic
259		* and Manual TODO: Right not Waitlist types are not tied to any Waitlist
260		* object so we need to define an "other key" to get the list of valid
261		* values from the type service. TODO: Decide if we need a separate
262		* getHasWaitList, perhaps no value in this field means no waitlist. TODO:
263		* Cross validate with hasWaitlist
264		*
265		* @name Waitlist Type Key
266		* @impl TODO: decide if this this should be stored on the Lui or on a
267		* waitlist object?
268		*/
269		public String getWaitlistTypeKey();
270
271		/**
272		* Indicates the waitlist level, i.e., CourseOffering or ActivityOffering
273		*
274		* @name Waitlist Level Type Key
275		*/
276
277		public String getWaitlistLevelTypeKey();
278
279		/*********** Finances *************************/
280
281		/**
282		* The primary source of funding for the offering.
283		*
284		* @name Funding Source
285		* @impl fyi "funding source" is an enumeration values are state support,
286		* self-support, contract funding
287		*/
288		public String getFundingSource();
289
290		/**
291		* Flag indicating whether a course is eligible for Financial Aid. Derived
292		* from course catalog (canonical) TODO: find a place to store this on the
293		* canonical course because it does not currently exist there TODO: Decide
294		* if this is really a rule or a CluSet or what?
295		*
296		* @name Is Financial Aid Eligible
297		* @impl TODO: decide where to store
298		*/
299		public Boolean getIsFinancialAidEligible();
300
301		/**
302		* Is this Course Offering Financial aid eligible. (why is this
303		* here?) use getIsFinancialAidEligible().
304		*
305		* @name Financial Aid Eligible Flag
306		*/
307		@Deprecated
308		public Boolean getFinancialAidEligible();
309
310		/**
311		* Places where this Course offering is offered.
312		*
313		* @name Campus Locations
314		*/
315		public List<String> getCampusLocations();
316
317		/**
318		* Is this a Honors Course offering
319		*
320		* @name Honors Flag
321		*/
322		public Boolean getHonorsOffering();
323
324		/**
325		* Indicates the type of final exam ('STANDARD', 'ALTERNATE', 'NONE') to be given for this format Offering, if any
326		*
327		* @name Final Exam Type
328		*/
329		public String getFinalExamType();
330
331		/**
332		* Indicates whether the fee is at activity offering level or
333		* course offering level. If true its at Activity Offering level,
334		* if false its at CourseOffering level.
335		*
336		* @name Is Fee at Activity Offering
337		*/
338		public Boolean getIsFeeAtActivityOffering();
339
340		/**
341		* Indicates whether the course offering has an evaluation.
342		*
343		* @name Is Evaluated
344		*/
345		public Boolean getIsEvaluated();
346
347		/**
348		* Gets the Course Offering URL.
349		*
350		* @name Course Offering URL
351		*/
352		public String getCourseOfferingURL();
353		}