public virtual ActionResult UpdateDetail(CustomEditImpactIndicatoModel updatedModel)
        {
            var indicatorModel = ClientResultsMatrix.FindOneImpactIndicatorModel(
                new ImpactIndicatorSpecification()
            {
                ImpactIndicatorId = updatedModel.impactIndicator.ImpactIndicatorId
            });
            var impactModel = ClientResultsMatrix.FindOneImpactModel(
                new ImpactSpecification()
            {
                ImpactId = indicatorModel.ImpactId
            });

            updatedModel.impactIndicator.IntervalId = updatedModel.IntervalId;
            updatedModel.impactIndicator.AccessedByAdministrator = updatedModel.AccessedByAdministrator;
            updatedModel.impactIndicator.IsThirdInterval         = updatedModel.IsThirdInterval;
            ClientResultsMatrix.UpdateImpactIndicator(
                updatedModel.impactIndicator, IDBContext.Current.UserName);
            _cacheData.Remove(
                _impactsIndicatorCacheName, System.Web.Caching.CacheItemRemovedReason.Removed);

            return(RedirectToAction(
                       "Detail",
                       "ImpactIndicator",
                       new
            {
                resultsMatrixId = impactModel.ResultsMatrixId,
                impactId = impactModel.ImpactId,
                impactIndicatorId = updatedModel.impactIndicator.ImpactIndicatorId
            }));
        }
        public virtual ActionResult Edit(int impactId)
        {
            var impactModel = ClientResultsMatrix.FindOneImpactModel(new ImpactSpecification()
            {
                ImpactId = impactId
            });

            return(View(impactModel));
        }
        public virtual ActionResult EditDetail(int impactIndicatorId)
        {
            ImpactIndicatorModel indicatorModel = ClientResultsMatrix.FindOneImpactIndicatorModel(new ImpactIndicatorSpecification()
            {
                ImpactIndicatorId = impactIndicatorId
            });

            ImpactModel impactModel = ClientResultsMatrix.FindOneImpactModel(new ImpactSpecification()
            {
                ImpactId = indicatorModel.ImpactId
            });

            bool isLinked = (indicatorModel.PredefinedIndicator == null) ? false : true;

            // Start third interval validation
            var operationNumber = ClientResultsMatrix.FindOneModel(new IDB.MW.Domain.Contracts.Specifications.ResultsMatrixSpecification()
            {
                ResultsMatrixId = impactModel.ResultsMatrixId
            }).Operation.OperationNumber;

            // Check if the administrator is accessing
            var accessedByAdministrator = true;

            var resultsMatrix = ClientResultsMatrix.GetResultsMatrixModel(new OperationModel()
            {
                OperationNumber = operationNumber, AccessedByAdministrator = accessedByAdministrator
            });

            // End third interval validation
            CustomEditImpactIndicatoModel editImpactIndicatoModel = new CustomEditImpactIndicatoModel
            {
                impact          = impactModel,
                impactIndicator = indicatorModel,
                IsLinkedToPredefinedIndicator = isLinked,
                IntervalId = resultsMatrix.Interval.IntervalId,
                AccessedByAdministrator = accessedByAdministrator,
                IsThirdInterval         = resultsMatrix.IsThirdInterval,
                OperationNumber         = operationNumber
            };

            return(View(editImpactIndicatoModel));
        }
        public virtual ActionResult Detail(int resultsMatrixId, int impactId, int impactIndicatorId)
        {
            var impactModel = ClientResultsMatrix.FindOneImpactModel(new ImpactSpecification()
            {
                ImpactId = impactId
            });

            var impactIndicatorModel = impactModel.ImpactIndicators.Where(ii => ii.ImpactIndicatorId == impactIndicatorId).SingleOrDefault <ImpactIndicatorModel>();

            impactModel.ImpactIndicators.Clear();

            impactModel.ImpactIndicators.Add(impactIndicatorModel);

            var ResultMatrixModel = ClientResultsMatrix.FindOneModel(new IDB.MW.Domain.Contracts.Specifications.ResultsMatrixSpecification()
            {
                ResultsMatrixId = impactModel.ResultsMatrixId
            });

            ViewData["operationNumber"] = ResultMatrixModel.Operation.OperationNumber;

            var StateDraftId = ClientConvergenceMasterData.GetMasterDataId("VALIDATION_STAGE", "PMI_DRAFT");
            var isDraft      = false;

            if (ResultMatrixModel.ValidationStageId == StateDraftId)
            {
                isDraft = true;
            }

            ViewBag.isDraft    = isDraft;
            ViewBag.isEditable = ClientResultsMatrix.GetLightResultsMatrixModel(new ResultsMatrixModel()
            {
                ResultsMatrixId = ResultMatrixModel.ResultsMatrixId
            }).isEditable;

            return(View(impactModel));
        }
        public virtual ActionResult ReassignIndicator(
            int resultsMatrixId,
            int impactId,
            int impactIndicatorId,
            int intervalId,
            bool accessedByAdmin,
            bool isThirInterval)
        {
            int code = 0;

            try
            {
                ImpactIndicatorModel indicatorModel = ClientResultsMatrix.FindOneImpactIndicatorModel(
                    new ImpactIndicatorSpecification()
                {
                    ImpactIndicatorId = impactIndicatorId
                });

                ImpactModel currentImpactModel = ClientResultsMatrix.FindOneImpactModel(
                    new ImpactSpecification()
                {
                    ImpactId = indicatorModel.ImpactId
                });

                ImpactModel newImpactModel = ClientResultsMatrix.FindOneImpactModel(
                    new ImpactSpecification()
                {
                    ImpactId = impactId
                });

                if (indicatorModel != null && currentImpactModel != null && newImpactModel != null)
                {
                    IntervalModel interval = new IntervalModel()
                    {
                        IntervalId = intervalId
                    };
                    ClientResultsMatrix.ReassignIndicator(
                        new ResultsMatrixModel()
                    {
                        ResultsMatrixId         = resultsMatrixId,
                        AccessedByAdministrator = accessedByAdmin,
                        IsThirdInterval         = isThirInterval,
                        Interval = interval
                    },
                        currentImpactModel,
                        newImpactModel,
                        indicatorModel,
                        IDBContext.Current.UserName);
                    code = 503;
                }
            }
            catch (Exception)
            {
                code = 497;
            }

            var resultsMatrix = ClientResultsMatrix.FindOneModel(new IDB.MW.Domain.Contracts.Specifications.ResultsMatrixSpecification()
            {
                ResultsMatrixId = resultsMatrixId
            });

            _cacheData.Remove(_impactsIndicatorCacheName, System.Web.Caching.CacheItemRemovedReason.DependencyChanged);

            return(RedirectToAction("Edit", "Impacts", new { operationId = resultsMatrix.OperationId, resultsMatrixId = resultsMatrixId, code = code }));
        }