/Gradebook/Controllers/GradesController.cs

using System.Security.Permissions;

using AutoMapper;

using Gradebook.Contracts;

using Gradebook.ViewModels;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Http;

using System.Web.Http;



namespace Gradebook.Controllers

{

    public class GradesController : ApiControllerBase

    {

        public GradesController(IGradebookUow uow) : base(uow) { }



        // GET /api/grades

        [ActionName("Default")]

        public IEnumerable<ViewModels.TaskResult> Get(int? task, int? student = 0)

        {

            var grades = Unit.Grades.GetAll().AsEnumerable();



            if (task.HasValue)

            {

                if (!Unit.Tasks.Contains(task.Value))

                    throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



                grades = Unit.Grades.GetAllByTask(task.Value);

            }



            if (student.HasValue && student != 0)

            {

                if (!Unit.Students.Contains(student.Value))

                    throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



                grades = grades.Where(x => x.StudentId == student.Value);

            }



            var model = grades.Select(Mapper.Map<Model.Grade, ViewModels.TaskResult>).ToList();



            model.ForEach(x =>

                {

                    if (Unit.Grades.Contains(x.TaskId, x.StudentId))

                    {

                        x.Rank = Unit.Grades.GetRank(x.TaskId, x.StudentId);

                        x.Rate = Unit.Grades.GetRate(x.TaskId, x.StudentId);

                    }

                });



            return model;

        }



        // GET /api/grades/{int}

        [ActionName("Default")]

        public ViewModels.Grade Get(int studentId, int taskId)

        {

            if (!Unit.Grades.Contains(taskId, studentId))

                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



            var grade = Unit.Grades.Read(new { StudentId = studentId, TaskId = taskId });



            return Mapper.Map<Model.Grade, ViewModels.Grade>(grade);

        }



        // POST /api/grades

        public HttpResponseMessage Post(ViewModels.Grade model)

        {

            if (ModelState.IsValid)

            {

                Unit.Grades.Create(model.TaskId, model.StudentId, model.Value, model.Comments);

                Unit.Commit();



                var response = Request.CreateResponse(HttpStatusCode.Created, model);

                var uri = Url.Link("DefaultApi", new { model.StudentId, model.TaskId });

                response.Headers.Location = new Uri(Request.RequestUri, uri);



                return response;

            }



            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));

        }



        // POST /api/grades/list

        [ActionName("List")]

        public HttpResponseMessage Post(IEnumerable<ViewModels.Grade> grades)

        {

            if (ModelState.IsValid)

            {

                foreach (var model in grades)

                {

                    if (Unit.Grades.Contains(model.TaskId, model.StudentId))

                    {

                        var grade = Unit.Grades.Read(model.TaskId, model.StudentId);



                        grade.Value = model.Value;

                        grade.Comments = model.Comments;



                        Unit.Grades.Update(grade);

                    }

                    else

                    {

                        Unit.Grades.Create(model.TaskId, model.StudentId, model.Value, model.Comments);

                    }

                }

                Unit.Commit();



                return Request.CreateResponse(HttpStatusCode.Created);

            }



            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));

        }



        // PUT /api/grades/studentId={int}&taskId={int}

        public HttpResponseMessage Put(int studentId, int taskId, int value)

        {

            var grade = Unit.Grades.Read(new { StudentId = studentId, TaskId = taskId });



            if (grade == null)

                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



            if (ModelState.IsValid)

            {

                grade.Value = value;



                Unit.Grades.Update(grade);

                Unit.Commit();



                return new HttpResponseMessage(HttpStatusCode.NoContent);

            }



            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));

        }



        // DELETE /api/grades/{int}

        public void Delete(int studentId, int taskId)

        {

            var game = Unit.Grades.Read(new { StudentId = studentId, TaskId = taskId });



            if (game == null)

                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



            Unit.Grades.Delete(new { StudentId = studentId, TaskId = taskId });

            Unit.Commit();



            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotAcceptable));

        }



        // GET /api/grades/class

        [ActionName("Class")]

        public IEnumerable<ViewModels.StudentResults> GetByClassCode(int code, int? term = 0, int? type = 0)

        {

            if (!Unit.ClassCodes.Contains(code))

                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



            var grades = Unit.Grades.GetAllByClassCode(code, term.GetValueOrDefault(), type.GetValueOrDefault())

                             .GroupBy(x => x.StudentId);



            foreach (var grade in grades)

            {

                var taskResults = grade.Select(Mapper.Map<Model.Grade, ViewModels.TaskResult>).ToList();



                taskResults.ForEach(x =>

                {

                    if (Unit.Grades.Contains(x.TaskId, x.StudentId))

                    {

                        x.Rank = Unit.Grades.GetRank(x.TaskId, x.StudentId);

                        x.Rate = Unit.Grades.GetRate(x.TaskId, x.StudentId);

                    }

                });



                var studentResults = new StudentResults

                {

                    StudentId = taskResults[0].StudentId,

                    StudentName = taskResults[0].StudentName,

                    Results = taskResults

                };



                yield return studentResults;

            }

        }



        // GET /api/grades/student

        [ActionName("Student")]

        public IEnumerable<ViewModels.TaskResult> GetByStudent(int student, int? code = 0)

        {

            if (!Unit.Tasks.Contains(student))

                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound));



            var grades = Unit.Grades.GetAllByStudent(student, code.GetValueOrDefault());

            var model = grades.Select(Mapper.Map<Model.Grade, ViewModels.TaskResult>).ToList();



            model.ForEach(x =>

            {

                if (Unit.Grades.Contains(x.TaskId, x.StudentId))

                {

                    x.Rank = Unit.Grades.GetRank(x.TaskId, x.StudentId);

                    x.Rate = Unit.Grades.GetRate(x.TaskId, x.StudentId);

                }

            });



            return model;

        }

    }

}