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 */
293
294 /**
295 * Indicates whether a RegistrationGroup has a waitlist TODO:
296 * figure out how to store this TODO: make sure we are consistent
297 * on how we spell Waitlist, should be spelled Waitlist, or Wait
298 * List or Wait-List (as the merriam-webster has it)
299 *
300 * @name Has Waitlist
301 * @impl not sure how to store this, it depends on how we end up
302 * implementing waitlists.
303 */
304 public Boolean getHasWaitlist();
305
306 /**
307 * Indicates the type of waitlist as it relates to processing
308 * students on and off The three types predefined in kuali are
309 * Automatic, Semi-Automatic and Manual TODO: Right not Waitlist
310 * types are not tied to any Waitlist object so we need to define
311 * an "other key" to get the list of valid values from the type
312 * service. TODO: Decide if we need a separate getHasWaitList,
313 * perhaps no value in this field means no waitlist. TODO: Cross
314 * validate with hasWaitlist
315 *
316 * @name Waitlist Type Key
317 * @impl TODO: decide if this this should be stored on the Lui or on a
318 * waitlist object?
319 */
320 public String getWaitlistTypeKey();
321
322 /**
323 * Indicates the waitlist level, i.e., CourseOffering or
324 * ActivityOffering. Values are in WaitListLevel enum.
325 *
326 * @name Waitlist Level Type Key
327 */
328 public String getWaitlistLevelTypeKey();
329
330 /**
331 * Maximum number of students to be allowed on the wait list.
332 *
333 * @name Waitlist Maximum
334 * @impl maps to Lui.waitlistMaximum
335 */
336 public Integer getWaitlistMaximum();
337
338
339 /************* Finances ***************************/
340
341 /**
342 * The primary source of funding for the offering.
343 *
344 * @name Funding Source
345 * @impl fyi "funding source" is an enumeration values are state support,
346 * self-support, contract funding
347 */
348 public String getFundingSource();
349
350 /**
351 * Flag indicating whether a course is eligible for Financial
352 * Aid. Derived from course catalog (canonical) TODO: find a place
353 * to store this on the canonical course because it does not
354 * currently exist there TODO: Decide if this is really a rule or
355 * a CluSet or what?
356 *
357 * @name Is Financial Aid Eligible
358 * @impl TODO: decide where to store
359 */
360 public Boolean getIsFinancialAidEligible();
361
362 /**
363 * Places where this Course offering is offered.
364 *
365 * @name Campus Locations
366 */
367 public List<String> getCampusLocations();
368
369 /**
370 * Indicates whether a final exam is to be given for this format
371 * Offering and if its true, the level at which it exists
372 * Indicates the type of final exam ('STANDARD', 'ALTERNATE',
373 * 'NONE') to be given for this format Offering, if any
374 *
375 * @name Final Exam Type
376 */
377 public String getFinalExamType();
378
379 /**
380 * Indicates whether the fee is at activity offering level or
381 * course offering level. If true its at Activity Offering level,
382 * if false its at CourseOffering level.
383 *
384 * @name Is Fee at Activity Offering
385 */
386 public Boolean getIsFeeAtActivityOffering();
387
388 /**
389 * Indicates whether the course offering has an evaluation.
390 *
391 * @name Is Evaluated
392 */
393 public Boolean getIsEvaluated();
394
395 /**
396 * Gets the Course Offering URL.
397 *
398 * @name Course Offering URL
399 */
400 public String getCourseOfferingURL();
401
402 /**
403 * Gets the Credit Count
404 *
405 * @name Credit Count
406 * @readOnly
407 * @impl this is the number of credits
408 */
409 public String getCreditCnt();
410
411 /**
412 * Gets the Grading Option Name
413 *
414 * @name Grading Option Name
415 * @readOnly
416 * @impl this is the name of the RVG matching the gradingOptionId
417 */
418 public String getGradingOptionName();
419
420 /**
421 * A suffix is the system generated code that is hidden from the
422 * user that parallels with courseOfferingNumberSuffix.
423 *
424 * @name Course Number Internal Suffix
425 * @impl initially copied from the canonical course but then
426 * stored in the Lui as lui.officialIdentifier.suffixCode
427 */
428 public String getCourseNumberInternalSuffix();
429 }