public IHttpActionResult PutUpdatedCommentHeader(int section_id, int term_id, [FromBody] String content)
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                int header = -1;
                try
                {
                    header = db.CommentHeaders.Where(h => h.SectionIndex == section_id && h.TermIndex == term_id).Single().id;
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e)));
                }

                CommentHeader headerParagraph = db.CommentHeaders.Find(header);

                content = CommentLetter.ConvertFromBase64String(content);

                headerParagraph.HTML = CommentLetter.CleanTags(content);

                try
                {
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, e)));
                }

                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new CommentHeaderInfo(header))));
            }
        }
Exemplo n.º 2
0
        public IHttpActionResult CreateNewCommentHeader(int section_id, [FromBody] String content)
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                Section section = db.Sections.Find(section_id);
                if (section == null)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Section Id."))));
                }

                WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
                int id = ((WebhostIdentity)principal.Identity).User.Id;

                Faculty self = db.Faculties.Find(id);

                if (!self.Sections.Contains(section))
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new UnauthorizedAccessException("You are not a teacher for this class."))));
                }

                int termId = DateRange.GetCurrentOrLastTerm();

                if (section.CommentHeaders.Where(h => h.TermIndex == termId).Count() > 0)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Header Already Exists.  Use PUT to Update."))));
                }

                CommentHeader newHeader = new CommentHeader()
                {
                    id           = db.CommentHeaders.OrderBy(h => h.id).ToList().Last().id + 1,
                    SectionIndex = section_id,
                    TermIndex    = termId,
                    HTML         = ""
                };

                content = CommentLetter.ConvertFromBase64String(content);

                newHeader.HTML = CommentLetter.CleanTags(content);

                try
                {
                    db.CommentHeaders.Add(newHeader);
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, e)));
                }

                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.Created, new CommentHeaderInfo(newHeader.id), "text/json")));
            }
        }
        public IHttpActionResult GetPdfComment(int id)
        {
            CommentLetter comment = new CommentLetter(id);

            byte[] pdfData = comment.Publish().Save();

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);

            response.Content = new ByteArrayContent(pdfData);
            response.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("inline")
            {
                FileName = "comment.pdf"
            };
            response.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/pdf");

            return(ResponseMessage(response));
        }
Exemplo n.º 4
0
        /// <summary>
        /// Initialize Info object.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="includeStudentCommentData"></param>
        public CommentHeaderInfo(int id, bool includeStudentCommentData = false)
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                CommentHeader header = db.CommentHeaders.Find(id);
                if (header == null)
                {
                    throw new ArgumentException("Invalid Comment Header Id.");
                }

                Id           = id;
                SectionId    = header.SectionIndex;
                TermId       = header.TermIndex;
                Term         = string.Format("{0} {1}", header.Term.Name, header.Term.StartDate.Year);
                SectionTitle = String.Format("[{0}] {1}", header.Section.Block.LongName, header.Section.Course.Name);

                // Convert HTML to Base64String.
                if (header.RTF.Length <= 0)
                {
                    HtmlContent = CommentLetter.ConvertToBase64String(header.HTML);
                }
                else
                {
                    RtfContnet = header.RTF;
                }

                StudentCommentIds = header.StudentComments.Select(com => com.id).ToList();

                if (includeStudentCommentData)
                {
                    StudentComments = new List <StudentCommentInfo>();
                    foreach (int comId in StudentCommentIds)
                    {
                        StudentComments.Add(new StudentCommentInfo(comId));
                    }
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Initialize a student comment.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="includeHeader"></param>
        public StudentCommentInfo(int id, bool includeHeader = false)
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                StudentComment comment = db.StudentComments.Find(id);
                if (comment == null)
                {
                    throw new ArgumentException("Invalid Student Comment.");
                }

                Grades = new GradeInfo()
                {
                    EngagementGrade = comment.EngagementGrade.Name,
                    ExamGrade       = comment.ExamGrade.Name,
                    FinalGrade      = comment.FinalGrade.Name,
                    TrimesterGrade  = comment.TermGrade.Name
                };

                Id       = id;
                Student  = new StudentInfo(comment.StudentID);
                HeaderId = comment.HeaderIndex;
                if (comment.RTF.Length <= 0)
                {
                    HtmlContent = CommentLetter.ConvertToBase64String(comment.HTML);
                }
                else
                {
                    RtfContent = comment.RTF;
                }

                if (includeHeader)
                {
                    Header = new CommentHeaderInfo(HeaderId);
                }
            }
        }
        public async Task <IHttpActionResult> PostNewCommentHeader(int section_id, int term_id)
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                if (db.CommentHeaders.Where(h => h.SectionIndex == section_id && h.TermIndex == term_id).Count() > 0)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, new ArgumentException("Comment Header already Exists."))));
                }

                CommentHeader headerParagraph = new CommentHeader()
                {
                    id           = db.CommentHeaders.OrderBy(h => h.id).ToList().Last().id + 1,
                    SectionIndex = section_id,
                    TermIndex    = term_id
                };

                String content = await Request.Content.ReadAsStringAsync();

                content = CommentLetter.ConvertFromBase64String(content);

                headerParagraph.HTML = CommentLetter.CleanTags(content);

                db.CommentHeaders.Add(headerParagraph);

                try
                {
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, e)));
                }

                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new CommentHeaderInfo(headerParagraph.id))));
            }
        }
