public ActionResult Details(int id)
        {
            ViewBag.CurrentUserId = Permissions.User.Id;
            var model = DafRepository.Find(id);

            if (model == null)
            {
                return(this.RedirectToAction("Index"));
            }
            TryValidateModel(model);
            model.UploadedFile = model.FileName;
            ViewBag.IsValid    = ModelState.IsValid;
            ViewBag.CanDelete  = Permissions.CanDeleteDaf(model.Status);
            if (model == null)
            {
                throw new HttpException(404, Resources.Resource.NotFound);
            }
            else
            {
                CC.Web.Attributes.LocalizationAttributeBase.SetCulture(model.Culture);
                if (Request.IsJsonRequest())
                {
                    return(this.MyJsonResult(model));
                }
                else
                {
                    return(View(model));
                }
            }
        }
        public ActionResult Delete(int id)
        {
            var model = DafRepository.Find(id);

            if (model == null)
            {
                throw new HttpException(404, Resources.Resource.NotFound);
            }
            var canDelete = Permissions.CanDeleteDaf(model.Status);

            if (!canDelete)
            {
                throw new HttpException(403, Resources.Resource.NotAllowed);
            }

            DafRepository.Remove(id);

            return(RedirectToAction("Index"));
        }
        public ActionResult DetailsPost(int id, CC.Data.Models.DafDetails postData, HttpPostedFileBase file)
        {
            ViewBag.CurrentUserId = Permissions.User.Id;
            ModelState.Clear();

            var model = DafRepository.Find(id);

            if (model == null)
            {
                return(this.RedirectToAction("Index"));
            }
            else
            {
                CC.Web.Attributes.LocalizationAttributeBase.SetCulture(model.Culture);

                if (postData.Questions.Any(f => !f.SelectedAnswerId.HasValue) && !User.IsInRole(FixedRoles.Admin))
                {
                    ModelState.AddModelError(string.Empty, Resources.Resource.FormNotFullyFilled);
                }

                if (model.Status != Daf.Statuses.Open)
                {
                    ModelState.AddModelError(string.Empty, Resources.Resource.DafIsNotEditableInCurrentStatus);
                }

                if (Request.IsJsonRequest())
                {
                    if (model.DownloadedTo != null)
                    {
                        var deviceId = this.GetDeviceId();
                        if (string.Equals(model.DownloadedTo, deviceId))
                        {
                            model.UploadedAt   = DateTime.Now;
                            model.UploadedBy   = this.Permissions.User.Id;
                            model.UploadedTo   = this.GetDeviceId();
                            model.DownloadedAt = null;
                            model.DownloadedBy = null;
                            model.DownloadedTo = null;
                        }
                        else
                        {
                            ModelState.AddModelError(string.Empty, Resources.Resource.DafTakenOfflineOnAnotherDevice);
                        }
                    }
                }

                if (model.EvaluatorId == default(int) && !User.IsInRole(FixedRoles.Admin))
                {
                    ModelState.AddModelError(string.Empty, Resources.Resource.OnlyAdminIsAllowedToModifyEvaluatorField);
                }
                if (User.IsInRole(FixedRoles.DafEvaluator))
                {
                    if (postData.EvaluatorId != Permissions.User.Id)
                    {
                        if (file == null && (string.IsNullOrEmpty(postData.UploadedFile) || model.EvaluatorId != postData.EvaluatorId))
                        {
                            ModelState.AddModelError(string.Empty, Resources.Resource.FileIsRequired);
                        }
                        if (!postData.Disclaimer)
                        {
                            model.Disclaimer = postData.Disclaimer;
                            ModelState.AddModelError(string.Empty, Resources.Resource.DafCreateDisclaimerRequired);
                        }
                    }
                }
                if ((User.IsInRole(FixedRoles.Admin) || User.IsInRole(FixedRoles.DafEvaluator)) && postData.EvaluatorId != default(int))
                {
                    if (model.Status != Daf.Statuses.Open)
                    {
                        ModelState.AddModelError(string.Empty, Resources.Resource.EvaluatorCantBeChangedWhenDafIsNotOpen);
                    }
                    else
                    {
                        model.EvaluatorId = postData.EvaluatorId;
                        var evaluator = db.Users.SingleOrDefault(f => f.Id == model.EvaluatorId);
                        if (evaluator != null)
                        {
                            model.EvaluatorName = (evaluator.FirstName + " " + evaluator.LastName).NullIfEmptyOrWhiteSpace() ?? evaluator.UserName;
                        }
                    }
                }
                if (User.IsInRole(FixedRoles.DafEvaluator) && model.AgencyId != Permissions.User.AgencyId)
                {
                    throw new HttpException(403, Resources.Resource.NotAllowed);
                }

                if (postData.AssessmentDate.HasValue)
                {
                    if ((postData.AssessmentDate.Value.Date > model.CreateDate.Date || postData.AssessmentDate.Value.Date < model.CreateDate.Date.AddDays(-14)) && (!User.IsInRole(FixedRoles.Admin) || postData.Status != Daf.Statuses.Open))
                    {
                        ModelState.AddModelError(string.Empty, Resources.Resource.AssessmentOutOfRange);
                    }
                }

                if (postData.EffectiveDate.Date > DateTime.Today && (!User.IsInRole(FixedRoles.Admin) || postData.Status != Daf.Statuses.Open) || postData.EffectiveDate < postData.AssessmentDate)
                {
                    ModelState.AddModelError(string.Empty, Resources.Resource.EffectiveOutOfRange);
                }

                if (User.IsInRole(FixedRoles.Admin))
                {
                    var x =                     /*model.GovernmentHours != postData.GovernmentHours ||
                                                 * model.ExceptionalHours != postData.ExceptionalHours ||*/
                            !model.Questions.Select(f => f.SelectedAnswerId).SequenceEqual(postData.Questions.Select(f => f.SelectedAnswerId));
                    if (x)
                    {
                        ModelState.AddModelError(string.Empty, Resources.Resource.DafEditIsNotAllowed);
                    }
                }

                if (User.IsInRole(FixedRoles.DafEvaluator) && model.Status == Daf.Statuses.Open)
                {
                    foreach (var q in model.Questions)
                    {
                        q.SelectedAnswerId = postData.Questions.Where(f => f.Id == q.Id).Select(f => f.SelectedAnswerId).FirstOrDefault();
                    }
                    if (file != null)
                    {
                        model.FileName = file.FileName;
                        SaveFile(model.Id, file);
                    }
                }
                if (Request.IsJsonRequest())
                {
                    var missingAnswers = model.Questions.Where(f => f.SelectedAnswerId == null);
                    if (missingAnswers.Any())
                    {
                        ModelState.AddModelError("", "Please fill in Answers: " + string.Join(", ", missingAnswers.Select(f => f.Text).Take(3)));
                    }
                }

                model.AssessmentDate = postData.AssessmentDate;
                if (Request.IsJsonRequest())
                {
                    model.EffectiveDate         = postData.EffectiveDate;
                    model.UserConsentObtainedAt = postData.UserConsentObtainedAt;
                }
                //model.GovernmentHours = postData.GovernmentHours;
                //model.ExceptionalHours = postData.ExceptionalHours;
                model.EvaluatorPosition = postData.EvaluatorPosition;
                model.Comments          = postData.Comments;

                TryValidateModel(model);
                if (ModelState.IsValid)
                {
                    DafRepository.Update(model);
                }
            }

            if (Request.IsJsonRequest())
            {
                if (this.ModelState.IsValid)
                {
                    return(this.MyJsonResult(model));
                }
                else
                {
                    return(this.MyJsonResult(new
                    {
                        errors = this.ModelState.ValidationErrorMessages()
                    }, 400));
                }
            }
            else
            {
                ViewBag.IsValid   = ModelState.IsValid;
                ViewBag.CanDelete = Permissions.CanDeleteDaf(model.Status);
                return(View(model));
            }
        }