public IList<Semester> Fill(AcademicYear academicYear)
{
if (academicYear == null||academicYear.Id<=0)
{
return null;
}
IList<Core.Business.Semester> semesterlist = new List<Core.Business.Semester>();
SqlServerUtility sql = new SqlServerUtility();
sql.AddParameter("@AcademicYearId", SqlDbType.Int, academicYear.Id);
SqlDataReader reader = sql.ExecuteSqlReader(SqlFillSemesterWithYearId);
if (reader != null)
{
while (reader.Read())
{
Core.Business.Semester semester = new Core.Business.Semester();
if (!reader.IsDBNull(0)) semester.Id = reader.GetInt32(0);
if (!reader.IsDBNull(1)) semester.AcademicYearId = reader.GetInt32(1);
if (!reader.IsDBNull(2)) semester.StartTime = reader.GetDateTime(2);
if (!reader.IsDBNull(3)) semester.EndTime = reader.GetDateTime(3);
if (!reader.IsDBNull(4)) semester.Name = reader.GetString(4);
semester.MarkOld();
semesterlist.Add(semester);
}
reader.Close();
}
return semesterlist;
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "application/json";
string yearName;
string yearDes;
StringBuilder sbResult = new StringBuilder();
#region Validation
if (string.IsNullOrEmpty(context.Request.Form["name"]) ||
string.IsNullOrEmpty(context.Request.Form["des"]))
{
context.Response.Write("{success: false, msg: '参数不正确'}");
return;
}
yearName = context.Request.Form["name"];
yearDes = context.Request.Form["des"];
#endregion
AcademicYear ay = new AcademicYear();
ay.Name = yearName;
ay.Description = yearDes;
try
{
AcademicYear ayTemp = AcademicYear.Load(yearName);
if (ayTemp != null)
{
throw new Exception("学年名称与系统已有学年名称重复");
}
ay.Save();
sbResult.Append("{success: true}");
}
catch (Exception ex)
{
sbResult = new StringBuilder();
sbResult.Append("{success: false, msg: '" + ex.Message.Replace('\'', ' ').Replace('"', ' ') + "'}");
}
context.Response.Write(sbResult.ToString());
}
public ActionResult Edit(AcademicYearDetailsEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
AcademicYear academicYear = this.academicYearService.GetById(model.Id);
if (academicYear == null)
{
ModelState.AddModelError(string.Empty, "Invalid or not existing year.");
return(View(model));
}
Mapper.Map(model, academicYear);
this.academicYearService.Update(academicYear);
return(RedirectToAction("Index"));
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
List <ValidationResult> errors = new List <ValidationResult>();
if (this.StartDate >= this.EndDate)
{
errors.Add(new ValidationResult("Start date should not be equal or greater than end date."));
}
IAcademicYearService academicYearService = DependencyResolver.Current.GetService <IAcademicYearService>();
bool yearExistsInDb =
academicYearService.AcademicYearExistsInDb(this.StartDate, this.EndDate) ? true : false;
if (yearExistsInDb)
{
errors.Add(new ValidationResult(
"Academic Year with the entered start year or end year already exists."));
}
if (academicYearService.All().Any())
{
AcademicYear latestAcademicYear =
academicYearService.All().OrderByDescending(ay => ay.StartDate).First();
if (latestAcademicYear != null && this.StartDate.Year > latestAcademicYear.StartDate.Year + 1)
{
errors.Add(new ValidationResult(
"New academic year cannot be more than 1 year later than latest academic year."));
}
}
if (this.EndDate.Year > this.StartDate.Year + 1)
{
errors.Add(new ValidationResult("Academic Year may not last more than 1 astronomical year."));
}
return(errors);
}
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 bool AddAcademicYear(AcademicYear year)
{
if (year.IsCurrent)
{
if (!RemoveAcademicYearCurrentStatus())
{
return(false);
}
}
var data = _db.AcademicYears.Add(year);
try
{
_db.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
year.YearId = data.YearId;
return(true);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
AcademicYear = await _context.AcademicYears
.Include(ay => ay.Semesters)
.Include(ay => ay.DiplomaProgramYearSections)
.ThenInclude(dpys => dpys.AdvisingAssignments)
.ThenInclude(aa => aa.Instructor)
.Include(ay => ay.DiplomaProgramYearSections)
.ThenInclude(dpys => dpys.DiplomaProgramYear)
.ThenInclude(dpy => dpy.DiplomaProgram)
.FirstOrDefaultAsync(m => m.Id == id);
if (AcademicYear == null)
{
return(NotFound());
}
return(Page());
}
void btnSave_Click(object sender, EventArgs e)
{
try
{
AcademicYear academicYear = new AcademicYear
{
Name = txtAcademiYearName.Text
};
BLL.AddAcademicYear(academicYear);
FillAcademicYears();
ResetControls();
upnlAcademicYears.Update();
upnlAddAcademicYear.Update();
SetAlert(operationMessage);
}
catch (Exception ex)
{
ErrorLogger.WriteError(ex);
}
}
public ActionResult Add(AcademicYearRegisterModel academicYearModel)
{
var year = new DateTime(academicYearModel.Year, 01, 01);
var approved = false;
var isActive = false;
if (academicYearModel.Approved == "1")
approved = true;
if (academicYearModel.IsActive == "1")
isActive = true;
var academicYear = new AcademicYear
{
Year = year.Year,
Grade = _gradeRepository.GetById(academicYearModel.Grade.Id),
Section = academicYearModel.Section,
Approved = approved,
IsActive = isActive
};
_academicYearRepository.Create(academicYear);
const string title = "Año Académico Agregado";
var content = "El año académico " + academicYearModel.Year + " ha sido agregado exitosamente.";
_viewMessageLogic.SetNewMessage(title, content, ViewMessageType.SuccessMessage);
return RedirectToAction("Index");
}
public ActionResult SaveYear(AcademicYearsViewModel model)
{
if (ModelState.IsValid)
{
var academicYear = new AcademicYear
{
StartDate = model.StartDate,
EndDate = model.EndDate,
EtYear = model.EtYear,
GcYear = model.GcYear
};
var academicYearStartEvent = new AcademicEvent
{
Subject = "Academic Year Start Date",
Description = $"{academicYear.EtYear} EC Academic Year Start Date",
Start = model.StartDate
};
var academicYearEndEvent = new AcademicEvent
{
Subject = "Academic Year End Date",
Description = $"{academicYear.EtYear} EC Academic Year End Date",
Start = model.EndDate
};
_context.AcademicYears.Add(academicYear);
_context.AcademicEvents.Add(academicYearStartEvent);
_context.AcademicEvents.Add(academicYearEndEvent);
_context.SaveChanges();
return(RedirectToAction("Index", "Semesters"));
}
return(View("NewAcademicYear"));
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
if (this.StartDate >= this.EndDate)
{
yield return(new ValidationResult("Start date should not be equal or greater than end date."));
}
IAcademicYearService academicYearService = DependencyResolver.Current.GetService <IAcademicYearService>();
bool uniqueOnEdit = academicYearService.AcademicYearUniqueOnEdit(this.Id, this.StartDate, this.EndDate);
if (!uniqueOnEdit)
{
yield return(new ValidationResult(
"Academic Year with the entered start year or end year already exists."));
}
if (academicYearService.All().Any())
{
AcademicYear latestAcademicYear = academicYearService
.All()
.OrderByDescending(ay => ay.StartDate)
.First();
if (latestAcademicYear != null && this.StartDate.Year > latestAcademicYear.StartDate.Year + 1)
{
yield return(new ValidationResult(
"New academic year cannot be more than 1 year later than latest academic year."));
}
}
if (this.EndDate.Year > this.StartDate.Year + 1)
{
yield return(new ValidationResult(
"Academic Year may not last more than 1 astronomical year."));
}
}
public bool UpdateAcademicYear(AcademicYear year)
{
if (year.IsCurrent)
{
if (!RemoveAcademicYearCurrentStatus())
{
return(false);
}
}
var data = _db.AcademicYears.First(x => x.YearId == year.YearId);
data.Year = year.Year;
data.IsCurrent = year.IsCurrent;
try
{
_db.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
return(true);
}
public IActionResult AcademicYearCreate([Bind("AcademicYearStart, AcademicYearEnd")] AddAcademicYearViewModel addAcademicYearViewModel)
{
//var isNotUnique = _context.InterviewTasks.Any(t => t.TaskGroup.TaskGroupName == addInterviewTaskViewModel.TaskGroupName);
//if (isNotUnique)
//{
// ModelState.AddModelError(string.Empty, "Tokia užduočių grupė jau yra sukurta");
//}
if (ModelState.IsValid)
{
AcademicYear newAcademicYear = new AcademicYear()
{
AcademicYearStart = addAcademicYearViewModel.AcademicYearStart,
AcademicYearEnd = addAcademicYearViewModel.AcademicYearEnd
};
_context.AcademicYears.Add(newAcademicYear);
_context.SaveChanges();
return(RedirectToAction("AcademicYear"));
}
return(View());
}
public AcademicTerm(int value, AcademicYear academicYear)
{
Value = value;
AcademicYear = academicYear;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
using (WebhostEntities db = new WebhostEntities())
{
Faculty currentUser = db.Faculties.Where(f => f.ID == this.user.ID).Single();
List <int> advisees = currentUser.Students.Where(s => s.isActive).Select(s => s.ID).ToList();
int year = DateRange.GetCurrentAcademicYear();
int currentTerm = DateRange.GetCurrentOrLastTerm();
AcademicYear ay = db.AcademicYears.Where(y => y.id == year).Single();
AdviseeSelectDDL.DataSource = StudentListItem.GetDataSource(advisees);
AdviseeSelectDDL.DataTextField = "Text";
AdviseeSelectDDL.DataValueField = "ID";
AdviseeSelectDDL.DataBind();
if (advisees.Contains(SelectedAdvisee))
{
AdviseeSelectDDL.ClearSelection();
AdviseeSelectDDL.SelectedValue = Convert.ToString(SelectedAdvisee);
}
else
{
SelectedAdvisee = Convert.ToInt32(AdviseeSelectDDL.SelectedValue);
}
TermSelectDDL.DataSource = TermListItem.GetDataSource(ay.Terms.Select(t => t.id).ToList());
TermSelectDDL.DataTextField = "Text";
TermSelectDDL.DataValueField = "ID";
TermSelectDDL.DataBind();
TermSelectDDL.ClearSelection();
TermSelectDDL.SelectedValue = Convert.ToString(SelectedTerm);
Student selectedAdvisee = currentUser.Students.Where(s => s.ID == SelectedAdvisee).Single();
List <MiniComment> comments = new List <MiniComment>();
foreach (StudentComment comment in selectedAdvisee.StudentComments.Where(c => c.CommentHeader.TermIndex == SelectedTerm).ToList())
{
comments.Add(new MiniComment()
{
id = comment.id,
className = comment.CommentHeader.Section.Course.Name
});
}
if (comments.Count == 0)
{
ClassSelectDDL.Enabled = false;
}
else
{
ClassSelectDDL.Enabled = true;
ClassSelectDDL.DataSource = comments;
ClassSelectDDL.DataTextField = "className";
ClassSelectDDL.DataValueField = "id";
ClassSelectDDL.DataBind();
if (SelectedComment != -1)
{
ClassSelectDDL.ClearSelection();
ClassSelectDDL.SelectedValue = Convert.ToString(SelectedComment);
}
else
{
SelectedComment = Convert.ToInt32(ClassSelectDDL.SelectedValue);
}
AdviseeCommentViewer.LoadComment(SelectedComment);
}
}
}
}
public ActionResult Index(UserLogin objcust)
{
/*var isNavigateToUpdateProfile = default(bool);*/
if (ModelState.IsValid)
{
try
{
DataTable dt = objDbTrx.GetBDMSLoginDtl(objcust.UserName, objcust.UserPassword, objcust.AccadmicYear);
if (dt.Rows.Count > 0)
{
DataTable dtRefInfo = new DataTable();
UserSec objUser = new UserSec();
objUser.UserType = dt.Rows[0]["USER_TYPE"].ToString();
objUser.UserId = dt.Rows[0]["USER_ID"].ToString();
objUser.DisplayName = dt.Rows[0]["DISPLAY_NAME"].ToString();
objUser.UserUniqueId = dt.Rows[0]["ID"].ToString();
objUser.AcademicYearId = objcust.AccadmicYear;
objUser.AcademicYear = dt.Rows[0]["ACAD_YEAR"].ToString();
objUser.HasReqEditPermission = Convert.ToInt32(dt.Rows[0]["HasReqEditPermission"].ToString());
objUser.HasChallanRevertPermission = Convert.ToInt32(dt.Rows[0]["HasChallanRevert"].ToString());
objUser.CircleID = "";
objUser.DistrictID = "";
objUser.CircleName = "";
objUser.DistrictNname = "";
if (objUser.UserType == "1")//Circle User
{
Session["REF_CRCL_ID_NEW"] = Convert.ToInt32(dt.Rows[0]["REF_ID"].ToString());
dtRefInfo = objDbTrx.GetCircleDtilById(Convert.ToInt32(dt.Rows[0]["REF_ID"].ToString()));
if (dtRefInfo.Rows.Count > 0)
{
objUser.CircleID = dtRefInfo.Rows[0]["ID"].ToString();
objUser.DistrictID = dtRefInfo.Rows[0]["DISTRICT_ID"].ToString();
objUser.CircleName = dtRefInfo.Rows[0]["CIRCLE_NAME"].ToString();
objUser.DistrictNname = dtRefInfo.Rows[0]["DISTRICT"].ToString();
/*if (string.IsNullOrWhiteSpace(dtRefInfo.Rows[0]["EMAIL_ID"].ToString())
|| string.IsNullOrWhiteSpace(dtRefInfo.Rows[0]["MOBILE_NO"].ToString())
|| string.IsNullOrWhiteSpace(dtRefInfo.Rows[0]["ALTERNATE_MOBILE_NO"].ToString())
|| string.IsNullOrWhiteSpace(dtRefInfo.Rows[0]["CIRCLE_OFFICER_NAME"].ToString()))
|| {
|| isNavigateToUpdateProfile = true;
|| }
|| else
|| {
|| isNavigateToUpdateProfile = default(bool);
|| }*/
}
}
if (objUser.UserType == "2")//District User User
{
dtRefInfo = objDbTrx.GetCircleDtilById(Convert.ToInt32(dt.Rows[0]["REF_ID"].ToString()));
if (dtRefInfo.Rows.Count > 0)
{
objUser.CircleID = dtRefInfo.Rows[0]["ID"].ToString();
objUser.CircleName = dtRefInfo.Rows[0]["CIRCLE_NAME"].ToString();
try
{
DataTable dtbl = objDbTrx.GetCircleDtilByDistId(Convert.ToInt32(dt.Rows[0]["REF_ID"].ToString()));
if (dtbl.Rows.Count > 0)
{
objUser.DistrictID = dtbl.Rows[0]["DISTRICT_ID"].ToString();
objUser.DistrictNname = dtbl.Rows[0]["DISTRICT"].ToString();
}
else
{
objUser.DistrictID = dtRefInfo.Rows[0]["DISTRICT_ID"].ToString();
objUser.DistrictNname = dtRefInfo.Rows[0]["DISTRICT"].ToString();
}
}
catch (Exception)
{
objUser.DistrictID = dtRefInfo.Rows[0]["DISTRICT_ID"].ToString();
objUser.DistrictNname = dtRefInfo.Rows[0]["DISTRICT"].ToString();
}
}
else
{
dtRefInfo = objDbTrx.GetCircleDtilByDistId(Convert.ToInt32(dt.Rows[0]["REF_ID"].ToString()));
if (dtRefInfo.Rows.Count > 0)
{
objUser.DistrictID = dtRefInfo.Rows[0]["DISTRICT_ID"].ToString();
objUser.DistrictNname = dtRefInfo.Rows[0]["DISTRICT"].ToString();
}
}
}
Session["UserSec"] = objUser;
GlobalSettings.oUserData = objUser;
DataTable dto = objDbTrx.GetAcademicYearByID(objUser.AcademicYearId);
if (dto != null && dto.Rows.Count > default(int))
{
AcademicYear oAcY = new AcademicYear();
oAcY.ACAD_YEAR = dto.Rows[0]["ACAD_YEAR"].ToString();
oAcY.ACAD_YEAR_SHORT = dto.Rows[0]["ACAD_YEAR_SHORT"].ToString();
oAcY.ID = Convert.ToInt32(dto.Rows[0]["ID"].ToString());
oAcY.ISACTIVE = Convert.ToInt32(dto.Rows[0]["ISACTIVE"].ToString());
oAcY.PFX_BINDER = dto.Rows[0]["PFX_BINDER"].ToString();
oAcY.PFX_CHALLAN = dto.Rows[0]["PFX_CHALLAN"].ToString();
oAcY.PFX_INVOICE = dto.Rows[0]["PFX_INVOICE"].ToString();
oAcY.PFX_REQ = dto.Rows[0]["PFX_REQ"].ToString();
oAcY.PFX_SCHCHALLAN = dto.Rows[0]["PFX_SCHCHALLAN"].ToString();
GlobalSettings.oAcademicYear = oAcY;
}
if (objUser.UserType == "1")//Circle User
{
Session["BDMSLoginType"] = "CIRCLE";
GlobalSettings.oUserData.vUserRole = UserRole.CIRCLE;
}
else if (objUser.UserType == "2")//District
{
Session["BDMSLoginType"] = "DISTRICT";
GlobalSettings.oUserData.vUserRole = UserRole.DISTRICT;
return(RedirectToAction("Index", "SchRequisitionApproval"));
}
else if (objUser.UserType == "3") //ADMIN
{
Session["BDMSLoginType"] = "ADMIN";
GlobalSettings.oUserData.vUserRole = UserRole.ADMIN;
}
else if (objUser.UserType == "4") //TB Login
{
Session["BDMSLoginType"] = "TBLOGIN";
GlobalSettings.oUserData.vUserRole = UserRole.TBLOGIN;
}
else if (objUser.UserType == "5") //DIRECORATE
{
Session["BDMSLoginType"] = "DIRECORATE";
GlobalSettings.oUserData.vUserRole = UserRole.DIRECTORATE;
return(RedirectToAction("Index", "SchRequisitionApproval"));
}
else if (objUser.UserType == "6") //TRANSPORTER
{
Session["BDMSLoginType"] = "TRANSPORTER";
GlobalSettings.oUserData.vUserRole = UserRole.TRANSPORTER;
}
else if (objUser.UserType == "7") //TRANSPORTER
{
Session["BDMSLoginType"] = "CHALLAN";
GlobalSettings.oUserData.vUserRole = UserRole.CHALLAN;
return(RedirectToAction("Index", "LandingPage"));
}
else if (objUser.UserType == "11") //Logistic User For Challan
{
Session["BDMSLoginType"] = "LOGISTIC";
GlobalSettings.oUserData.vUserRole = UserRole.LOGISTIC;
}
/*if (isNavigateToUpdateProfile)
* {
* return RedirectToAction("Index", "CircleUserEdit");
* }
* else
* {
* return RedirectToAction("Index", "WelcomeLandingPage");
* }*/
return(RedirectToAction("Index", "WelcomeLandingPage"));
}
else
{
TempData["AppMessage"] = "Invalid User name or password..";
}
}
catch (Exception ex)
{
objDbTrx.SaveSystemErrorLog(ex, Request.UserHostAddress);
}
finally { }
}
return(RedirectToAction("Index", "CircleLogin"));
}
public void CompareToTest()
{
AcademicYear year2 = new AcademicYear(13);
Assert.AreEqual(-1, year.CompareTo(year2));
}
public ActionResult Details(int?page, bool own = false, string tryb = "", string promotor = "", string AcademicYears = "")
{
List <string> years = (from w in db.AcademicYear orderby w.ID descending select w.Year).ToList();
ViewBag.AcademicYears = new SelectList(years);
ViewBag.UserPermission = false;
var userName = User.Identity.Name;
if (AcademicYears == "")
{
AcademicYears = (from i in db.AcademicYear orderby i.ID descending select i.Year).FirstOrDefault();
}
AcademicYear academicYear = (from a in db.AcademicYear where a.Year == AcademicYears select a).FirstOrDefault();
if (academicYear == null)
{
return(HttpNotFound());
}
var academicYearId = (from a in db.AcademicYear where a.Year == AcademicYears select a.ID).FirstOrDefault();
List <Thesis> thesis = (from t in db.Thesis where t.AcademicYearID == academicYearId select t).ToList();
foreach (var t in thesis)
{
Lecturer lecturer = (from l in db.Users where l.Id == t.LecturerID select l).FirstOrDefault();
t.Lecturer = lecturer;
}
if (userName == null && String.IsNullOrEmpty(tryb))
{
thesis = (thesis.Where(a => a.Category == "Inżynierskie stacjonarne")).ToList();
}
if (tryb != "Wszystkie" && !String.IsNullOrEmpty(tryb))
{
thesis = (thesis.Where(a => a.Category == tryb)).ToList();
}
if (!String.IsNullOrEmpty(promotor))
{
string lecturer = (from l in db.Users where l.Lastname.Contains(promotor) select l.Id).FirstOrDefault();
thesis = (thesis.Where(a => a.LecturerID == lecturer)).ToList();
}
else if (!String.IsNullOrEmpty(userName) && own)
{
string lecturer = (from l in db.Users where l.Email == userName select l.Id).FirstOrDefault();
thesis = (thesis.Where(a => a.LecturerID == lecturer)).ToList();
}
if (!String.IsNullOrEmpty(userName))
{
Lecturer lecturer = (from user in db.Users where user.UserName == userName select user).FirstOrDefault();
if (lecturer.AddThesisPermision != null)
{
int current = DateTime.Compare(DateTime.Now, lecturer.AddThesisPermision);
if (current < 0)
{
ViewBag.UserPermission = true;
}
}
}
List <Institute> institutes = (from f in db.Institutes select f).ToList();
ViewBag.Institutes = new SelectList(institutes, "ID", "Name");
int pageSize = 5;
int pageNumber = (page ?? 1);
ThesisInYear thesisInYear = new ThesisInYear
{
AcademicYear = academicYear,
Thesis = new PagedList <Thesis>(thesis, pageNumber, pageSize)
};
return(View(thesisInYear));
}
internal AcademicYearModel(AcademicYear model) : base(model)
{
LoadFromModel(model);
}
public AcademicYear Delete(AcademicYear itemToDelete)
{
_context.AcademicYears.Remove(itemToDelete);
_context.SaveChanges();
return(itemToDelete);
}
public static void AddAcademicYear(AcademicYear academicYear)
{
DAL dal = new DAL();
dal.AddAcademicYear(academicYear);
}
private void LoadFromModel(AcademicYear model)
{
Name = model.Name;
Locked = model.Locked;
}
static CSV GetClassSizeDistribution(int academicYear, TermName term)
{
using (WebhostEntities db = new WebhostEntities())
{
String termName = term.Equals(TermName.Fall) ? "Fall" : term.Equals(TermName.Winter) ? "Winter" : "Spring";
AcademicYear ay = db.AcademicYears.Where(a => a.id == academicYear).Single();
if (ay.Terms.Count <= 0)
{
throw new ArgumentException(String.Format("No Terms for {0} {1}", termName, academicYear));
}
Term theTerm = ay.Terms.Where(t => t.Name.Contains(termName)).Single();
CSV output = new CSV();
Dictionary <Faculty, List <Section> > FallTermData = new Dictionary <Faculty, List <Section> >();
foreach (Section section in theTerm.Sections.ToList())
{
foreach (Faculty teacher in section.Teachers.ToList())
{
if (FallTermData.ContainsKey(teacher))
{
FallTermData[teacher].Add(section);
}
else
{
FallTermData.Add(teacher, new List <Section>()
{
section
});
}
}
}
List <Faculty> activeTeachers = FallTermData.Keys.ToList();
foreach (Faculty faculty in activeTeachers)
{
int studentCount = 0;
int smallClasses = 0;
int largeClasses = 0;
int largestClass = 0;
foreach (Section section in FallTermData[faculty])
{
int count = section.Students.Count / section.Teachers.Count;
if (count < 6)
{
smallClasses++;
}
if (count > 12)
{
largeClasses++;
}
if (count > largeClasses)
{
largestClass = section.Students.Count;
}
studentCount += count;
}
int totalSections = FallTermData[faculty].Count;
int averageClassSize = studentCount / totalSections;
Dictionary <String, String> row = new Dictionary <string, string>()
{
{ "First Name", faculty.FirstName },
{ "Last Name", faculty.LastName },
{ "Advisees", faculty.Students.Where(s => s.GraduationYear >= academicYear && s.isActive).Count().ToString() },
{ "# Fall Sections", totalSections.ToString() },
{ "Total Students", studentCount.ToString() },
{ "Average Class Size", averageClassSize.ToString() },
{ "Classes Less than 6 students", smallClasses.ToString() },
{ "Classes Greater than 12 students", largeClasses.ToString() },
{ "largest class", largestClass.ToString() }
};
output.Add(row);
}
return(output);
}
}
static CSV AttendanceYearReport(int student_id)
{
using (WebhostEntities db = new WebhostEntities())
{
int year = DateRange.GetCurrentAcademicYear();
AcademicYear ay = db.AcademicYears.Find(year);
Student student = db.Students.Find(student_id);
CSV csv = new CSV(String.Format("{0} {1} Attendance Report", student.FirstName, student.LastName));
List <AttendanceMarking> attendances = new List <AttendanceMarking>();
foreach (Term term in ay.Terms.ToList())
{
attendances.AddRange(student.AttendanceMarkings.Where(m => m.AttendanceDate >= term.StartDate && m.AttendanceDate <= term.EndDate).ToList());
}
Dictionary <DateTime, List <AttendanceMarking> > attendances_by_date = new Dictionary <DateTime, List <AttendanceMarking> >();
foreach (AttendanceMarking mark in attendances)
{
if (attendances_by_date.ContainsKey(mark.AttendanceDate))
{
attendances_by_date[mark.AttendanceDate].Add(mark);
}
else
{
attendances_by_date.Add(mark.AttendanceDate, new List <AttendanceMarking>()
{
mark
});
}
}
int totalCuts = 0, totalPresent = 0, totalLates = 0, totalExcused = 0, totalOther = 0;
foreach (DateTime date in attendances_by_date.Keys.OrderBy(d => d))
{
int cuts = 0, present = 0, lates = 0, excused = 0, other = 0;
foreach (AttendanceMarking mark in attendances_by_date[date])
{
switch (mark.Marking.Name)
{
case "Cut": cuts++; break;
case "Late": lates++; break;
case "Present": present++; break;
case "Excused": excused++; break;
default: other++; break;
}
}
totalCuts += cuts;
totalPresent += present;
totalLates += lates;
totalExcused += excused;
totalOther += other;
Dictionary <String, String> row = new Dictionary <string, string>()
{
{ "Date", date.ToString("ddd dd MMM yyyy") },
{ "Present", present.ToString() },
{ "Lates", lates.ToString() },
{ "Cuts", cuts.ToString() },
{ "Excused", excused.ToString() },
{ "Total", (cuts + lates + present + excused).ToString() }
};
if (other > 0)
{
row.Add("Ambiguous Marking", other.ToString());
}
csv.Add(row);
}
Dictionary <String, String> totalRow = new Dictionary <string, string>()
{
{ "Date", "Totals" },
{ "Present", totalPresent.ToString() },
{ "Lates", totalLates.ToString() },
{ "Cuts", totalCuts.ToString() },
{ "Excused", totalExcused.ToString() },
{ "Total", (totalPresent + totalLates + totalCuts + totalExcused).ToString() }
};
if (totalOther > 0)
{
totalRow.Add("Ambiguous Marking", totalOther.ToString());
}
csv.Add(totalRow);
return(csv);
}
}
public void Detach(AcademicYear academicYear)
{
_context.Entry(academicYear).State = EntityState.Detached;
}
//this method is enabled when add student method is clicked
private void addStudent_Click(object sender, EventArgs e)
{
String fname = "", lname = "", maj = "", nameSt = name.Text;
String zidSt = zid.Text;
int flag = 0, yr = 0;
output.Text = "";
if (nameSt.Contains(",")) //checks if the name contains ,
{
String[] st = nameSt.Split(',');
fname = st[1];
lname = st[0];
flag = 1;
}
else //or display that they should enter full name
{
flag++;
output.AppendText("Please enter full name (Lastname, Firstname)\n");
}
if (zidSt.Contains("z") || zidSt.Contains("Z")) //if the zid contains z then we trim it
{
zidSt = zidSt.Trim(new char[] { 'z', 'Z' });
if (zidSt.Count() == 7) //checking whether the zid is valid or not
{
flag = 1;
}
else
{
flag++;
output.AppendText("Please enter valid 7 digit Z-ID\n");
}
}
else if (zidSt.Count() == 7)
{
flag = 1;
}
else
{
flag++;
output.AppendText("Please enter valid 7 digit Z-ID\n");
}
if (Convert.ToInt32(majorCombo.SelectedIndex) != 0) //to check if the major is selected
{
maj = Convert.ToString(((KeyValuePair <string, string>)majorCombo.SelectedItem).Value);
flag = 1;
}
else
{
flag++;
output.AppendText("Please select major\n");
}
AcademicYear ay = AcademicYear.None;
if (Convert.ToInt32(yearCombo.SelectedIndex) != 0) //to check if the year is selected
{
yr = Convert.ToInt32(yearCombo.SelectedIndex);
ay = (AcademicYear)Enum.Parse(typeof(AcademicYear), Convert.ToString(yr));
flag = 1;
}
else
{
flag++;
output.AppendText("Please select academic year\n");
}
if (flag == 1)
{
PublicVariables.studentlist.Add(new Student(Convert.ToUInt32(zidSt), fname, lname, maj, ay, 0));
list_of_students.Items.Add(zid.Text + " -- " + (fname) + " , " + (lname));
PublicVariables.studentCount++;
output.AppendText("Student is added!!");
Form1_Load(sender, e);
}
}
public void Delete(AcademicYear academicYear)
{
this.academicYearRepository.Delete(academicYear);
this.academicYearRepository.SaveChanges();
}
public AcademicYear Update(AcademicYear itemToUpdate)
{
_context.Entry(itemToUpdate).State = EntityState.Modified;
_context.SaveChanges();
return(itemToUpdate);
}
public void Add(AcademicYear entity)
{
AcademicYearDAL dalObject = new AcademicYearDAL();
dalObject.Add(entity);
}
public void Edit(AcademicYear entity)
{
AcademicYearDAL dalObject = new AcademicYearDAL();
dalObject.Edit(entity);
}
public void Add(StudentResult type)
{
lock (type)
{
if (Count == Date.Length)
{
var newLength = Date.Length + 1000;
var _Date = new System.DateTime[newLength];
Date.CopyTo(_Date);
Date = _Date;
var _ExamResultId = new string[newLength];
ExamResultId.CopyTo(_ExamResultId);
ExamResultId = _ExamResultId;
var _StudentId = new string[newLength];
StudentId.CopyTo(_StudentId);
StudentId = _StudentId;
var _AcademicYear = new string[newLength];
AcademicYear.CopyTo(_AcademicYear);
AcademicYear = _AcademicYear;
var _Semester = new string[newLength];
Semester.CopyTo(_Semester);
Semester = _Semester;
var _Credit = new int[newLength];
Credit.CopyTo(_Credit);
Credit = _Credit;
var _ProgramId = new string[newLength];
ProgramId.CopyTo(_ProgramId);
ProgramId = _ProgramId;
var _Level = new string[newLength];
Level.CopyTo(_Level);
Level = _Level;
var _RegisteredCourseId = new string[newLength];
RegisteredCourseId.CopyTo(_RegisteredCourseId);
RegisteredCourseId = _RegisteredCourseId;
var _Grade = new string[newLength];
Grade.CopyTo(_Grade);
Grade = _Grade;
var _GradePoint = new decimal[newLength];
GradePoint.CopyTo(_GradePoint);
GradePoint = _GradePoint;
var _ClassMark = new decimal[newLength];
ClassMark.CopyTo(_ClassMark);
ClassMark = _ClassMark;
var _ExamMark = new decimal[newLength];
ExamMark.CopyTo(_ExamMark);
ExamMark = _ExamMark;
var _TotalMark = new decimal[newLength];
TotalMark.CopyTo(_TotalMark);
TotalMark = _TotalMark;
var _Scoring = new bool[newLength];
Scoring.CopyTo(_Scoring);
Scoring = _Scoring;
var _LecturerId = new string[newLength];
LecturerId.CopyTo(_LecturerId);
LecturerId = _LecturerId;
}
Date.Span[Count] = type.Date;
ExamResultId.Span[Count] = type.ExamResultId;
StudentId.Span[Count] = type.StudentId;
AcademicYear.Span[Count] = type.AcademicYear;
Semester.Span[Count] = type.Semester;
Credit.Span[Count] = type.Credit;
ProgramId.Span[Count] = type.ProgramId;
Level.Span[Count] = type.Level;
RegisteredCourseId.Span[Count] = type.RegisteredCourseId;
Grade.Span[Count] = type.Grade;
GradePoint.Span[Count] = type.GradePoint;
ClassMark.Span[Count] = type.ClassMark;
ExamMark.Span[Count] = type.ExamMark;
TotalMark.Span[Count] = type.TotalMark;
Scoring.Span[Count] = type.Scoring;
LecturerId.Span[Count] = type.LecturerId;
}
}
public Student(uint zid, string lName, string fName, string majorStr, float cumGPA, AcademicYear ay)
{
if (zid > 1000000)
{
zID = zid;
FirstName = fName;
LastName = lName;
Major = majorStr;
CumulativeGPA = cumGPA;
AcademicYears = ay;
NumOfCreditHoursEnrolled = 0;
}
else
{
throw new Exception("Invalid Student Z-ID.");
}
}
// Helpers
private AcademicYear CreateSingleAcademicYear(
AcademicYear academicYear, AcademicYear previousAcademicYear, int highestGrade)
{
academicYear.IsActive = true;
previousAcademicYear.IsActive = false;
academicYear.SchoolThemes = this.CreateSchoolThemes(previousAcademicYear.SchoolThemes, academicYear);
IList <Grade> previousAcademicYearGrades = previousAcademicYear.Grades ?? new List <Grade>();
academicYear.Grades = this.CreateGrades(previousAcademicYearGrades, academicYear, highestGrade);
foreach (var grade in academicYear.Grades)
{
IList <Subject> previousYearCurrentGradeSubjects = new List <Subject>();
Grade previousAcademicYearCurrentGrade = previousAcademicYearGrades
.FirstOrDefault(g => g.GradeYear == grade.GradeYear);
if (previousAcademicYearCurrentGrade != null)
{
previousYearCurrentGradeSubjects = previousAcademicYearCurrentGrade.Subjects;
}
else
{
previousYearCurrentGradeSubjects = new List <Subject>();
}
grade.Subjects = this.CreateGradeSubjects(grade, previousYearCurrentGradeSubjects);
IList <SchoolClass> previousYearPreviousGradeClasses = new List <SchoolClass>();
if (previousAcademicYear.Grades != null && previousAcademicYear.Grades.Any() && grade.GradeYear > 1)
{
previousYearPreviousGradeClasses =
previousAcademicYear.Grades.First(g => g.GradeYear == grade.GradeYear - 1).SchoolClasses;
}
IList <SchoolClass> previousYearCurrentGradeClasses = new List <SchoolClass>();
if (previousAcademicYearCurrentGrade != null && previousAcademicYearCurrentGrade.SchoolClasses != null)
{
previousYearCurrentGradeClasses =
previousAcademicYearCurrentGrade.SchoolClasses;
}
this.CreateGradeSchoolClasses(
grade, previousYearPreviousGradeClasses, previousYearCurrentGradeClasses);
foreach (var schoolClass in grade.SchoolClasses)
{
SchoolClass oldSchoolClass = new SchoolClass();
if (previousAcademicYear.Grades != null &&
previousAcademicYear.Grades.Any() &&
grade.GradeYear > 1)
{
oldSchoolClass = previousYearPreviousGradeClasses
.FirstOrDefault(sc => sc.ClassLetter == schoolClass.ClassLetter);
}
schoolClass.Students = this.CreateSchoolClassStudents(oldSchoolClass);
}
}
this.CreateTeachers(academicYear.Grades, previousAcademicYearGrades);
this.academicYearRepository.Add(academicYear);
this.academicYearRepository.SaveChanges();
return(academicYear);
}
