public ActionResult MarkAsComplete(int id)
        {
            if (this.IsThesisStudentOrTeacher(id))
            {
                var thesis = this.Data.Theses.GetById(id);

                thesis.FinishedAt = DateTime.Now;
                thesis.IsComplete = true;
                this.Data.SaveChanges();

                var logger = this.loggerCreator.Create(this.Data);
                var userId = this.User.Identity.GetUserId();
                var log    = new ThesisLog
                {
                    ThesisId   = id,
                    UserId     = userId,
                    LogType    = LogType.CompletedThesis,
                    ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", id)
                };
                logger.Log(log);

                CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_COMPLEDED_THESIS);

                return(RedirectToAction("ThesisProfile", "Thesis", new { id = id }));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult AddFinalEvaluation(int id, CreateFinalEvaluationViewModel model)
        {
            var thesis = this.Data.Theses.GetById(id);
            var userId = this.User.Identity.GetUserId();

            if (this.IsThesisTeacher(userId, thesis) && thesis.FinalEvaluation == null)
            {
                if (ModelState.IsValid)
                {
                    thesis.FinishedAt      = DateTime.Now;
                    thesis.FinalEvaluation = model.FinalEvaluation;
                    this.Data.SaveChanges();

                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = id,
                        UserId     = userId,
                        LogType    = LogType.AddedFinalEvaluation,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", id)
                    };
                    logger.Log(log);

                    CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_ADDED_FINAL_EVALUATION);

                    return(RedirectToAction("ThesisProfile", "Thesis", new { id = id }));
                }

                return(View(model));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult AddPart(int id, IList <CreateOrUpdateThesisPartViewModel> parts)
        {
            if (this.IsThesisStudentOrTeacher(id))
            {
                if (ModelState.IsValid)
                {
                    UpdateParts(id, parts);
                    var userId = this.User.Identity.GetUserId();
                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = id,
                        UserId     = userId,
                        LogType    = LogType.AddedPart,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", id)
                    };
                    logger.Log(log);

                    CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_ADDED_PART);

                    return(RedirectToAction("ThesisProfile", "Thesis", new { id = id }));
                }

                return(View(parts));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult AddReview(int id, CreateReviewViewModel model)
        {
            var thesis = this.Data.Theses.GetById(id);
            var userId = this.User.Identity.GetUserId();

            if (this.IsThesisTeacher(userId, thesis) && thesis.Evaluation == null)
            {
                if (ModelState.IsValid)
                {
                    var reviewId = 0;

                    try
                    {
                        reviewId = SaveNewReview(model);
                    }
                    catch (Exception)
                    {
                        return(RedirectToAction("ThesisProfile", "Thesis", new { id = id }));
                    }

                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = id,
                        UserId     = userId,
                        LogType    = LogType.AddedReview,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", id)
                    };
                    logger.Log(log);

                    CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_ADDED_REVIEW);

                    return(RedirectToAction("ThesisProfile", "Thesis", new { id = id }));
                }
                var reviewers = this.Data.Teachers.All()
                                .OrderBy(t => t.User.FirstName)
                                .ThenBy(t => t.User.LastName)
                                .AsQueryable()
                                .Project()
                                .To <SupervisorDropDownListITemViewModel>()
                                .ToList();

                ViewBag.ReviewerId = new SelectList(reviewers, "Id", "FullName");

                return(View(model));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult AddVersion(int id, CreateVersionViewModel model)
        {
            if (this.IsThesisStudentOrTeacher(id))
            {
                if (ModelState.IsValid && model.Archive != null && model.Archive.ContentLength > 0)
                {
                    var userId = this.User.Identity.GetUserId();

                    var versionId = 0;

                    try
                    {
                        versionId = SaveNewVersion(model);
                    }
                    catch (Exception)
                    {
                        return(View(model));
                    }

                    UpdateParts(model.Id, model.ThesisParts);
                    UpdatePages(model.Id, model.Pages);

                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = model.Id,
                        UserId     = userId,
                        LogType    = LogType.AddedVersion,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "Version", versionId)
                    };
                    logger.Log(log);

                    CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_ADDED_VERSION);

                    return(RedirectToAction("Version", "Thesis", new { id = versionId }));
                }

                return(View(model));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult Create(CreateThesisViewModel model)
        {
            if (this.User.IsInRole(GlobalConstants.STUDENT))
            {
                if (ModelState.IsValid)
                {
                    var userId = this.User.Identity.GetUserId();
                    var thesis = Mapper.Map <Thesis>(model);
                    thesis.StudentId = userId;

                    this.Data.Theses.Add(thesis);

                    this.Data.SaveChanges();

                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = thesis.Id,
                        UserId     = userId,
                        LogType    = LogType.CreatedThesis,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", thesis.Id)
                    };
                    logger.Log(log);

                    CreateNotification(thesis.Id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_INVITATION);

                    return(RedirectToAction("ThesisProfile", "Thesis", new { id = thesis.Id }));
                }

                var superviosors = this.Data.Teachers.All()
                                   .AsQueryable()
                                   .Project()
                                   .To <SupervisorDropDownListITemViewModel>()
                                   .ToList();

                ViewBag.SupervisorId = new SelectList(superviosors, "Id", "FullName");

                return(View(model));
            }

            return(RedirectToAction("Index", "Storage"));
        }
        public ActionResult Version(int id, CreateCommentViewModel comment)
        {
            var version = this.Data.Versions.GetById(id);

            if (this.IsThesisStudentOrTeacher(version.ThesisId))
            {
                if (ModelState.IsValid)
                {
                    var userId = this.User.Identity.GetUserId();

                    var newComment = Mapper.Map <Comment>(comment);
                    newComment.UserId    = userId;
                    newComment.VersionId = id;

                    this.Data.Comments.Add(newComment);
                    this.Data.SaveChanges();

                    var logger = this.loggerCreator.Create(this.Data);
                    var log    = new ThesisLog
                    {
                        ThesisId   = version.ThesisId,
                        UserId     = userId,
                        LogType    = LogType.AddedComment,
                        ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "Version", id)
                    };
                    logger.Log(log);

                    CreateNotification(version.ThesisId, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_COMMENTED);

                    return(RedirectToAction("Version", "Thesis", new { id = id }));
                }

                return(View(comment));
            }

            return(RedirectToAction("Index", "Storage"));
        }