public ScheduledCourse(Course course, Semester semester, int year, DegreeRequirement req = null)
{
Semester = semester;
Course = course;
Year = year;
Requirement = req;
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request.HttpMethod == "POST")
{
Semester newTerm = new Semester
{
SchoolYear = Request.Form["SchoolYear"],
Season = Request.Form["Season"],
};
LabDB.Semester.InsertOnSubmit(newTerm);
try
{
LabDB.SubmitChanges();
}
catch (Exception ex)
{
Response.Write("<script type=\"text/javascript\"> alert('添加数据时发生错误！请重试或联系管理员！');</script>");
return;
}
Response.Write("<script type=\"text/javascript\"> alert('添加成功！');</script>");
Response.Write("<script type=\"text/javascript\"> window.location='ExperimentManage.aspx'</script>");
}
}
public ActionResult Create(Semester semester)
{
if (ModelState.IsValid)
{
db.Semesters.Add(semester);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(semester);
}
public void InsertOrUpdate(Semester semester)
{
if (semester.SemesterId == default(int))
{
// New entity
context.Semesters.Add(semester);
}
else
{
// Existing entity
context.Entry(semester).State = EntityState.Modified;
}
}
public PrescheduleViewer(IEnumerable <Course> courses, List <Course> prescheduledCourses,
List <Semester> semesterList, Dictionary <Semester, List <Course> > allPrescheduledCourses,
Semester semester, List <Course> completedCourses) :
base(new List <Course>(courses), prescheduledCourses)
{
List <Course> test = new List <Course>();
InitializeComponent();
//set variables
this.semesterList = semesterList;
this.allPrescheduledCourses = allPrescheduledCourses;
this.semester = semester;
this.completedCourses = completedCourses;
//modify form
this.upButton.Visible = false;
this.downButton.Visible = false;
this.Name = "Schedule Semester";
//remove already scheduled courses
foreach (List <Course> coursesInSem in allPrescheduledCourses.Values)
{
foreach (Course cou in coursesInSem)
{
_nonPrioritizedItems.Remove(cou);
}
}
//add current semester back in
foreach (Course cou in prescheduledCourses)
{
_nonPrioritizedItems.Add(cou);
}
//update lists
base.updateLists(_nonPrioritizedItems, _priorityList);
}
public async Task<List<SemesterUpdate>> Create(List<SemesterCreate> models)
{
var semesters = models.Select(_ =>
{
var semester = new Semester { };
UpdateValues(semester, _);
Validate(semester);
return semester;
});
await context.Semester.AddRangeAsync(semesters);
await context.SaveChangesAsync();
return semesters.Select(_ => new SemesterUpdate
{
Id = _.Id,
StartDate = _.StartDate,
EndDate = _.EndDate,
IsWinter = _.IsWinter
}).ToList();
}
public ICommandResult Handle(Command command)
{
if (string.IsNullOrWhiteSpace(command.Major) || command.Major.Length < 3)
{
return(CommandResult.Failed("Major has to have minimum length of 3 letters"));
}
if (command.FinishedOn == null || command.FinishedOn.Value.Date <= DateTime.Now)
{
return(CommandResult.Failed("Finished date must be in future"));
}
var semester = new Semester {
CreatedOn = DateTime.Now,
Major = command.Major,
FinishedOn = command.FinishedOn.Value,
};
_dbContext.Semesters.Add(semester);
_dbContext.SaveChanges();
return(CommandResult.Success());
}
public bool PutSemester(SemesterEnum id, Semester semester)
{
if (id != semester.Name)
{
return(false);
}
Semester checkSemester = db.SemesterRepository.GetByID(id);
if (checkSemester == null)
{
return(false);
}
checkSemester.StartDate = semester.StartDate;
checkSemester.EndDate = semester.EndDate;
db.SemesterRepository.Update(checkSemester);
db.Save();
logger.Info("Updated semester (id:{0})", checkSemester.Name);
return(true);
}
protected override void deserialize(BaseItem item, List <SyncPropertyNames> changedProperties)
{
Semester i = item as Semester;
if (changedProperties != null)
{
if (Start != i.Start.ToUniversalTime())
{
changedProperties.Add(SyncPropertyNames.Start);
}
if (End != i.End.ToUniversalTime())
{
changedProperties.Add(SyncPropertyNames.End);
}
}
Start = i.Start.ToUniversalTime();
End = i.End.ToUniversalTime();
base.deserialize(i, changedProperties);
}
/// <summary>
/// Creates a new class
/// </summary>
/// <param name="name">The name/title of the class</param>
/// <param name="number">The course number</param>
/// <param name="section">The section</param>
/// <param name="semester">The semester e.g. Fall 2016</param>
/// <param name="teacher">The teacher for this class</param>
/// <returns>The created class</returns>
/// <remarks>Throws InvalidOperationException if class already exists with the given details</remarks>
public Class CreateClass(string name, int number, string section, Semester semester, int year, int teacherId)
{
var existing = _db.Classes
.Count(c => c.Name == name &&
c.Number == number &&
c.Section == section &&
c.Semester == semester &&
c.Teacher.Id == teacherId);
var teacher = _db.Teachers.Find(teacherId);
if (existing > 0 || teacher == null)
{
throw new InvalidOperationException("Error creating class");
}
var newClass = new Class
{
Name = name,
Number = number,
Section = section,
Semester = semester,
Year = year,
TrainingStatus = TrainingStatus.UnTrained,
Teacher = teacher
};
var added = _db.Classes.Add(newClass);
_db.SaveChanges();
// Create the PersonGroup for this class
var faceClient = RecognitionService.GetFaceClient();
Task.Run(() => faceClient.CreatePersonGroupAsync(added.Id.ToString(), added.Name)).Wait();
return(added);
}
public async Task <ActionResult <BaseResponse> > PutSemester(int id, Semester semester_update)
{
var datas = _context.Semesters.Where(x => x.SemesterName.Equals(semester_update.SemesterName.Trim())).ToList();
var Semes = await _context.Semesters.FindAsync(id);
if (Semes == null)
{
return(NotFound());
}
if (semester_update.SemesterName == "")
{
return(new BaseResponse
{
ErrorCode = 2,
Messege = "Not be emty!!"
});
}
else if (datas.Count != 0)
{
return(new BaseResponse
{
ErrorCode = 3,
Messege = "Semester Name already exist!!"
});
}
else
{
Semes.SemesterName = semester_update.SemesterName;
_context.Semesters.Update(Semes);
await _context.SaveChangesAsync();
return(new BaseResponse
{
ErrorCode = 1,
Messege = "Update thành công!!"
});
}
}
public async Task <Semester> Edit(Semester semester)
{
await this.Connection.OpenAsync();
var com = new MySqlCommand("sp_EditSemester", this.Connection);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.AddWithValue("@semesterId", semester.Id);
com.Parameters.AddWithValue("@name", semester.Name);
com.Parameters.AddWithValue("@startDate", DateTime.Parse(semester.StartDate));
com.Parameters.AddWithValue("@endDate", DateTime.Parse(semester.EndDate));
com.ExecuteNonQuery();
this.Connection.Close();
this.Connection.Open();
var command = new MySqlCommand($"SELECT * FROM semesters where id={semester.Id};",
this.Connection);
var reader = command.ExecuteReader();
var editSemester = new Semester();
while (reader.Read())
{
var id = reader.GetValue(0);
var name = reader.GetValue(1);
var startDate = reader.GetValue(2);
var endDate = reader.GetValue(3);
editSemester = new Semester()
{
Id = int.Parse(id.ToString()),
Name = name.ToString(),
StartDate = DateTime.Parse(startDate.ToString()).ToString("yyyy-MM-dd"),
EndDate = DateTime.Parse(endDate.ToString()).ToString("yyyy-MM-dd")
};
}
this.Connection.Close();
return(editSemester);
}
public void Add(RegisteredCourse type)
{
lock (type)
{
if (Count == RegisteredCourseId.Length)
{
var newLength = RegisteredCourseId.Length + 1000;
var _RegisteredCourseId = new string[newLength];
RegisteredCourseId.CopyTo(_RegisteredCourseId);
RegisteredCourseId = _RegisteredCourseId;
var _RegistrationDate = new System.DateTime[newLength];
RegistrationDate.CopyTo(_RegistrationDate);
RegistrationDate = _RegistrationDate;
var _StudentId = new string[newLength];
StudentId.CopyTo(_StudentId);
StudentId = _StudentId;
var _Semester = new string[newLength];
Semester.CopyTo(_Semester);
Semester = _Semester;
var _MountedCourseId = new string[newLength];
MountedCourseId.CopyTo(_MountedCourseId);
MountedCourseId = _MountedCourseId;
var _AcademicYear = new string[newLength];
AcademicYear.CopyTo(_AcademicYear);
AcademicYear = _AcademicYear;
var _Approved = new bool[newLength];
Approved.CopyTo(_Approved);
Approved = _Approved;
}
RegisteredCourseId.Span[Count] = type.RegisteredCourseId;
RegistrationDate.Span[Count] = type.RegistrationDate;
StudentId.Span[Count] = type.StudentId;
Semester.Span[Count] = type.Semester;
MountedCourseId.Span[Count] = type.MountedCourseId;
AcademicYear.Span[Count] = type.AcademicYear;
Approved.Span[Count] = type.Approved;
}
}
public List <Semester> GetAll()
{
string query = "SELECT ObjId,ObjVersion,Year,Semester,SemKey FROM semester_tab ORDER BY ObjId DESC";
List <Semester> lst = new List <Semester>();
Semester obj;
if (this.OpenConnection() == true)
{
//Create Command
MySqlCommand cmd = new MySqlCommand(query, connection);
MySqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
obj = new Semester();
obj.ObjId = int.Parse(dataReader["ObjId"].ToString());
obj.ObjVersion = int.Parse(dataReader["ObjVersion"].ToString());
obj.Year = int.Parse(dataReader["Year"].ToString());
obj.Semester_ = int.Parse(dataReader["Semester"].ToString());
obj.SemKey = "Y" + dataReader["Year"].ToString() + ".S" + dataReader["Semester"].ToString();
lst.Add(obj);
}
//close Data Reader
dataReader.Close();
//close Connection
this.CloseConnection();
//return list to be displayed
return(lst);
}
else
{
return(lst);
}
}
public SemesterModel GetSemesterWithOrganization(SemesterModel model)
{
Logger.Debug($"{model}");
if (model == null || model.Id == null || model.Id == System.Guid.Empty)
{
throw new System.ArgumentNullException("model");
}
Semester semester = this.UnitOfWork.SemesterRepository.GetById(model.Id);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Organization.Models.Organization, Organization.Models.OrganizationModel>().ForMember(x => x.Semesters, y => y.Ignore());
cfg.CreateMap <Organization.Models.Semester, Organization.Models.SemesterModel>();
});
var mapper = config.CreateMapper();
SemesterModel semesterModel = mapper.Map <Models.Semester, Models.SemesterModel>(semester);
return(semesterModel);
}
/// <summary>
///
/// </summary>
/// <param name="semester"></param>
/// <param name="userName"></param>
/// <returns></returns>
public string GetOrganisationName(Semester semester, string userName)
{
if (string.IsNullOrEmpty(userName))
return null;
var user = UserManager.FindByName(userName);
if (user == null)
return string.Empty;
var organiser = db.Organisers.FirstOrDefault(org => org.Members.Any(m => m.UserId.Equals(user.Id)));
if (organiser != null)
return organiser.ShortName;
// es könnte auch ein Student sein
// Suche nach der Semstererinschreibung
// dort findet sich der Studiengang und darüber dann der Veranstalter
var semesterService = new SemesterService();
var subscription = semesterService.GetSubscription(semester, user.Id);
if (subscription == null)
return string.Empty;
return subscription.SemesterGroup.CapacityGroup.CurriculumGroup.Curriculum.Organiser.ShortName;
}
public ActionResult DeleteConfirmed(int id)
{
try
{
Semester semester = db.Semesters.Find(id);
db.Semesters.Remove(semester);
db.SaveChanges();
ViewBag.MessageType = "success";
ViewBag.Message = "Record has been removed successfully.";
}
catch (DbUpdateException ex)
{
ViewBag.MessageType = "error";
ViewBag.Message = ex.Message;
ModelState.AddModelError(string.Empty, ex.Message);
}
model.Semesters = db.Semesters.OrderByDescending(a => a.SemesterID).ToList();
model.SelectedSemester = null;
model.DisplayMode = "WriteOnly";
ViewBag.IsActive = new SelectList(db.Options, "OptionDesc", "OptionDesc");
return(View("Index", model));
}
public async Task CreateAsync(int number, int year, string courseName, int courseId)
{
var semester = new Semester
{
Number = number,
Year = year,
CourseName = courseName,
CourseId = courseId,
};
await this.semesterRepository.AddAsync(semester);
await this.semesterRepository.SaveChangesAsync();
var chat = new Chat
{
SemesterId = semester.Id,
};
await this.chatRepository.AddAsync(chat);
await this.chatRepository.SaveChangesAsync();
}
public SemesterViewModel GetById(int semesterId)
{
SemesterViewModel result;
Semester semester = unitOfWork.Repository <Semester>().GetById(semesterId);
if (semester != null)
{
result = new SemesterViewModel
{
Id = (int)semester.Id,
Name = semester.Name
};
}
else
{
result = new SemesterViewModel
{
Id = 0,
Name = "[NoSemester]"
};
}
return(result);
}
public async Task <ActionResult> DeleteConfirmed(Guid id)
{
try
{
Semester semester = await Db.Semesters.FindAsync(id);
if (semester != null)
{
Db.Semesters.Remove(semester);
await Db.SaveChangesAsync();
Flash.Success("OK", "El semestre ha sido eliminado exitosamente");
return(RedirectToAction("Index"));
}
Flash.Error("Error", "Ha ocurrido un error eliminando el semestre");
return(RedirectToAction("Delete", id));
}
catch (Exception)
{
Flash.Error("Error", "Ha ocurrido un error eliminando el semestre, puede tener relaciones");
return(RedirectToAction("Index"));
}
}
public List <Semester> getAllSemester()
{
string connection = WebConfigurationManager.ConnectionStrings["UMS"].ConnectionString;
string query = "SELECT * FROM Semesters;";
SqlConnection con = new SqlConnection(connection);
con.Open();
SqlCommand com = new SqlCommand(query, con);
SqlDataReader reader = com.ExecuteReader();
List <Semester> semesters = new List <Semester>();
if (reader.HasRows)
{
while (reader.Read())
{
Semester aSemester = new Semester();
aSemester.SemesterId = Convert.ToInt32(reader["SemesterId"]);
aSemester.SemesterNo = reader["SemesterNo"].ToString();
semesters.Add(aSemester);
}
}
return(semesters);
}
public List <Semester> GetSemesterDropdownList()
{
List <Semester> semesterList = new List <Semester>();
GenarateConnection();
using (Connection)
{
Connection.Open();
string query = "select * from Semester;";
Command = new SqlCommand(query, Connection);
Reader = Command.ExecuteReader();
while (Reader.Read())
{
Semester semester = new Semester();
semester.ID = Convert.ToInt32(Reader["ID"].ToString());
semester.Name = Reader["Name"].ToString();
semesterList.Add(semester);
}
Connection.Close();
}
return(semesterList);
}
private List <ActivitySummary> GetLecturerExams(Semester semester, ApplicationUser user)
{
List <ActivitySummary> model = new List <ActivitySummary>();
var lectureActivities =
//Db.Activities.OfType<Exam>().ToList();
Db.Activities.OfType <Exam>().Where(a =>
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.Owners.Any(d => d.Member.UserId.Equals(user.Id))).ToList();
foreach (var activity in lectureActivities)
{
var summary = new ActivitySummary {
Activity = activity
};
model.Add(summary);
}
return(model);
}
internal List <Semester> GetShowSemesterDetails()
{
string query = @"SELECT [ID],[Name] FROM [Semester]";
SqlCommand command = new SqlCommand(query, con);
con.Open();
SqlDataReader reader = command.ExecuteReader();
Semester aSmpt = null;
var SmtList = new List <Semester>();
if (reader.HasRows)
{
while (reader.Read())
{
aSmpt = new Semester();
aSmpt.Id = (int)reader["ID"];
aSmpt.Name = reader["Name"].ToString();
SmtList.Add(aSmpt);
}
}
con.Close();
return(SmtList);
}
public List <Semester> GetAllSemesters()
{
Query = "SELECT*FROM Semester";
Command.CommandText = Query;
Command.Connection = Connection;
Connection.Open();
Reader = Command.ExecuteReader();
List <Semester> semesters = new List <Semester>();
if (Reader.HasRows)
{
while (Reader.Read())
{
Semester semester = new Semester();
semester.Id = Convert.ToInt32(Reader["Id"].ToString());
semester.Name = Reader["Name"].ToString();
semesters.Add(semester);
}
Reader.Close();
}
Connection.Close();
return(semesters);
}
public List <Semester> GetAllSemester()
{
SqlConnection connection = new SqlConnection(connectionString);
string query = "select * from Dic_Semester";
connection.Open();
SqlCommand command = new SqlCommand(query, connection);
SqlDataReader reader = command.ExecuteReader();
List <Semester> semesterList = new List <Semester>();
while (reader.Read())
{
int id = Convert.ToInt32(reader["id"]);
string name = reader["name"].ToString();
Semester semester = new Semester(id, name);
semesterList.Add(semester);
}
return(semesterList);
}
public List <Semester> GetAllSemesters()
{
Query = "SELECT * FROM Semester";
Command.CommandText = Query;
Connection.Open();
List <Semester> semesters = new List <Semester>();
Reader = Command.ExecuteReader();
while (Reader.Read())
{
Semester aSemester = new Semester
{
SemesterId = Convert.ToInt32(Reader["SemesterId"]),
Name = Reader["Name"].ToString()
};
semesters.Add(aSemester);
}
Reader.Close();
Connection.Close();
return(semesters);
}
private void DeleteSemester(object param)
{
Semester selectedSemester = (Semester)((DataGrid)param).SelectedItem;
SessionGroupDAL sessionGroupDal = new SessionGroupDAL();
if (selectedSemester.IsActive == true)
{
MessageBox.Show("Aktív szemeszter nem törölhető!", "Hiba", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
else if (sessionGroupDal.FindAll(x => x.SemesterID == selectedSemester.ID).FirstOrDefault() != null)
{
MessageBox.Show("A félévhez tartozik csoport, ezért nem törölhető!", "Hiba", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
else
{
MessageBoxResult messageBoxResult = MessageBox.Show("Valóban törli?", "Törlés megerősítése", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (messageBoxResult == MessageBoxResult.Yes)
{
SemesterList.Remove(selectedSemester);
((TeacherDAL)_contextDal).DeleteSemester(selectedSemester);
}
}
}
// GET: Semesters/Edit/5
public ActionResult EditSemester(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Semester semester = db.Semesters.Find(id);
if (semester == null)
{
return(HttpNotFound());
}
var forms = from f in db.Forms
select f;
forms = forms.Where(f => f.SemesterName.Equals(semester.Name));
if (forms.Count() > 0)
{
ViewBag.ContainsForms = "true";
}
return(View(semester));
}
public bool IsFree(Semester semester, DateTime day)
{
// innerhalb Vorlesungszeit
if (semester.StartCourses <= day && day <= semester.EndCourses)
{
var isVorlesung = true;
foreach (SemesterDate sd in semester.Dates)
{
// Wenn der Termin in eine vorlesungsfreie Zeit fällt, dann nicht importieren
if (sd.From.Date <= day.Date &&
day.Date <= sd.To.Date &&
sd.HasCourses == false)
{
isVorlesung = false;
}
}
return(!isVorlesung);
}
// ist nicht explizit vorlesungsfrei
return(false);
}
public List <Semester> GetAllSemesterList()
{
string query = "SELECT * FROM Semesters";
SqlCommand.CommandText = query;
SqlConnection.Open();
SqlDataReader reader = SqlCommand.ExecuteReader();
List <Semester> semesters = new List <Semester>();
while (reader.Read())
{
Semester semester = new Semester
{
Id = Convert.ToInt32(reader["Id"].ToString()),
Name = reader["Name"].ToString()
};
semesters.Add(semester);
}
reader.Close();
SqlConnection.Close();
return(semesters);
}
private bool checkMentor(string userMentor)
{
MSSEntities context = new MSSEntities();
Semester semester = new Semester();
DateTime date = DateTime.Now;
CourseraApiSoapClient courseraApiSoap = new CourseraApiSoapClient();
semester = context.Semesters.Where(sem => sem.Start_Date <date && sem.End_Date> date).FirstOrDefault();
var listSubjectID = context.Subjects.Where(o => o.Subject_Active == true).Select(o => o.Subject_ID).ToArray();
string authenKey = "A90C9954-1EDD-4330-B9F3-3D8201772EEA";
List <MentorObject> objectMentor = new List <MentorObject>();
try
{
string jsonData = courseraApiSoap.GetScheduledSubject(authenKey, userMentor.Split('@')[0], listSubjectID, semester.Semester_Name.Replace(" ", ""));
var scheduledSubject = Newtonsoft.Json.JsonConvert.DeserializeObject <List <MertorFAP> >(jsonData);
scheduledSubject = scheduledSubject.Distinct(new ListComparer()).ToList();
foreach (var scheduled in scheduledSubject)
{
objectMentor.Add(new MentorObject
{
Subject_ID = scheduled.SubjectCode,
Class_ID = scheduled.ClassName
});
}
}
catch
{
objectMentor = new List <MentorObject>();
}
if (objectMentor.Count > 0)
{
return(true);
}
return(false);
}
protected void Page_Load(object sender, EventArgs e)
{
AuthHelper.LoginCheck(Session, Request, Response, Server);
if (!IsPostBack)
{
var all = new ClassServiceImpl().GetAll();
DropDownList1.DataSource = all; //绑定班级
DropDownList1.DataTextField = "Name";
DropDownList1.DataValueField = "ClassId";
DropDownList1.DataBind();
ArrayList schoolYear = new ArrayList(); //绑定学年
for (int i = DateTime.Now.Year; i >= DateTime.Now.Year - 6; i--)
{
schoolYear.Add((i) + "-" + (i + 1));
}
SchoolYear.DataSource = schoolYear;
SchoolYear.DataBind();
ArrayList semester = new ArrayList(new int[] { 1, 2, 3 });
Semester.DataSource = semester;
Semester.DataBind();
if (Request.QueryString["id"] != null)
{
int CourseId = int.Parse(Request.QueryString["id"]);
CourseServiceImpl courseServiceImpl = new CourseServiceImpl();
Course course = (Course)courseServiceImpl.GetById(CourseId);
//绑定数据
CourseName.Value = course.Name;
DropDownList1.Text = string.Concat(course.ClassId);
SchoolYear.Text = course.SchoolYear;
Semester.Text = course.Semester;
ShortCourseIntro.Value = course.ShortIntroduction;
}
}
}
public static Timetable MergeSameBlocksWithDifferentTeacher(IEnumerable <Block> blocks)
{
var sortedBlocks = blocks
.OrderBy(b => b.Day)
.ThenBy(b => b.StartHour)
.ThenBy(b => b.Duration)
.ThenBy(b => b.Room)
.ThenBy(b => b.BlockType)
.ThenBy(b => b.CourseId)
.ToList();
IEnumerable <Block> mergedBlocks = Merge(sortedBlocks,
(group, b2) =>
{
Block b1 = group.Last();
return(b1.Day == b2.Day &&
b1.StartHour == b2.StartHour &&
b1.Duration == b2.Duration &&
b1.Room == b2.Room &&
b1.BlockType == b2.BlockType &&
b1.CourseId == b2.CourseId);
},
(blocksGroup) =>
{
Block block = blocksGroup[0].Clone();
block.Teacher = string.Join(",", blocksGroup.Select(b => b.Teacher));
return(block);
}
);
Timetable mergedTimetable = new(Semester.GetSemester());
foreach (var mergedBlock in mergedBlocks)
{
mergedTimetable.AddNewBlock(mergedBlock);
}
return(mergedTimetable);
}
private bool HasSemester(String course, Semester sem)
{
bool flag = false;
try
{
flag = CourseByCode(course).Sections.ToList().Exists(x => x.Term == sem.ToString());
}
catch (NullReferenceException) { }
return flag;
}
public void GenerateSectionList(Semester sem)
{
List<Section> SectionList = new List<Section>();
List<Course> Fall = new List<Course>();
List<Course> Winter = new List<Course>();
List<Course> Both = new List<Course>();
List<List<Course>> Container = new List<List<Course>>();
Container.Add(Fall);
Container.Add(Winter);
Container.Add(Both);
//Filter by availability
FilterClasses(Fall, Winter, Both);
if (DEBUG)
System.Diagnostics.Debug.WriteLine("Fall: " + Fall.Count + " | Winter: " + Winter.Count + " | Both: " + Both.Count);
//Find Sections
foreach (List<Course> list in Container)
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("In find section loop list size is: " + list.Count);
foreach (Course c in list)
{
foreach (Section sec in c.Sections.ToList())
{
SectionList.Add(sec);
if (DEBUG)
System.Diagnostics.Debug.WriteLine("\tAdding Section " + c.Code + " " + sec.Name);
}
if (DEBUG)
System.Diagnostics.Debug.WriteLine("Section count is: " + SectionList.Count);
}
}
//Remove sections that the student cannot attend
FilterConstrainedSections(SectionList);
//At this point, we have all the potential sections the student can take, its time to start scheduling them.
//If scheduling for Fall, include fall and winter. If winter, only winter.
List<Course> TakeFall = new List<Course>();
List<Course> TakeWinter = new List<Course>();
foreach (string s in CoursesToTake)
{
if (s.Contains("_"))
{
TakeWinter.Add(CourseByCode(s.Split('_')[0]));
}
else if (Both.Exists(x => x.Code == s))
{
if (TakeFall.Count < MaxSemesterCourses && sem == Semester.Fall)
TakeFall.Add(CourseByCode(s));
else
TakeWinter.Add(CourseByCode(s));
}
else if (Winter.Exists(x => x.Code == s))
{
TakeWinter.Add(CourseByCode(s));
}
else if (Fall.Exists(x => x.Code == s))
{
TakeFall.Add(CourseByCode(s));
}
}
foreach (Course c in TakeFall)
{
try
{
if (DEBUG) System.Diagnostics.Debug.WriteLine("FALL: " + c.Code);
}
catch (NullReferenceException) { }
}
foreach (Course c in TakeWinter)
{
try
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("WINTER: " + c.Code);
}
catch (NullReferenceException) { }
}
foreach (Course c in TakeFall)
{
List<Section> courseSections = SectionList.Where(x => (x.Course.Code == c.Code) && (x.Term == "Fall")).ToList();
if (DEBUG)
System.Diagnostics.Debug.WriteLine("Sections Found: " + courseSections.Count);
if (c.HasLab && c.HasTutortial)
{
AddType("LEC", courseSections, ScheduledSectionsFall);
AddType("LAB", courseSections, ScheduledSectionsFall);
AddType("TUT", courseSections, ScheduledSectionsFall);
}
else if (c.HasTutortial)
{
AddType("LEC", courseSections, ScheduledSectionsFall);
AddType("TUT", courseSections, ScheduledSectionsFall);
}
else
{
AddType("LEC", courseSections, ScheduledSectionsFall);
}
}
foreach (Course c in TakeWinter)
{
List<Section> courseSections = SectionList.Where(x => (x.Course.Code == c.Code) && (x.Term == Semester.Winter.ToString())).ToList();
if (c.HasLab && c.HasTutortial)
{
AddType("LEC", courseSections, ScheduledSectionsWinter);
AddType("LAB", courseSections, ScheduledSectionsWinter);
AddType("TUT", courseSections, ScheduledSectionsWinter);
}
else if (c.HasTutortial)
{
AddType("LEC", courseSections, ScheduledSectionsWinter);
AddType("TUT", courseSections, ScheduledSectionsWinter);
}
else
{
AddType("LEC", courseSections, ScheduledSectionsWinter);
}
}
foreach (Section c in ScheduledSectionsFall)
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("[FALL SECTION SCHEDULED]: " + c.Course.Code + " : " + c.Name);
}
foreach (Section c in ScheduledSectionsWinter)
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("[WINTER SECTION SCHEDULED]: " + c.Course.Code + " : " + c.Name);
}
}
private void CheckPrereqs(String course, Semester sem)
{
int PrereqDoneCount = 0;
int PrereqWaitingCount = 0;
List<Course> list = GetPrereqs(course);
if (DEBUG)
System.Diagnostics.Debug.WriteLine("Checking " + course + " for prereqs");
if (HasPrereqs(course))
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("There are " + list.Count + " prereqs");
foreach (Course c in list)
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("\tPrereq is: " + c.Code);
//This course was already taken by the student
if (CoursesTaken.Exists(x => (x.Code == course)))
{
PrereqDoneCount++;
if (PrereqDoneCount == list.Count)
{
if (!CoursesToTake.Exists(x => (x == (course))))
{
CoursesToTake.Add(course);
}
}
}
else if (CoursesToTake.Exists(x => (x == c.Code)))
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("\t\t" + c.Code + " IN CTT");
PrereqWaitingCount++;
if (PrereqWaitingCount == list.Count)
{
if (!CoursesToTake.Exists(x => (x == (course + "_SKIP"))) && sem == Semester.Fall)
{
CoursesToTake.Add(course + "_SKIP");
}
}
}
else
{
if (HasPrereqs(c.Code))
{
CheckPrereqs(c.Code, sem);
}
}
}
if (DEBUG) System.Diagnostics.Debug.WriteLine("\t" + course + " has prereqs.");
if (!PrereqsMissing.Exists(x => x == CourseByCode(course)))
{
PrereqsMissing.Add(CourseByCode(course));
}
}
else
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("\t" + course + " needs to be done.");
if (!CoursesToTake.Exists(x => x == course))
CoursesToTake.Add(course);
}
if (DEBUG)
System.Diagnostics.Debug.WriteLine("..done checking " + course);
}
public void UpdateSem(object sender, EventArgs e)
{
Semester semester = new Semester(sem.sem, sem.year); //Once AddSemester form closes,
lbSemesters.Items.Clear(); //clear lbSemesters, sort then re-add
if (semList.Contains(semester))
MessageBox.Show("Cannot add duplicate semester", "Exception");
else {
semList.Add(semester);
semList.Sort();
foreach (Semester r in semList)
lbSemesters.Items.Add(r);
}
sem.Close();
lbSemesters.SelectedIndex = 0;
}
public HttpResponseMessage<Semester> AddSemester(Semester semester)
{
// Add the region that was passed in as the argument
context.Semesters.Add(semester);
context.SaveChanges();
// Prepare the response - we want to return "201 Created"
HttpResponseMessage<Semester> response = new HttpResponseMessage<Semester>(semester, HttpStatusCode.Created);
return response;
}
public ActionResult Semesters(List<int> courses, int semester)
{
// Retreive the Courses selected
List<Course> SelectedCourses = new List<Course> ();
if ( courses != null )
{
var list_of_courses = db.Courses.ToList();
SelectedCourses = list_of_courses.Where(c => courses.Contains(c.course_id)).ToList();
// Retreive the Semester That Selected
Semester SelectedSemester = new Semester();
var list_of_Semesters = (from s in db.Semesters
where s.semester_id == semester
select s).ToList();
SelectedSemester = list_of_Semesters.First();
ViewBag.SelectedSemester = SelectedSemester;
foreach (var course in SelectedCourses)
{
SemesterCourse sc = new SemesterCourse();
sc.course_id = course.course_id;
sc.semester_id = semester;
db.SemesterCourses.Add(sc);
}
db.SaveChanges();
}
return View(SelectedCourses);
}
public ActionResult Edit(Semester semester)
{
if (ModelState.IsValid)
{
db.Entry(semester).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
return View(semester);
}
public bool isAvailable(Semester s)
{
return ((_semester & s) != 0);
}
public static bool IsSemesterValid(Semester sem, int year)
{
if (year >= DialogManager.Instance.GradYear)
{
if (year == DialogManager.Instance.GradYear && sem == Semester.Spring)
{
return true;
}
else
{
return false;
}
}
else if (year <= DialogManager.Instance.GradYear - 4)
{
if (year == DialogManager.Instance.GradYear-4 && sem == Semester.Fall)
{
return true;
}
else
{
return false;
}
}
return true;
}
//FALL = FALL N Winter
//Winter = Winter ONLY
//NO SUMMER
public void GenerateSchedule(Semester sem)
{
//10 if Fall, 5 if Winter
int ClassCount = (sem == Semester.Fall) ? 10 : 5;
foreach (List<string> year in MasterSequence.YearToListOfCourses)
{
foreach (string course in year)
{
if (DEBUG)
System.Diagnostics.Debug.WriteLine("Course Count is: " + CoursesToTake.Count);
if (CoursesToTake.Count < ClassCount)
{
//The Student already took the course, remove it
if (CoursesTaken.Contains(CourseByCode(course)))
{
LocalSequence.RemoveCourse(course);
if (DEBUG)
System.Diagnostics.Debug.WriteLine("[ALREADY TOOK]: " + course.ToString());
continue;
}
CheckPrereqs(course, sem);
}
else { break; }
}
}
GenerateSectionList(sem);
}
public static Semester? GetSemester(SemanticValueDict semantics, Semester? sem = null)
{
if (semantics.ContainsKey(Slots.Semester.ToString()))
{
sem = (Semester)Enum.Parse(typeof(Semester), semantics[Slots.Semester.ToString()].Value.ToString(), true);
}
return sem;
}
public void notOffered(SemanticValueDict context, Semester semester)
{
//RecoManager.Instance.SayCancelAll();
RecoManager.Instance.Say("That class is not available in the " + semester.ToString());
}
public void SetSemester(Semester sem, int year)
{
this.sem = sem;
this.year = year;
this.sem_year_label.Content = sem.ToString() + " " + year.ToString();
}
public CourseInSemester(Semester semester, int year)
{
Id = new Guid();
Semester = semester;
Year = year;
}
