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
29 extends IdNamelessEntity {
30
31 /**
32 * A unique identifier assigned to all approved courses that exist
33 * in the catalog This is not updatable once initialized.
34 *
35 * @name Course Id
36 * @readOnly
37 * @required
38 * @impl this maps the the version dependent id as the offering
39 * must point to one and only one version of the
40 * course. Maps to cluId in Lui.
41 */
42 public String getCourseId();
43
44 /**
45 * Academic term of course offering
46 *
47 * @name Term Id
48 * @readOnly on updates
49 * @required
50 * @impl set during the #createCourseOffering and then maps to
51 * the aptKey on the Lui
52 */
53 public String getTermId();
54
55 /**
56 * Custom Description for the course Offering.
57 *
58 * @name Course Offering Description
59 */
60 public RichText getDescr();
61
62 /**
63 * Identifies the number of a course as reflected in the course
64 * catalog. This typically must be unique across all courses
65 * offered during that term. If the user wants to create two
66 * separate offerings for the same course they must modify this
67 * code to make it unique. For example: An on-line offering of the
68 * course might have an "O" appended to it to distinguish it from
69 * the face to face offering, i.e. ENG101 and ENG101O Initially
70 * copied from the course catalog but then, depending on the
71 * configuration it may be updatable. Often this field is
72 * configured so that it is not not directly updatable but rather
73 * is calculated from it's two constituent parts, the subject area
74 * and the course number suffix. For example: Subject Area = "ENG"
75 * and Suffix = "101" then code = "ENG101"
76 *
77 * This field is differentiated from the Couurse Offering Code in
78 * that the Course Offering Code can updated while the Course Code
79 * always indicates the official canonical code.
80 *
81 * @name Course Code
82 * @readOnly
83 * @impl this is a read only copy of the official canonical course code
84 */
85 public String getCourseCode();
86
87 /**
88 * Identifies the number of a course as reflected in the course
89 * catalog. This typically must be unique across all courses
90 * offered during that term. If the user wants to create two
91 * separate offerings for the same course they must modify this
92 * code to make it unique. For example: An on-line offering of the
93 * course might have an "O" appended to it to distinguish it from
94 * the face to face offering, i.e. ENG101 and ENG101O Initially
95 * copied from the course catalog but then, depending on the
96 * configuration it may be updatable. Often this field is
97 * configured so that it is not not directly updatable but rather
98 * is calculated from it's two constituent parts, the subject area
99 * and the course number suffix. For example: Subject Area = "ENG"
100 * and Suffix = "101" then code = "ENG101"
101 *
102 * @name Course Offering Code
103 * @impl initialially this is copied from the course catalog code but then
104 * is subsequently stored in the lui as lui.officialIdentifier.code
105 */
106 public String getCourseOfferingCode();
107
108 /**
109 * Identifies the department and/subject code of the course as
110 * reflected in the course catalog. Initially copied from the
111 * course catalog but then, depending on the configuration it may
112 * be updatable. In most configurations this should not be
113 * updatable. Often used in the calculation of the courseCode
114 *
115 * @name Subject Area
116 * @impl initially copied from the canonical course but then stored in the
117 * Lui as lui.officialIdentifier.division
118 */
119 public String getSubjectArea();
120
121 /**
122 * A suffix of the course number as reflected in the college
123 * catalog. This is the "number" portion of the course
124 * code. Initially copied from the course catalog but then,
125 * depending on the configuration it may be updatable. This field
126 * is often configured to be updatable but the updates typically
127 * simply append something like an "O" for on-line to it to
128 * differentiate multiple course offerings for the same
129 * course. Often used in the calculation of the courseCode.
130 *
131 * @name Course Number Suffix
132 * @impl initially copied from the canonical course but then stored in the
133 * Lui as lui.officialIdentifier.suffixCode
134 */
135 public String getCourseNumberSuffix();
136
137 /**
138 * Name of the course used in the college catalog. Initially
139 * copied from the course catalog but then, depending on the
140 * configuration it may be updatable. For regular courses this is
141 * not generally allowed to be updated on the offering, but for
142 * special topics courses this is often overridden to capture the
143 * particular topic being taught offered this term. Note: the
144 * configuration of the validation for titles is typically
145 * restricted to exclude line breaks. This may have to be loosened
146 * as some schools may want the particular topic to appear on a
147 * 2nd line. For example: SPECIAL TOPICS: AN EXPLORATION OF DEEP
148 * SPACE ARTIFACTS l
149 *
150 * @name Course Title
151 * @impl initially copied from the canonical course but then stored in the
152 * Lui as lui.officialIdentifier.longName
153 */
154 public String getCourseOfferingTitle();
155
156 /**
157 * Indicates that the entire course offering is an Honors Course
158 * ??? Is this an enrollment restriction rule or a flag or both?
159 *
160 * @name Is Honors Offering
161 * @impl store in a generic lui luCodes type of field?
162 */
163 public Boolean getIsHonorsOffering();
164
165 /**
166 * Total maximum number of "seats" or enrollment slots that can be
167 * filled for the offering. Calculated based on sum of all the
168 * maximum seats of primary activity type offerings.
169 *
170 * @name Maximum Enrollment
171 * @readOnly
172 * @impl maps to Lui.maximumEnrollment
173 */
174 public Integer getMaximumEnrollment();
175
176 /**
177 * Total minimum number of seats that must be filled for the
178 * offering not to be canceled. Calculated based on sum of all the
179 * minimum seats of primary activity type offerings
180 *
181 * @name Minimum Enrollment
182 * @impl maps to Lui.minimumEnrollment
183 */
184 public Integer getMinimumEnrollment();
185
186 /**
187 * The cross listings which this CourseOffering can be offered under.
188 */
189 public List<? extends CourseOfferingCrossListing> getCrossListings();
190
191
192 /******** Assessment Information ***************/
193
194 /**
195 * The options/scales that indicate the allowable grades within a
196 * grading scheme that can be awarded. Typically, the values here
197 * are constrained by the values on the canonical course. If the
198 * value is set here then the Clu must have a grading option set
199 * on the canonical activity. For example: an id might point to
200 * Pass/Fail or Letter Graded option.
201 *
202 * @name: Grading Option Id
203 * @impl Lui.resultOptionIds of type ???
204 */
205 public String getGradingOptionId();
206
207 /**
208 * The options/scales that indicate the allowable grades within a
209 * grading scheme in which an eligible student can register. This
210 * list of options includes the Grading Option Id plus any
211 * additional grading schemes, such as P/F or Audit.
212 *
213 * @name: registration Grading Option Ids
214 * @impl Lui.resultOptionIds of type ???
215 */
216 public List<String> getStudentRegistrationGradingOptions();
217
218 /**
219 * The name of the credit option
220 *
221 * @name Credit Option Name
222 * @readOnly
223 * @impl the name of the RVG for the creditOptionId
224 */
225 public String getCreditOptionName();
226
227 /**
228 * Type of credit of course offering. This field is initially
229 * copied from the canonical course but then, depending on
230 * configuration, it may be updated. TODO: figure out which of the
231 * credit options will be copied down because the canonical has
232 * more than one! Often it is just a fixed single value but a
233 * ResultValuesGroup could contain a range (with increments) or
234 * even a discrete list of possible credit values.
235 *
236 * @name Credit Option Id
237 * @impl Lui.resultOptionIds returns a list of
238 * resultOptions. Filter option with credit type and that
239 * should give the resultValueGroup.
240 */
241 public String getCreditOptionId();
242
243
244 /******** Personnel Information *****************/
245
246 /**
247 * Instructors for this course offering TODO: find out if the
248 * canonical instructors should be copied down
249 *
250 * @name Instructors
251 * @impl These are derived from Lui Person relations with instructor type
252 */
253 public List<? extends OfferingInstructor> getInstructors();
254
255 /********* Organization Information **************/
256
257 /**
258 * Organization(s) that is responsible for administering the
259 * course delivery - and all associated logistics - of the course
260 * Initially copied from the canonical course then, depending on
261 * the configuration, updated This is typically an academic
262 * department but could be for example the extended studies office
263 * that is responsible for delivering the course even though it's
264 * content is managed by an academic department.
265 *
266 * @name Units Deployment
267 * @impl initalized from canonical course units deployment but then stored
268 * in lui.unitsDeployment
269 */
270 public List<String> getUnitsDeploymentOrgIds();
271
272 /**
273 * Organization(s) that is responsible for the academic content of
274 * the course as approved in its canonical form. This is the
275 * organization that has oversight of the curriculum. This is
276 * typically an academic department.
277 *
278 * @name Units Content Owner
279 * @readOnly on updates
280 * @impl this is never updatable so it should just be grabbed from
281 * the canonical course and then stored in
282 * lui.unitsContentOwner
283 */
284 public List<String> getUnitsContentOwnerOrgIds();
285
286
287
288 /*********** Waitlist *****************************/
289
290 /*
291 * TODO: Skip this section for core slice development
292 * If keeping, These should be moved into FormatOffering and
293 * removed from CourseOffering.
294 */
295
296 /**
297 * Indicates whether a RegistrationGroup has a waitlist TODO:
298 * figure out how to store this TODO: make sure we are consistent
299 * on how we spell Waitlist, should be spelled Waitlist, or Wait
300 * List or Wait-List (as the merriam-webster has it)
301 *
302 * @name Has Waitlist
303 * @impl not sure how to store this, it depends on how we end up
304 * implementing waitlists.
305 * @deprecated Use the CourseWaitList service instead.
306 */
307 @Deprecated
308 public Boolean getHasWaitlist();
309
310 /**
311 * Indicates the type of waitlist as it relates to processing
312 * students on and off The three types predefined in kuali are
313 * Automatic, Semi-Automatic and Manual TODO: Right not Waitlist
314 * types are not tied to any Waitlist object so we need to define
315 * an "other key" to get the list of valid values from the type
316 * service. TODO: Decide if we need a separate getHasWaitList,
317 * perhaps no value in this field means no waitlist. TODO: Cross
318 * validate with hasWaitlist
319 *
320 * @name Waitlist Type Key
321 * @impl TODO: decide if this this should be stored on the Lui or on a
322 * waitlist object?
323 * @deprecated Use the CourseWaitList service instead.
324 */
325 @Deprecated
326 public String getWaitlistTypeKey();
327
328 /**
329 * Indicates the waitlist level, i.e., CourseOffering or
330 * ActivityOffering. Values are in WaitListLevel enum.
331 *
332 * @name Waitlist Level Type Key
333 * @deprecated Use the CourseWaitList service instead.
334 */
335 @Deprecated
336 public String getWaitlistLevelTypeKey();
337
338 /**
339 * Maximum number of students to be allowed on the wait list.
340 *
341 * @name Waitlist Maximum
342 * @impl maps to Lui.waitlistMaximum
343 * @deprecated Use the CourseWaitList service instead.
344 */
345 @Deprecated
346 public Integer getWaitlistMaximum();
347
348
349 /************* Finances ***************************/
350
351 /**
352 * The primary source of funding for the offering.
353 *
354 * @name Funding Source
355 * @impl fyi "funding source" is an enumeration values are state support,
356 * self-support, contract funding
357 */
358 public String getFundingSource();
359
360 /**
361 * Flag indicating whether a course is eligible for Financial
362 * Aid. Derived from course catalog (canonical) TODO: find a place
363 * to store this on the canonical course because it does not
364 * currently exist there TODO: Decide if this is really a rule or
365 * a CluSet or what?
366 *
367 * @name Is Financial Aid Eligible
368 * @impl TODO: decide where to store
369 */
370 public Boolean getIsFinancialAidEligible();
371
372 /**
373 * Places where this Course offering is offered.
374 *
375 * @name Campus Locations
376 */
377 public List<String> getCampusLocations();
378
379 /**
380 * Indicates whether a final exam is to be given for this format
381 * Offering and if its true, the level at which it exists
382 * Indicates the type of final exam ('STANDARD', 'ALTERNATE',
383 * 'NONE') to be given for this format Offering, if any
384 *
385 * @name Final ExamOffering Type
386 */
387 public String getFinalExamType();
388
389 /**
390 * Indicates whether the fee is at activity offering level or
391 * course offering level. If true its at Activity Offering level,
392 * if false its at CourseOffering level.
393 *
394 * @name Is Fee at Activity Offering
395 */
396 public Boolean getIsFeeAtActivityOffering();
397
398 /**
399 * Indicates whether the course offering has an evaluation.
400 *
401 * @name Is Evaluated
402 */
403 public Boolean getIsEvaluated();
404
405 /**
406 * Gets the Course Offering URL.
407 *
408 * @name Course Offering URL
409 */
410 public String getCourseOfferingURL();
411
412 /**
413 * Gets the Credit Count
414 *
415 * @name Credit Count
416 * @readOnly
417 * @impl this is the number of credits
418 */
419 public String getCreditCnt();
420
421 /**
422 * Gets the Grading Option Name
423 *
424 * @name Grading Option Name
425 * @readOnly
426 * @impl this is the name of the RVG matching the gradingOptionId
427 */
428 public String getGradingOptionName();
429
430 /**
431 * A suffix is the system generated code that is hidden from the
432 * user that parallels with courseOfferingNumberSuffix.
433 *
434 * @name Course Number Internal Suffix
435 * @impl initially copied from the canonical course but then
436 * stored in the Lui as lui.officialIdentifier.suffixCode
437 */
438 public String getCourseNumberInternalSuffix();
439 }