public async Task <IActionResult> AddVersion(PaperVersionsAddViewModel model)
        {
            if (model == null)
            {
                StatusMessage = "Error. Something went wrong.";
                return(View());
            }
            if (model.File == null || model.File.Length == 0)
            {
                StatusMessage = "Error. File is missing or broken.";
                return(View(model));
            }

            var user = await _userManager.GetUserAsync(HttpContext.User);

            var paper = _paperRepository.GetPaper(model.PaperId);

            if (paper == null)
            {
                StatusMessage = "Error. Paper do not exists.";
                return(RedirectToAction("MyPapers", "Papers"));
            }

            if (paper.Status != 1)
            {
                StatusMessage = "Error. You cannot add new version.";
                return(RedirectToAction("MyPapers", "Papers"));
            }
            var participancy = _participanciesRepository.GetParticipancy(paper.ParticipancyId);

            if (paper.Participancy.User.Id != user.Id)
            {
                StatusMessage = "Error. You cannot add version of this paper.";
                return(RedirectToAction("MyPapers", "Papers"));
            }

            if (!model.File.FileName.EndsWith(".doc") && !model.File.FileName.EndsWith(".docx") && !model.File.FileName.EndsWith(".pdf") && !model.File.FileName.EndsWith(".odt"))
            {
                StatusMessage = "Error. File has forbidden extension.(Only .doc .docx .pdf .odt allowed)";
                return(RedirectToAction("Add", new { id = model.PaperId }));
            }
            if (ModelState.IsValid)
            {
                string newFileName = Guid.NewGuid().ToString() + model.File.FileName.Substring(model.File.FileName.Length - 4);
                var    path        = Path.Combine(
                    Directory.GetCurrentDirectory(), "wwwroot\\Papers",
                    newFileName);

                using (var stream = new FileStream(path, FileMode.Create))
                {
                    await model.File.CopyToAsync(stream);
                }
                var paperVersion = new PaperVersionDTO
                {
                    PaperId          = model.PaperId,
                    OriginalFileName = model.File.FileName.Split('\\').Last(),
                    FileName         = newFileName,
                    Status           = 0
                };
                var newVersionId = _paperVersionRepository.AddPaperVersion(paperVersion);
                paper = _paperRepository.GetPaper(paper.Id);

                var differentJustCreatedVersion = paper.PaperVersions.FirstOrDefault(v => v.Status == 0 && v.Id != newVersionId);
                var versionWithMinorChanges     = paper.PaperVersions.FirstOrDefault(v => v.Status == 4);
                var pastVersionsWithReviews     = paper.PaperVersions.Where(v => (v.Status == 4 || v.Status == 5) && v.Reviews.Count() >= 2).OrderByDescending(v => v.CreationDate);
                if (differentJustCreatedVersion != null)
                {
                    _paperVersionRepository.SetStatusVersionRejected(differentJustCreatedVersion.Id);
                }
                else if (versionWithMinorChanges != null)
                {
                    _paperVersionRepository.SetStatusVersionAccepted(newVersionId);
                    _paperRepository.SetStatuAccepted(paper.Id);
                }
                if (pastVersionsWithReviews.Count() >= 1)
                {
                    var lastReviews = pastVersionsWithReviews.First().Reviews.Where(r => r.Recommendation != 5 && r.Recommendation != 1);
                    foreach (var critic in lastReviews)
                    {
                        var review = new ReviewDTO
                        {
                            CriticId       = critic.CriticId,
                            PaperVersionId = newVersionId,
                            Deadline       = DateTime.Now.AddMonths(1)
                        };
                        _reviewRepository.CreateReview(review);
                    }
                    _paperVersionRepository.SetStatusWaitingForReview(newVersionId);
                }

                StatusMessage = "Version has beed added.";
                return(RedirectToAction("MyPaper", "Papers", new { id = model.PaperId }));
            }
            StatusMessage = "Error. Entered data is not valid.";
            return(RedirectToAction("MyPapers", "Papers"));
        }
        public async Task <IActionResult> AddReview(AddReviewViewModel model)
        {
            var user = await _userManager.GetUserAsync(HttpContext.User);

            var existingReview = _reviewRepository.GetReview(model.Id);

            if (user.Id != existingReview.CriticId)
            {
                StatusMessage = "Error. You cannot review this file.";
                return(RedirectToAction(nameof(MyReviews)));
            }
            if (existingReview.FileName != null)
            {
                StatusMessage = "Error. You can review this paper only once.";
                return(RedirectToAction(nameof(MyReviews)));
            }
            if (model.File == null || model.File.Length == 0)
            {
                StatusMessage = "Error. File is missing or broken.";
                return(View(model));
            }
            if (!model.File.FileName.EndsWith(".doc") && !model.File.FileName.EndsWith(".docx") && !model.File.FileName.EndsWith(".pdf") && !model.File.FileName.EndsWith(".odt"))
            {
                StatusMessage = "Error. File has forbidden extension.(Only .doc .docx .pdf .odt allowed)";
                return(RedirectToAction("AddReview", new { id = model.Id }));
            }
            if (ModelState.IsValid)
            {
                string newFileName = Guid.NewGuid().ToString() + model.File.FileName.Substring(model.File.FileName.Length - 4);
                var    path        = Path.Combine(
                    Directory.GetCurrentDirectory(), "wwwroot\\Reviews",
                    newFileName);

                using (var stream = new FileStream(path, FileMode.Create))
                {
                    await model.File.CopyToAsync(stream);
                }

                var review = Mapper.Map <ReviewDTO>(model);
                review.OriginalFileName = model.File.FileName.Split('\\').Last();
                review.FileName         = newFileName;
                review.CompletionDate   = DateTime.Now;


                var result = _reviewRepository.AddReview(review);

                if (result == 1)
                {
                    var reviews = _reviewRepository.GetPaperVersionReviews(existingReview.PaperVersionId);
                    if (reviews.Where(r => r.Recommendation == 2).Count() >= 2)
                    {
                        _paperVersionRepository.SetStatusVersionAccepted(existingReview.PaperVersionId);
                        _paperRepository.SetStatuAccepted(existingReview.PaperVersion.PaperId);
                    }
                    else if (reviews.Where(r => r.Recommendation == 5).Count() >= 2)
                    {
                        _paperVersionRepository.SetStatusVersionRejected(existingReview.PaperVersionId);
                        _paperRepository.SetStatusDiscarded(existingReview.PaperVersion.PaperId);
                    }
                    else if (reviews.Where(r => r.Recommendation == 3).Count() >= 2)
                    {
                        _paperVersionRepository.SetStatusMinorRevision(existingReview.PaperVersionId);
                    }
                    else if (reviews.Where(r => r.Recommendation == 4).Count() >= 2)
                    {
                        _paperVersionRepository.SetStatusMajorRevision(existingReview.PaperVersionId);
                    }
                    else if (reviews.Where(r => r.Recommendation == 3).Count() >= 1 && reviews.Where(r => r.Recommendation == 2).Count() >= 1)
                    {
                        _paperVersionRepository.SetStatusMinorRevision(existingReview.PaperVersionId);
                    }
                    else if (reviews.Where(r => r.Recommendation == 4).Count() >= 1 && (reviews.Where(r => r.Recommendation == 2 || r.Recommendation == 3).Count() >= 1))
                    {
                        _paperVersionRepository.SetStatusMajorRevision(existingReview.PaperVersionId);
                    }
                    else if (reviews.Where(r => r.Recommendation > 1).Count() == 2 && reviews.Where(r => r.Recommendation == 5).Count() == 1)
                    {
                        //wysłac info do admina o wyborze kolejnego
                    }

                    StatusMessage = "Succesfully added.";
                    return(RedirectToAction(nameof(MyReviews)));
                }

                StatusMessage = "Error. If you see this error. Contact with administrator.";
                return(RedirectToAction(nameof(MyReviews)));
            }
            StatusMessage = "Error. Entered data is not valid.";
            return(View(model));
        }