public IHttpActionResult GetCommentsForTerm(int term_id, int student_id)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
Term term = db.Terms.Find(term_id);
if (term == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new HttpError("Invalid Term Id"))));
}
Student student = db.Students.Find(student_id);
if (student == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new HttpError("Invalid Student Id"))));
}
List <int> student_comments = student.StudentComments.Where(com => com.CommentHeader.TermIndex == term_id).Select(com => com.id).ToList();
List <StudentCommentInfo> output = new List <StudentCommentInfo>();
foreach (int id in student_comments)
{
output.Add(new RequestHandlers.StudentCommentInfo(id, true));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, output)));
}
}
/// <summary>
/// Initialize StudentInfo given their Authorization Fingerprint.
/// </summary>
/// <param name="fingerprint"></param>
/// <exception cref="AccessViolationException">Thrown when the provided fingerprint is invalid.</exception>
public StudentInfo(byte[] fingerprint)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
Student student = null;
foreach (Student st in db.Students.Where(s => s.isActive && s.Fingerprints.Count > 0).ToList())
{
foreach (Fingerprint fp in st.Fingerprints.ToList())
{
if (fp.Value.SequenceEqual(fingerprint))
{
student = st;
break;
}
}
}
if (student == null)
{
throw new AccessViolationException("Unrecognized Fingerprint.");
}
Email = String.Format("{0}@dublinschool.org", student.UserName);
FirstName = student.FirstName;
LastName = student.LastName;
Id = student.ID;
GraduationYear = student.GraduationYear;
Advisor = new TeacherInfo(student.AdvisorID, true);
Groups = new List <string>();
this.Groups.Add("Students");
}
}
/// <summary>
/// Initialize an instance of the abstract UserInfo class as a Faculty member given the ID number.
/// </summary>
/// <param name="id"></param>
/// <param name="fullDetails"></param>
public TeacherInfo(int id, bool fullDetails = false)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
Faculty owner = db.Faculties.Find(id);
if (owner == null)
{
throw new ArgumentException("Invalid Faculty Id.");
}
UserName = owner.UserName;
Id = owner.ID;
if (fullDetails)
{
FirstName = owner.FirstName;
LastName = owner.LastName;
Email = String.Format("{0}@dublinschool.org", UserName);
Groups = new List <string>();
foreach (ApiPermissionGroup group in owner.ApiPermissionGroups.ToList())
{
Groups.Add(group.Name);
}
}
}
}
/// <summary>
/// Look up the <see cref="GradeTableEntry.id"/> given the text value of <see cref="GradeTableEntry.Name"/>.
/// </summary>
/// <param name="name"><see cref="GradeTableEntry.Name"/></param>
/// <returns><see cref="GradeTableEntry.id"/></returns>
/// <exception cref="ArgumentOutOfRangeException">Thrown if the provided Name is invalid.</exception>
public static int LookUpAttendanceMarking(String name)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
int year = DateRange.GetCurrentAcademicYear();
GradeTable table = db.GradeTables.Where(t => t.AcademicYearID == year && t.Name.Equals("Attendance")).Single();
if (table.GradeTableEntries.Where(g => g.Name.Equals(name)).Count() <= 0)
{
throw new ArgumentOutOfRangeException(nameof(name));
}
return(table.GradeTableEntries.Where(g => g.Name.Equals(name)).Single().id);
}
}
/// <summary>
/// Initialize information about a student's signup.
/// </summary>
/// <param name="activity_id"></param>
/// <param name="student_id"></param>
public StudentSignupInfo(int activity_id, int student_id)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
StudentSignup signup = db.StudentSignups.Find(activity_id, student_id);
if (signup == null)
{
throw new ArgumentException("Invalid Signup Id.");
}
ActivityId = activity_id;
Student = new RequestHandlers.StudentInfo(student_id);
IsRescended = signup.IsRescended;
IsBanned = signup.IsBanned;
Timestamp = signup.TimeStamp;
}
}
public IHttpActionResult PutSignupRequest(int activity_id, [FromUri] bool isRescend = false)
{
if (!DateRange.WeekendSignupsAreOpen)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, new MethodAccessException("Weekend Signups will be available at 11:30 on Friday."))));
}
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
int id = ((WebhostIdentity)principal.Identity).User.Id;
WeekendActivity activity = db.WeekendActivities.Find(activity_id);
if (activity == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new InvalidOperationException("Invalid Activity Id."))));
}
StudentSignup signup = db.StudentSignups.Find(activity_id, id);
if (signup == null) // New Signup!
{
signup = new WebhostAPI.StudentSignup()
{
ActivityId = activity_id,
Attended = false,
IsBanned = false,
IsRescended = isRescend,
StudentId = id,
TimeStamp = DateTime.Now
};
db.StudentSignups.Add(signup);
db.SaveChanges();
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.Created, new StudentSignupInfo(activity_id, id), "text/json")));
}
signup.IsRescended = isRescend;
signup.TimeStamp = DateTime.Now;
db.SaveChanges();
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new StudentSignupInfo(activity_id, id), "text/json")));
}
}
/// <summary>
/// Generate this given the <see cref="AttendanceMarking.id"/>.
/// </summary>
/// <param name="id"><see cref="AttendanceMarking.id"/></param>
/// <param name="fullDetails">Fills in all of the non-mandatory fields if true. Otherwise, only provides the mandatory data.</param>
public AttendanceInfo(int id, bool fullDetails = false)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
AttendanceMarking marking = db.AttendanceMarkings.Find(id);
Id = id;
StudentId = marking.StudentID;
SectionId = marking.SectionIndex;
Marking = marking.GradeTableEntry.Name;
Date = marking.AttendanceDate;
Notes = marking.Notes;
EnteredBy = new TeacherInfo(marking.SubmittedBy);
if (fullDetails)
{
Student = new StudentInfo(StudentId);
Section = new SectionInfo(SectionId);
}
}
}
public IHttpActionResult GetStudentAttendance()
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
int id = ((WebhostIdentity)principal.Identity).User.Id;
Student self = db.Students.Find(id);
DateRange thisWeek = DateRange.ThisAttendanceWeek;
List <AttendanceInfo> output = new List <RequestHandlers.AttendanceInfo>();
foreach (AttendanceMarking mark in self.AttendanceMarkings.Where(a => a.AttendanceDate >= thisWeek.Start && a.AttendanceDate <= thisWeek.End).ToList())
{
output.Add(new RequestHandlers.AttendanceInfo(mark.id));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, output, "text/json")));
}
}
public IHttpActionResult PutOverrideSignup(int activity_id, int student_id, [FromBody] StudentSignupInfo info)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WeekendActivity activity = db.WeekendActivities.Find(activity_id);
if (activity == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new InvalidOperationException("Invalid Activity Id."))));
}
Student student = db.Students.Find(student_id);
if (student == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new InvalidOperationException("Invalid Student Id."))));
}
StudentSignup signup = db.StudentSignups.Find(activity_id, student_id);
if (signup == null) // Create a new one.
{
signup = new WebhostAPI.StudentSignup()
{
ActivityId = activity_id,
StudentId = student_id,
IsBanned = info.IsBanned,
IsRescended = info.IsRescended,
Attended = false,
TimeStamp = DateTime.Now
};
db.StudentSignups.Add(signup);
db.SaveChanges();
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.Created, new StudentSignupInfo(activity_id, student_id), "text/json")));
}
signup.IsBanned = info.IsBanned;
signup.IsRescended = info.IsRescended;
signup.TimeStamp = DateTime.Now;
db.SaveChanges();
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new StudentSignupInfo(activity_id, student_id), "text/json")));
}
}
public IHttpActionResult GetWeekendActivities([FromUri] bool listStudents = true)
{
DateTime friday = DateRange.ThisFriday;
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
if (db.Weekends.Where(w => w.StartDate.Equals(friday)).Count() <= 0)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new InvalidOperationException("No Weekend Information for this week."))));
}
List <WeekendActivityInfo> info = new List <WeekendActivityInfo>();
Weekend thisWeekend = db.Weekends.Where(w => w.StartDate.Equals(friday)).Single();
foreach (WeekendActivity activity in thisWeekend.WeekendActivities.Where(act => !act.IsDeleted).OrderBy(act => act.DateAndTime).ToList())
{
info.Add(new RequestHandlers.WeekendActivityInfo(activity.id, listStudents));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, info, "text/json")));
}
}
public IHttpActionResult GetAttendances(int section_id, [FromUri] long datebinary = -1)
{
DateTime date = DateTime.Today;
if (datebinary != -1)
{
date = DateTime.FromBinary(datebinary);
}
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
int tid = ((WebhostIdentity)principal.Identity).User.Id;
Faculty self = db.Faculties.Find(tid);
Section section = db.Sections.Find(section_id);
if (section == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Section Id."))));
}
if (!section.Teachers.Contains(self))
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, new InvalidOperationException("That is not your class."))));
}
List <int> ids = section.AttendanceMarkings.Where(a => a.AttendanceDate.Equals(date)).Select(a => a.id).ToList();
List <AttendanceInfo> output = new List <AttendanceInfo>();
foreach (int id in ids)
{
output.Add(new RequestHandlers.AttendanceInfo(id));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, output, "text/json")));
}
}
/// <summary>
/// Get Student Info given the student Id.
/// </summary>
/// <param name="studentId">Valid Student Id</param>
/// <param name="shortVersion">Omit some data.</param>
/// <exception cref="ArgumentException">Thrown when the student Id is Invalid.</exception>
public StudentInfo(int studentId, bool shortVersion = true)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
Student student = db.Students.Find(studentId);
if (student == null)
{
throw new ArgumentException("Invalid Student Id");
}
UserName = student.UserName;
if (!shortVersion)
{
Email = String.Format("{0}@dublinschool.org", student.UserName);
Advisor = new TeacherInfo(student.AdvisorID, true);
}
FirstName = student.FirstName;
LastName = student.LastName;
Id = student.ID;
GraduationYear = student.GraduationYear;
Groups = new List <string>();
this.Groups.Add("Students");
}
}
public IHttpActionResult GetWeekendActivity(int id, [FromUri] bool listStudents)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WeekendActivity activity = db.WeekendActivities.Find(id);
if (activity == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentOutOfRangeException(nameof(id)))));
}
WeekendActivityInfo info = null;
try
{
info = new WeekendActivityInfo(id);
}
catch (Exception e)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e)));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, info, "text/json")));
}
}
/// <summary>
/// Get information about a given weekend activity.
/// </summary>
/// <param name="id"></param>
/// <param name="listStudents"></param>
public WeekendActivityInfo(int id, bool listStudents = true)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WeekendActivity activity = db.WeekendActivities.Find(id);
if (activity == null)
{
throw new ArgumentException("Invalid Activity Id.");
}
if (activity.IsDeleted)
{
throw new ArgumentException("That Activity has been marked deleted.");
}
Id = id;
Name = activity.Name;
DayAndTime = activity.DateAndTime;
IsOffCampus = activity.IsOffCampus;
MaxSignups = activity.MaxSignups;
Description = activity.Description;
Categories = new List <string>();
foreach (WeekendActivityCategory category in activity.WeekendActivityCategories.ToList())
{
Categories.Add(category.CategoryName);
}
if (listStudents)
{
Students = new List <RequestHandlers.StudentSignupInfo>();
foreach (StudentSignup signup in activity.StudentSignups.ToList())
{
Students.Add(new RequestHandlers.StudentSignupInfo(signup.ActivityId, signup.StudentId));
}
}
}
}
public IHttpActionResult GetMyComments(string term, int year)
{
if (!(new List <String>()
{
"Fall", "Winter", "Spring"
}).Contains(term))
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, new ArgumentOutOfRangeException(nameof(term)))));
}
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
Term theTerm = null;
try
{
theTerm = db.Terms.Where(t => t.Name.Equals(term) && t.StartDate.Year == year).Single();
}
catch (Exception e)
{ // Invalid term.
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e)));
}
WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
int id = ((WebhostIdentity)principal.Identity).User.Id;
byte[] zipData = null;
using (MemoryStream ms = new MemoryStream())
{
using (ZipArchive archive = new ZipArchive(ms, ZipArchiveMode.Create, true))
{
List <int> CommentIds = new List <int>();
if (((WebhostIdentity)(principal.Identity)).User.IsTeacher())
{
Faculty teacher = db.Faculties.Find(((WebhostIdentity)(principal.Identity)).User.Id);
foreach (Section section in teacher.Sections.Where(s => s.CommentHeaders.Where(ch => ch.TermIndex == theTerm.id).Count() > 0).ToList())
{
CommentHeader header = section.CommentHeaders.Where(ch => ch.TermIndex == theTerm.id).Single();
CommentIds.AddRange(header.StudentComments.Select(c => c.id).ToList());
}
}
else
{
Student student = db.Students.Find(((WebhostIdentity)(principal.Identity)).User.Id);
CommentIds.AddRange(student.StudentComments.Where(com => com.CommentHeader.TermIndex == theTerm.id).Select(com => com.id).ToList());
}
foreach (int cid in CommentIds)
{
CommentLetter letter = new CommentLetter(cid);
byte[] pdfData = letter.Publish().Save();
ZipArchiveEntry entry = archive.CreateEntry(CommentLetter.EncodeSafeFileName(letter.Title) + ".pdf");
using (Stream stream = entry.Open())
{
stream.Write(pdfData, 0, pdfData.Length);
}
}
}
ms.Seek(0, SeekOrigin.Begin);
zipData = new byte[ms.Length];
for (long i = 0; i < ms.Length; i++)
{
zipData[i] = (byte)ms.ReadByte();
}
}
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new ByteArrayContent(zipData);
response.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("inline")
{
FileName = "comments.zip"
};
response.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/octet-stream");
return(ResponseMessage(response));
}
}
public IHttpActionResult PutMyAttendance(int section_id, [FromBody] List <AttendanceInfo> content)
{
using (WebhostEntities db = new WebhostAPI.WebhostEntities())
{
WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
int tid = ((WebhostIdentity)principal.Identity).User.Id;
Faculty self = db.Faculties.Find(tid);
Section section = db.Sections.Find(section_id);
if (section == null)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Section Id."))));
}
if (!section.Teachers.Contains(self))
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, new InvalidOperationException("That is not your class."))));
}
List <int> outputIds = new List <int>();
int nextId = db.AttendanceMarkings.OrderBy(m => m.id).ToList().Last().id;
foreach (AttendanceInfo info in content)
{
if (info.SectionId != section_id)
{
continue;
}
AttendanceMarking marking = null;
if (section.AttendanceMarkings.Where(s => s.AttendanceDate.Equals(info.Date) && s.StudentID == info.StudentId).Count() > 0)
{
marking = section.AttendanceMarkings.Where(s => s.AttendanceDate.Equals(info.Date) && s.StudentID == info.StudentId).Single();
marking.MarkingIndex = AttendanceInfo.LookUpAttendanceMarking(info.Marking);
marking.SubmittedBy = tid;
if (!String.IsNullOrEmpty(info.Notes))
{
marking.Notes += String.Format("[{0} {1}] {2}", self.FirstName, self.LastName, info.Notes);
}
marking.SubmissionTime = DateTime.Now;
outputIds.Add(marking.id);
}
else
{
marking = new WebhostAPI.AttendanceMarking()
{
id = ++nextId,
AttendanceDate = info.Date,
MarkingIndex = AttendanceInfo.LookUpAttendanceMarking(info.Marking),
SubmittedBy = tid,
Notes = String.Format("[{0} {1}] {2}", self.FirstName, self.LastName, String.IsNullOrEmpty(info.Notes) ? "" : info.Notes),
StudentID = info.StudentId,
SectionIndex = info.SectionId,
SubmissionTime = DateTime.Now
};
db.AttendanceMarkings.Add(marking);
outputIds.Add(marking.id);
}
}
List <AttendanceInfo> output = new List <AttendanceInfo>();
foreach (int iid in outputIds)
{
output.Add(new RequestHandlers.AttendanceInfo(iid, true));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, output, "text/json")));
}
}