Exemplo n.º 7
0
        public IHttpActionResult PutUpdatedStudentComment(int section_id, int student_id, [FromBody] StudentCommentInfo info, [FromUri] String format = "rtf")
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                Section section = db.Sections.Find(section_id);
                if (section == null)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Section Id."))));
                }

                if (section.Students.Where(s => s.ID == student_id).Count() <= 0)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Student Id."))));
                }

                WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
                int id = ((WebhostIdentity)principal.Identity).User.Id;

                Faculty self = db.Faculties.Find(id);

                if (!self.Sections.Contains(section))
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new UnauthorizedAccessException("You are not a teacher for this class."))));
                }

                int termId = DateRange.GetCurrentOrLastTerm();

                if (section.CommentHeaders.Where(h => h.TermIndex == termId).Count() <= 0)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NoContent, new ArgumentException("No Comment Header for this Term is saved."))));
                }

                CommentHeader header = section.CommentHeaders.Where(h => h.TermIndex == termId).Single();

                if (header.StudentComments.Where(com => com.StudentID == student_id).Count() <= 0)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, new ArgumentException("No Comment for this student saved."))));
                }

                StudentComment comment = header.StudentComments.Where(com => com.StudentID == student_id).Single();

                Dictionary <String, int> GradeEntries = CommentLetter.GetGradeTableEntryData();

                comment.EffortGradeID = GradeEntries[info.Grades.EngagementGrade];
                comment.ExamGradeID   = GradeEntries[info.Grades.ExamGrade];
                comment.TermGradeID   = GradeEntries[info.Grades.TrimesterGrade];
                comment.FinalGradeID  = GradeEntries[info.Grades.FinalGrade];

                if (format.Equals("html"))
                {
                    comment.HTML = CommentLetter.ConvertFromBase64String(info.HtmlContent);
                }
                else
                {
                    comment.RTF = info.RtfContent;
                }

                try
                {
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, e)));
                }

                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new StudentCommentInfo(header.StudentComments.Where(com => com.StudentID == student_id).Single().id))));
            }
        }
Exemplo n.º 8
0
        public IHttpActionResult PutUpdatedCommentHeader(int section_id, [FromBody] String content, [FromUri] String format = "rtf")
        {
            using (WebhostEntities db = new WebhostEntities())
            {
                Section section = db.Sections.Find(section_id);
                if (section == null)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new ArgumentException("Invalid Section Id."))));
                }

                WebhostUserPrinciple principal = (WebhostUserPrinciple)ActionContext.RequestContext.Principal;
                int id = ((WebhostIdentity)principal.Identity).User.Id;

                Faculty self = db.Faculties.Find(id);

                if (!self.Sections.Contains(section))
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new UnauthorizedAccessException("You are not a teacher for this class."))));
                }

                int termId = DateRange.GetCurrentOrLastTerm();

                CommentHeader header;

                if (section.CommentHeaders.Where(h => h.TermIndex == termId).Count() <= 0)
                {
                    header = new CommentHeader()
                    {
                        id           = db.CommentHeaders.OrderBy(h => h.id).ToList().Last().id + 1,
                        HTML         = "",
                        SectionIndex = section_id,
                        TermIndex    = termId
                    };
                    db.CommentHeaders.Add(header);
                }
                else
                {
                    header = section.CommentHeaders.Where(h => h.TermIndex == termId).Single();
                }

                content = CommentLetter.ConvertFromBase64String(content);

                if (format.Equals("html"))
                {
                    header.HTML = CommentLetter.ConvertFromBase64String(content);
                }
                else
                {
                    header.RTF = Convert.FromBase64String(content);
                }

                try
                {
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, e)));
                }

                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new CommentHeaderInfo(header.id), "text/json")));
            }
        }
