private void AddCourseOffering(object sender, RoutedEventArgs e)
{
FormOffering.CourseId = Course.Id;
db.AddCourseOffering(FormOffering);
FormOffering = new CourseOffering();
LoadOfferings();
}
public static List <Student> getStudentsFromOffering(CourseOffering courseOffering)
{
string selectSQL = "SELECT s.StudentNum, s.Name, s.Type FROM Student s "
+ "JOIN Registration r ON s.StudentNum = r.Student_StudentNum "
+ "WHERE r.CourseOffering_Course_CourseID=@courseID "
+ " AND r.CourseOffering_Year = @year "
+ " AND r.CourseOffering_Semester = @Semester";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand command = new SqlCommand(selectSQL, connection);
command.Parameters.AddWithValue("@courseID", courseOffering.CourseOffered.CourseNumber);
command.Parameters.AddWithValue("@year", courseOffering.Year.ToString());
command.Parameters.AddWithValue("@Semester", courseOffering.Semester);
SqlDataReader reader = null;
List <Student> studentsInOffering = new List <Student>();
try
{
connection.Open();
reader = command.ExecuteReader();
if (reader != null && reader.HasRows)
{
while (reader.Read())
{
string studentNumber = (string)reader["StudentNum"];
string studentName = (string)reader["Name"];
string type = (string)reader["Type"];
if (type == "Full Time")
{
Student ourStudent = new FullTimeStudent(studentNumber, studentName);
studentsInOffering.Add(ourStudent);
}
if (type == "Part Time")
{
Student ourStudent = new PartTimeStudent(studentNumber, studentName);
studentsInOffering.Add(ourStudent);
}
else
{
Student ourStudent = new CoopStudent(studentNumber, studentName);
studentsInOffering.Add(ourStudent);
}
}
}
}
catch (Exception e)
{
throw e;
}
finally
{
connection.Close();
}
return(studentsInOffering);
}
public static void addRegistration(Student student, CourseOffering courseOffering)
{
string insertRegistrationSQL = "INSERT INTO Registration " + "(Student_StudentNum, CourseOffering_Course_CourseID, CourseOffering_Year, CourseOffering_Semester) " + "VALUES (@studentNum, @courseID, @year, @semester)";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand sqlCourseCommand = new SqlCommand(insertRegistrationSQL, connection);
string type = StudentType.getStudentType(student);
sqlCourseCommand.Parameters.AddWithValue("@studentNum", student.Number);
sqlCourseCommand.Parameters.AddWithValue("@courseID", courseOffering.CourseOffered.CourseNumber);
sqlCourseCommand.Parameters.AddWithValue("@year", courseOffering.Year);
sqlCourseCommand.Parameters.AddWithValue("@semester", courseOffering.Semester);
int added = 0;
try
{
connection.Open();
added = sqlCourseCommand.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
connection.Close();
}
}
public List <CourseOffering> getCourseOfferingsBySemester(String semester)
{
List <CourseOffering> theOfferings = repo.Offerings;
List <CourseOffering> courseOfferingsThatMeetSemester = new List <CourseOffering>();
CourseOffering theGoal = null;
foreach (CourseOffering f in theOfferings)
{
if (f.Semester.Equals(semester))
{
theGoal = f;
courseOfferingsThatMeetSemester.Add(theGoal);
break;
}
}
if (theGoal == null)
{
throw new Exception("Didn't find any offerings for this semester");
}
return(courseOfferingsThatMeetSemester);
}
public static void addNewCourseOffering(CourseOffering courseOffering)
{
string insertCourseOfferingSQL = "INSERT INTO CourseOffering (Year, Semester, Course_CourseID) VALUES (@year, @Semester, @courseID)";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand sqlCourseCommand = new SqlCommand(insertCourseOfferingSQL, connection);
sqlCourseCommand.Parameters.AddWithValue("@year", courseOffering.Year);
sqlCourseCommand.Parameters.AddWithValue("@Semester", courseOffering.Semester);
sqlCourseCommand.Parameters.AddWithValue("@courseID", courseOffering.CourseOffered.CourseNumber);
int added = 0;
try
{
connection.Open();
added = sqlCourseCommand.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
connection.Close();
}
}
private void AddCourseOfferingChanges(CourseOffering courseOffering, string changeType)
{
string userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
ApplicationUser appUser = database.Users.Find(userID);
CourseOfferingChanges offeringChanges = new CourseOfferingChanges();
if (User.IsInRole("Chair"))
{ offeringChanges.ChangerRole = "Chair"; }
else
{ offeringChanges.ChangerRole = "Coordinator"; }
offeringChanges.ChangeType = changeType;
offeringChanges.CourseID = courseOffering.CourseID;
offeringChanges.CRN = courseOffering.CRN;
offeringChanges.DateAndTimeOfChange = PopulateGetDateViewModel();
offeringChanges.Days = courseOffering.Days;
offeringChanges.EndDate = courseOffering.EndDate;
offeringChanges.EndTime = courseOffering.EndTime;
offeringChanges.InstructorID = courseOffering.InstructorID;
offeringChanges.ChangerName = appUser.LastName;
offeringChanges.StartDate = courseOffering.StartDate;
offeringChanges.StartTime = courseOffering.StartTime;
database.CoursesOfferingsChanges.Add(offeringChanges);
database.SaveChanges();
}
public List <CourseOffering> GetOfferingsByDepartmnet(string departmentName)
{
List <CourseOffering> offerings = new List <CourseOffering>();
String sql = "SELECT courseofferings.* FROM courseofferings,courses where courseofferings.c_id = courses.c_id AND courses.dep_name = @dep_name";
MySqlCommand cmd = new MySqlCommand(sql, Connection);
cmd.Parameters.AddWithValue("@dep_name", departmentName);
MySqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
CourseOffering offering = new CourseOffering();
offering.CourseId = rdr["c_id"].ToString();
offering.Semster = rdr["semster"].ToString();
offerings.Add(offering);
}
rdr.Close();
return(offerings);
}
public static int AddNewCourseOffering(CourseOffering courseOffering)
{
if (!checkCourseOffering(courseOffering))
{
//Define ADO.NET objects
string insertCourseOfferingSQL = "INSERT INTO CourseOffering(Course_CourseID, Year, Semester) VALUES (@Course_CourseID, @Year, @Semester)";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand sqlCourseCmd = new SqlCommand(insertCourseOfferingSQL, connection);
// Add the parameters
sqlCourseCmd.Parameters.AddWithValue("@Course_CourseID", courseOffering.CourseOffered.CourseNumber);
sqlCourseCmd.Parameters.AddWithValue("@Year", courseOffering.Year);
sqlCourseCmd.Parameters.AddWithValue("@Semester", courseOffering.Semester);
// Try to open the database and execute the update
int added = 0;
try
{
connection.Open();
added = sqlCourseCmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
connection.Close();
}
return(added);
}
return(0);
}
public static int AddNewRegistration(CourseOffering courseOffering, Student student)
{
// Define ADO.NET Objects
string insertRegistrationSQL =
"INSERT INTO Registration"
+ "(Student_StudentNum, CourseOffering_Course_CourseID, CourseOffering_Year, CourseOffering_Semester)"
+ "VALUES (@studentNum, @courseID, @year,@semester)";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand sqlInsertRegistrationCmd = new SqlCommand(insertRegistrationSQL, connection);
// Add the parameters
sqlInsertRegistrationCmd.Parameters.AddWithValue("@studentNum", student.Number);
sqlInsertRegistrationCmd.Parameters.AddWithValue("@courseID", courseOffering.CourseOffered.courseNumber);
sqlInsertRegistrationCmd.Parameters.AddWithValue("@year", courseOffering.Year);
sqlInsertRegistrationCmd.Parameters.AddWithValue("@semester", courseOffering.Semester);
//Try to open the database and execute the update
int added = 0;
try
{
connection.Open();
added = sqlInsertRegistrationCmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
connection.Close();
}
return(added);
}
public List <CourseOffering> GetCourseOfferingsByInstructor(Instructor instructor)
{
List <CourseOffering> offerings = new List <CourseOffering>();
String sql = "SELECT courseofferings.* FROM courseofferings,teaches where courseofferings.c_id = teaches.c_id AND courseofferings.semster = teaches.semster AND teaches.ins_id = @ins_id";
MySqlCommand cmd = new MySqlCommand(sql, Connection);
cmd.Parameters.AddWithValue("@ins_id", instructor.Id);
MySqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
CourseOffering offering = new CourseOffering();
offering.CourseId = rdr["c_id"].ToString();
offering.Semster = rdr["semster"].ToString();
offerings.Add(offering);
}
rdr.Close();
return(offerings);
}
public async Task Post_Existing_CourseOffering()
{
var offeringId = "1111";
var userId = "13";
var courseId = "0001";
SetupEntities(offeringId, userId, new List <string> {
courseId
});
var courseOffering = new CourseOffering
{
CourseId = courseId,
OfferingId = offeringId
};
var postResult = await _controller.PostCourseOffering(courseOffering);
Assert.IsType <OkResult>(postResult.Result);
postResult = await _controller.PostCourseOffering(courseOffering);
Assert.IsType <OkObjectResult>(postResult.Result);
var getResult = await _controller.GetCourseOfferingsByInstructor(userId);
List <CourseOfferingsController.CourseOfferingDTO> courseOfferingDTOs = getResult.Value.ToList();
Assert.Single(courseOfferingDTOs);
Assert.Single(courseOfferingDTOs[0].Offerings);
Assert.Equal(courseOffering.OfferingId, courseOfferingDTOs[0].Offerings[0].Id);
Assert.Equal(courseOffering.CourseId, courseOfferingDTOs[0].Course.Id);
}
/// <summary>
/// Updates or creates a resource based on the resource identifier. The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database. If the resource "id" is provided in the JSON body, it will be ignored as well.
/// </summary>
/// <param name="id">A resource identifier specifying the resource to be updated.</param>
/// <param name="IfMatch">The ETag header value used to prevent the PUT from updating a resource modified by another consumer.</param>
/// <param name="body">The JSON representation of the "courseOffering" resource to be updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PutCourseOffering(string id, string IfMatch, CourseOffering body)
{
var request = new RestRequest("/courseOfferings/{id}", Method.PUT);
request.RequestFormat = DataFormat.Json;
request.AddUrlSegment("id", id);
// verify required params are set
if (id == null || body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddHeader("If-Match", IfMatch);
request.AddBody(body);
request.Parameters.First(param => param.Type == ParameterType.RequestBody).Name = "application/json";
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
private void btnAdd_Click(object sender, EventArgs e)
{
try
{
Course course = cbSelectCourse.SelectedItem as Course;
var courseOffering = new CourseOffering
{
CourseID = course.CourseId,
CourseTitle = course.Title,
Course = course
};
var added = courseOfferingsCRUD.AddCourseOffering(courseOffering);
if (added)
{
MessageBox.Show("Course offered successfully.");
UpdateDGVcourseOfferings();
}
else
{
MessageBox.Show("Error while offering the course!");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private Room GetRoom(CourseOffering courseOffering, int typeId)
{
return(courseOffering.Rooms
.Where(r => r.TypeId == typeId)
.FirstOrDefault()
.Room);
}
private Instructor GetInstructor(CourseOffering courseOffering, int typeId)
{
return(courseOffering.Instructors
.Where(i => i.TypeId == typeId)
.FirstOrDefault()
.Instructor);
}
public ActionResult DeleteConfirmed(int id)
{
CourseOffering courseOffering = db.CourseOfferings.Find(id);
db.CourseOfferings.Remove(courseOffering);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void UpdateCourse(CourseOffering course)
{
using (var db = new LiteDatabase(Connection))
{
var courses = db.GetCollection <CourseOffering>();
courses.Update(course);
}
}
public IActionResult EditCourseOffering(int? id)
{
CourseOffering courseOffering = database.CourseOfferings.Find(id);
PopulateDropDownList();
return View(courseOffering);
}
private void LoadHours(CourseOffering offering)
{
_currentEditingOffering = offering;
Hours.Clear();
foreach (var classHour in db.GetHours().FindAll(hour => hour.CourseId == offering.CourseId && hour.Semster.Equals(offering.Semster)))
{
Hours.Add(classHour);
}
}
public static CourseOffering FindCourse(CourseOffering searchCourse)
{
using (var db = new LiteDatabase(Connection))
{
var courses = db.GetCollection <CourseOffering>();
var results = courses.Find(x => x.CourseNumber == searchCourse.CourseNumber && x.Term.TermId == searchCourse.Term.TermId && x.Section == searchCourse.Section).SingleOrDefault();
return(results);
}
}
public ActionResult Save(CourseOffering courseOffering)
{
var courseOfferingInDb = _context.CourseOfferings.Single(c => c.Id == courseOffering.Id);
courseOfferingInDb.InstructorId = courseOffering.InstructorId;
_context.SaveChanges();
return(RedirectToAction("Index", "CourseOfferings"));
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
var t = new CourseOffering();
var tc = new ItemController();
if (ItemId > 0)
{
t = tc.GetItem(ItemId, ModuleId);
t.CourseTerm = txtCourseTerm.Text.Trim();
t.CourseNumber = ddlTargetCourseID.SelectedItem.Text;
t.SectionID = txtCourseTerm.Text.Trim();
t.InstructorID = Convert.ToInt32(ddlAssignedInstructor.SelectedValue);
t.SectionDates = txtSectionDates.Text.Trim();
t.SectionNote = txtSectionNotes.Text.Trim();
t.SectionClosedDate = calSectionClosedDate.SelectedDate;
t.SectionSize = Convert.ToInt32(txtSectionSize.Text.Trim());
t.SectionSupplies = txtSectionSupplies.Text.Trim();
t.SectionSuppliesFee = Convert.ToInt32(txtSectionSuppliesFee.Text.Trim());
t.LastModifiedByUserId = UserId;
t.LastModifiedOnDate = DateTime.Now;
t.AssignedUserId = Convert.ToInt32(ddlTargetCourseID.SelectedValue);
}
else //insert new
{
t = new CourseOffering()
{
AssignedUserId = Convert.ToInt32(ddlTargetCourseID.SelectedValue),
CreatedByUserId = UserId,
CreatedOnDate = DateTime.Now,
CourseTerm = txtCourseTerm.Text.Trim(),
CourseNumber = ddlTargetCourseID.SelectedItem.Text,
SectionID = txtCourseSection.Text.Trim(),
InstructorID = Convert.ToInt32(ddlAssignedInstructor.SelectedValue),
SectionDates = txtSectionDates.Text.Trim(),
SectionNote = txtSectionNotes.Text.Trim(),
SectionClosedDate = calSectionClosedDate.SelectedDate,
SectionSize = Convert.ToInt32(txtSectionSize.Text.Trim()),
SectionSupplies = txtSectionSupplies.Text.Trim(),
SectionSuppliesFee = Convert.ToInt32(txtSectionSuppliesFee.Text.Trim())
};
}
t.LastModifiedOnDate = DateTime.Now;
t.LastModifiedByUserId = UserId;
t.ModuleId = ModuleId;
if (t.Id > 0)
{
tc.UpdateItem(t);
}
else
{
tc.CreateItem(t);
}
Response.Redirect(DotNetNuke.Common.Globals.NavigateURL());
}
public IActionResult DeleteCourseOffering(int?id)
{
CourseOffering courseOffering = database.CourseOfferings.Find(id);
database.CourseOfferings.Remove(courseOffering);
database.SaveChanges();
AddCourseOfferingChangesChanges(courseOffering, "Delete");
return(RedirectToAction("SearchCourseOfferings"));
}
public IActionResult Create([FromBody] CourseOffering courseOffering)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_service.Add(courseOffering);
return(Ok(courseOffering));
}
public static List <CourseOffering> GetRegisteredCourseOfferingsByStudent(Student student)
{
// Define ADO.NET objects
string selectSQL = "SELECT c.CourseID, c.CourseTitle, c.HoursPerWeek r.CourseOffering_Year r.CourseOffering_Semester"
+ "FROM Course c"
+ "JOIN Registration r ON c.CourseID = r.CourseOffering_Course_CourseID"
+ "WHERE r.Student_StudentNum = @studentNumber";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand SqlCoursecommand = new SqlCommand(selectSQL, connection);
// Add the parameters
SqlCoursecommand.Parameters.AddWithValue("@StudentNumber", student);
SqlDataReader reader = null;
List <CourseOffering> coursesOfferings = new List <CourseOffering>();
try
{
connection.Open();
reader = SqlCoursecommand.ExecuteReader();
if (reader != null && reader.HasRows)
{
while (reader.Read())
{
string courseID = (string)reader["CourseID"];
int courseTitle = (int)reader["CourseTitle"];
int hourPerWeek = (int)reader["HoursPerWeek"];
Course course = new Course(courseID, courseTitle.ToString(), hourPerWeek);
int year = (int)reader["CourseOffering_Year"];
string semester = (string)reader["CourseOffering_Semester"];
CourseOffering courseOffering = new CourseOffering(course, year, semester);
coursesOfferings.Add(courseOffering);
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
connection.Close();
}
return(coursesOfferings);
}
public ActionResult Edit([Bind(Include = "CourseOfferingId,CourseId,CRN,WeekDays,NumberOfOpennings")] CourseOffering courseOffering)
{
if (ModelState.IsValid)
{
db.Entry(courseOffering).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "CourseNumber", courseOffering.CourseId);
return(View(courseOffering));
}
public IActionResult EditCourseOffering([Bind("CourseOfferingID, CRN, Days, StartTIme, EndTime, StartDate, EndDate, InstructorID, CourseID")]CourseOffering courseOffering)
{
database.CourseOfferings.Update(courseOffering);
database.SaveChanges();
AddCourseOfferingChanges(courseOffering, "Edit");
return RedirectToAction("SearchCourseOfferings");
}
public IActionResult Update([FromBody] CourseOffering courseOffering, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
courseOffering.Id = id;
_service.Update(courseOffering);
return(Ok(courseOffering));
}
protected void btnAddCourseOffering_Click(object sender, EventArgs e)
{
string courseId = drpCourseOfferingList.SelectedValue;
int year = int.Parse(drpOfferInYr.SelectedValue);
string semester = drpSemester.SelectedValue;
Course course = CourseDataAccess.RetrieveCourseByCourseId(courseId);
CourseOffering courseOffering = new CourseOffering(course, year, semester);
CourseOfferingDataAccess.AddNewCourseOffering(courseOffering);
}
public TestEnrollmentRepository()
{
_courseOfferings = new List <CourseOffering>();
_studentEnrollments = new Dictionary <int, Dictionary <int, CourseEnrollment> >();
_terms = new Dictionary <int, DateTime>();
#region Preparing Test Data
// Course offerings
for (int i = 0; i < 5; ++i)
{
int id = i + 1;
var co = new CourseOffering
{
Course = "Course " + id,
CourseInfo = "Course info " + id,
RegistrationMessage = "Available",
};
_courseOfferings.Add(co);
}
_courseOfferings[0].Term = DateTime.Parse("2006-07-27 00:00:00.000");
_courseOfferings[1].Course = "Course 1";
_courseOfferings[1].Term = DateTime.Parse("2007-02-26 00:00:00.000");
_courseOfferings[2].Term = DateTime.Parse("2009-01-02 00:00:00.000");
_courseOfferings[3].Term = DateTime.Parse("2007-01-02 00:00:00.000");
_courseOfferings[4].Term = DateTime.Parse("2006-01-03 00:00:00.000");
// Student enrollments
var entry = new CourseEnrollment
{
CourseOfferingNo = 439,
ImportDate = DateTime.Now,
GradeNo = 109,
ImportConversion = "Student Portal",
StatusId = 1,
StudentId = 1
};
var courseEnrollment = new Dictionary <int, CourseEnrollment>();
courseEnrollment.Add(entry.CourseOfferingNo, entry);
_studentEnrollments.Add(entry.StudentId, courseEnrollment);
_terms.Add(1, DateTime.Parse("2006-01-03 00:00:00.000"));
_terms.Add(2, DateTime.Parse("2006-07-27 00:00:00.000"));
_terms.Add(3, DateTime.Parse("2007-01-02 00:00:00.000"));
_terms.Add(4, DateTime.Parse("2007-02-26 00:00:00.000"));
_terms.Add(5, DateTime.Parse("2009-01-02 00:00:00.000"));
#endregion
}
public static List<CourseOffering> getAllCourseOfferings()
{
List<CourseOffering> offeredCourses = new List<CourseOffering>();
try
{
connection.Open();
string getCourseOfferings = "select * from CourseOffering";
SqlCommand getCO = new SqlCommand(getCourseOfferings, connection);
rdr2 = getCO.ExecuteReader();
while (rdr2.Read())
{
int year = (int)rdr2["Year"];
string semester = (string)rdr2["Semester"];
Course c = getCourseById((string)rdr2["Course_CourseID"]);
CourseOffering co = new CourseOffering(c, year, semester);
offeredCourses.Add(co);
}
}
catch (Exception err)
{
var page = (Page)HttpContext.Current.Handler;
page.Title = err.Message + " 1";
}
finally
{
if (rdr2 != null)
{
rdr2.Close();
}
connection.Close();
}
//offeredCourses.Sort(new CourseSorter().Compare);
return offeredCourses;
}
protected void submitCourseOffering_OnClick(object sender, EventArgs e)
{
try
{
connection.Open();
string insertCourseSQL = "INSERT INTO Course (CourseID, CourseTitle, HoursPerWeek) VALUES (@courseID, @courseTitle, @courseHours)";
string insertCourseOfferingSQL = "INSERT INTO CourseOffering (Year, Semester, Course_CourseID) VALUES (@year, @Semester, @courseID)";
//add the course to course table
SqlCommand cmdAddCourse = new SqlCommand(insertCourseSQL, connection);
cmdAddCourse.Parameters.AddWithValue("@courseID", courseNumber.Text);
cmdAddCourse.Parameters.AddWithValue("@courseTitle", courseName.Text);
cmdAddCourse.Parameters.AddWithValue("@courseHours", wklyHours.Text);
cmdAddCourse.ExecuteNonQuery();
Course course = new Course(courseNumber.Text, courseName.Text, Convert.ToInt32(wklyHours.Text));
//add the course to CourseOffering table
SqlCommand cmdAddCourseOffering = new SqlCommand(insertCourseOfferingSQL, connection);
cmdAddCourseOffering.Parameters.AddWithValue("@year", drpdnYear.SelectedValue);
cmdAddCourseOffering.Parameters.AddWithValue("@Semester", drpdnSemester.SelectedValue);
cmdAddCourseOffering.Parameters.AddWithValue("@courseTitle", courseName.Text);
cmdAddCourseOffering.Parameters.AddWithValue("@courseID", courseNumber.Text);
cmdAddCourseOffering.ExecuteNonQuery();
CourseOffering offering = new CourseOffering(course, Convert.ToInt32(drpdnYear.SelectedValue),drpdnSemester.SelectedValue);
Session["offering"] = offering;
}
catch (Exception err)
{
Title = err.Message;
}
finally
{
if (rdr != null)
{
rdr.Close();
}
connection.Close();
pnlCourseCreation.Visible = false;
pnlStudentRegistration.Visible = true;
}
}
public static CourseOffering getCourseOfferingByID(Course c)
{
CourseOffering courseOffered = null;
int year = 0;
string semester = null;
try
{
connection.Open();
string selectCoursesSQL = "SELECT * FROM CourseOffering WHERE Course_CourseID = @courseID";
SqlCommand getCourse = new SqlCommand(selectCoursesSQL, connection);
getCourse.Parameters.AddWithValue("@courseID", c.CourseNumber);
rdr = getCourse.ExecuteReader();
while (rdr.Read())
{
year = (int)rdr["Year"];
semester = (string)rdr["Semester"];
}
courseOffered = new CourseOffering(c, year,semester);
}
catch (Exception err)
{
}
finally
{
if (rdr != null)
{
rdr.Close();
}
connection.Close();
}
return courseOffered;
}