Exemplo n.º 9
0
        protected void SaveBtn_Click(object sender, EventArgs e)
        {
            if (SelectedSectionId == -1)
            {
                State.log.WriteLine("{0} {1}:  Cannot Save with no section selected.", DateTime.Today.ToShortDateString(), DateTime.Now.ToLongTimeString());
                LogWarning("Cannot save with no section selected.");
                return;
            }
            if (Saving)
            {
                State.log.WriteLine("{1} {0}:  Aborted multiple Saving attempts.", DateTime.Now.ToLongTimeString(), DateTime.Today.ToShortDateString());
                LogWarning("Aborted multiple Saving Attempts.");
                return;
            }
            using (WebhostEntities db = new WebhostEntities())
            {
                Saving = true;
                if (HeaderPanel.Visible)
                {
                    CommentHeader header = db.CommentHeaders.Where(h => h.id == LoadedHeaderId).Single();
                    State.log.WriteLine("{0} {1}:  Saving Header Paragraph.", DateTime.Today.ToShortDateString(), DateTime.Now.ToLongTimeString());
                    // Save the Header!
                    if (HeaderEditor.Content.Length < header.HTML.Length)
                    {
                        State.log.WriteLine("{0} {1}:  Warning--suspicious overwrite:{2}Original:{2}{3}{2}Replacement:{2}{4}", DateTime.Today.ToShortDateString(),
                                            DateTime.Now.ToLongTimeString(), Environment.NewLine, header.HTML, HeaderEditor.Content);
                        WebhostEventLog.CommentLog.LogWarning("Suspicious Overwrite:{0}Original:{0}{1}{0}========================================================{0}Replacement:{0}{2}",
                                                              Environment.NewLine, header.HTML, HeaderEditor.Content);
                    }

                    String html = HeaderEditor.Content;
                    String temp = html;
                    html = CommentLetter.CleanTags(html);

                    if (!temp.Equals(html))
                    {
                        WebhostEventLog.CommentLog.LogWarning("CleanTags method changed:{0}{1}{0}============================================================={0}Into:{0}{2}",
                                                              Environment.NewLine, temp, html);
                    }

                    WebhostEventLog.CommentLog.LogInformation("Saving Header:{0}{1}", Environment.NewLine, html);

                    HeaderEditor.Content = html;

                    header.HTML = HeaderEditor.Content;
                    HeaderHTML  = HeaderEditor.Content;
                }

                if (LoadedCommentId != -1)
                {
                    State.log.WriteLine("{0} {1}:  Saving Student Comment.", DateTime.Today.ToShortDateString(), DateTime.Now.ToLongTimeString());
                    StudentComment comment = db.StudentComments.Where(com => com.id == LoadedCommentId).Single();

                    if (StudentEditor.Content.Length < comment.HTML.Length)
                    {
                        State.log.WriteLine("{0} {1}:  Warning--suspicious overwrite:{2}Original:{2}{3}{2}Replacement:{2}{4}", DateTime.Today.ToShortDateString(),
                                            DateTime.Now.ToLongTimeString(), Environment.NewLine, comment.HTML, StudentEditor.Content);
                        WebhostEventLog.CommentLog.LogWarning("Suspicious Overwrite:{0}Original:{0}{1}{0}========================================================{0}Replacement:{0}{2}",
                                                              Environment.NewLine, comment.HTML, StudentEditor.Content);
                    }


                    String html = StudentEditor.Content;

                    String temp = html;
                    html = CommentLetter.CleanTags(html);

                    if (!temp.Equals(html))
                    {
                        WebhostEventLog.CommentLog.LogWarning("CleanTags method changed:{0}{1}{0}============================================================={0}Into:{0}{2}",
                                                              Environment.NewLine, temp, html);
                    }

                    WebhostEventLog.CommentLog.LogInformation("Saving Comment for {2} {3}:{0}{1}", Environment.NewLine, html, comment.Student.FirstName, comment.Student.LastName);

                    StudentEditor.Content = html;

                    comment.HTML          = StudentEditor.Content;
                    comment.EffortGradeID = CommentGrades.EffortGradeID;
                    comment.FinalGradeID  = CommentGrades.FinalGradeID;
                    comment.TermGradeID   = CommentGrades.TrimesterGradeID;
                    comment.ExamGradeID   = CommentGrades.ExamGradeID;
                    StudentCommentHTML    = StudentEditor.Content;
                }

                db.SaveChanges();
                State.log.WriteLine("{0} {1}:  Changes saved to the Database.", DateTime.Today.ToShortDateString(), DateTime.Now.ToLongTimeString());
                WebhostEventLog.CommentLog.LogInformation("Save Complete.");
            }

            Saving = false;
        }
        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));
            }
        }