public virtual ActionResult Add()
        {
            var model = new InstitutionalAgreementConfigurationForm();

            // find the configuration for the currently signed in user's default affiliation
            var configuration = _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User));

            // if configuration exists, cannot add
            if (configuration != null)
            {
                model = Mapper.Map<InstitutionalAgreementConfigurationForm>(configuration);
            }
            else
            {
                // when configuration does not exist, get the default affiliation for the currently signed in user
                var person = GetConfigurationSupervisor();
                if (person == null)
                    return HttpNotFound();

                // allow the viewmodel to disclose the establishment official name
                model.ForEstablishmentOfficialName = person.DefaultAffiliation.Establishment.OfficialName;

                // add default options
                DefaultTypes.ForEach(option => model.AllowedTypeValues.Add(
                    new InstitutionalAgreementTypeValueForm { IsAdded = true, Text = option }));
                DefaultStatuses.ForEach(option => model.AllowedStatusValues.Add(
                    new InstitutionalAgreementStatusValueForm { IsAdded = true, Text = option }));
                DefaultContactTypes.ForEach(option => model.AllowedContactTypeValues.Add(
                    new InstitutionalAgreementContactTypeValueForm { IsAdded = true, Text = option }));

                // add a default empty allowed options
                AddEmptyAllowedOptions(model);
            }
            return View(model);
        }
        public virtual ActionResult Add(InstitutionalAgreementConfigurationForm model)
        {
            // do nothing without a viewmodel
            if (model != null)
            {
                if (ModelState.IsValid)
                {
                    // make sure configuration does not already exist
                    var configuration = _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User));
                    if (configuration != null)
                    {
                        SetFeedbackMessage("Your configuration has already been set up.");
                        return RedirectToAction(MVC.InstitutionalAgreements.ConfigurationForms.Add());
                    }

                    // configuration must have a ForEstablishmentId, and all items should be added
                    var person = _queryProcessor.Execute(new GetMyPersonQuery(User));
                    var establishment = person.DefaultAffiliation.Establishment;
                    model.ForEstablishmentId = establishment.RevisionId;

                    var command = new CreateOrUpdateConfigurationCommand(User)
                    {
                        IsCustomTypeAllowed = model.IsCustomTypeAllowed,
                        IsCustomStatusAllowed = model.IsCustomStatusAllowed,
                        IsCustomContactTypeAllowed = model.IsCustomTypeAllowed,
                        AllowedTypeValues = model.AllowedTypeValues.Select(x => x.Text),
                        AllowedStatusValues = model.AllowedStatusValues.Select(x => x.Text),
                        AllowedContactTypeValues = model.AllowedContactTypeValues.Select(x => x.Text),
                    };
                    _commandHandler.Handle(command);

                    SetFeedbackMessage("Module configuration was set up successfully.");
                    return RedirectToAction(MVC.InstitutionalAgreements.ManagementForms.Browse());
                }

                // add a default empty allowed options
                AddEmptyAllowedOptions(model);
                return View(model);
            }
            return HttpNotFound();
        }
示例#3
0
        public void ViewModel_InstitutionalAgreements_ConfigurationForms_InstitutionalAgreementConfigurationForm_ShouldBeConstructible()
        {
            var model = new InstitutionalAgreementConfigurationForm
            {
                RevisionId                 = 1,
                ForEstablishmentId         = null,
                EntityId                   = Guid.NewGuid(),
                IsCustomTypeAllowed        = false,
                IsCustomStatusAllowed      = false,
                IsCustomContactTypeAllowed = false,
                AllowedTypeValues          = new List <InstitutionalAgreementTypeValueForm>(),
                AllowedStatusValues        = new List <InstitutionalAgreementStatusValueForm>(),
                AllowedContactTypeValues   = new List <InstitutionalAgreementContactTypeValueForm>(),
                ExampleTypeInput           = "Example",
                ExampleStatusInput         = "Example",
                ExampleContactTypeInput    = "Example",
            };

            model.ShouldNotBeNull();
            model.EntityId.ShouldNotEqual(Guid.Empty);
            model.ForEstablishmentId.ShouldBeNull();
        }
        public void ViewModel_InstitutionalAgreements_ConfigurationForms_InstitutionalAgreementConfigurationForm_ShouldBeConstructible()
        {
            var model = new InstitutionalAgreementConfigurationForm
            {
                RevisionId = 1,
                ForEstablishmentId = null,
                EntityId = Guid.NewGuid(),
                IsCustomTypeAllowed = false,
                IsCustomStatusAllowed = false,
                IsCustomContactTypeAllowed = false,
                AllowedTypeValues = new List<InstitutionalAgreementTypeValueForm>(),
                AllowedStatusValues = new List<InstitutionalAgreementStatusValueForm>(),
                AllowedContactTypeValues = new List<InstitutionalAgreementContactTypeValueForm>(),
                ExampleTypeInput = "Example",
                ExampleStatusInput = "Example",
                ExampleContactTypeInput = "Example",
            };

            model.ShouldNotBeNull();
            model.EntityId.ShouldNotEqual(Guid.Empty);
            model.ForEstablishmentId.ShouldBeNull();
        }
 private static void AddEmptyAllowedOptions(InstitutionalAgreementConfigurationForm model)
 {
     model.AllowedTypeValues.Insert(0, new InstitutionalAgreementTypeValueForm { ConfigurationId = model.RevisionId });
     model.AllowedStatusValues.Insert(0, new InstitutionalAgreementStatusValueForm { ConfigurationId = model.RevisionId });
     model.AllowedContactTypeValues.Insert(0, new InstitutionalAgreementContactTypeValueForm { ConfigurationId = model.RevisionId });
 }
        public virtual JsonResult ValidateDuplicateOption(string type, List<string> values)
        {
            var model = new InstitutionalAgreementConfigurationForm();
            var validationResults = new List<ValidationResult>();
            var validationContext = new ValidationContext(model, null, null);
            var isValid = false;

            if (string.Compare(type, typeof(InstitutionalAgreementTypeValueForm).FullName, false, CultureInfo.InvariantCulture) == 0)
            {
                values.ForEach(t => model.AllowedTypeValues.Add(new InstitutionalAgreementTypeValueForm { Text = t }));
                validationContext.MemberName = "AllowedTypeValues";
                isValid = Validator.TryValidateProperty(model.AllowedTypeValues, validationContext, validationResults);
            }
            else if (string.Compare(type, typeof(InstitutionalAgreementStatusValueForm).FullName, false, CultureInfo.InvariantCulture) == 0)
            {
                values.ForEach(t => model.AllowedStatusValues.Add(new InstitutionalAgreementStatusValueForm { Text = t }));
                validationContext.MemberName = "AllowedStatusValues";
                isValid = Validator.TryValidateProperty(model.AllowedStatusValues, validationContext, validationResults);
            }
            else if (string.Compare(type, typeof(InstitutionalAgreementContactTypeValueForm).FullName, false, CultureInfo.InvariantCulture) == 0)
            {
                values.ForEach(t => model.AllowedContactTypeValues.Add(new InstitutionalAgreementContactTypeValueForm { Text = t }));
                validationContext.MemberName = "AllowedContactTypeValues";
                isValid = Validator.TryValidateProperty(model.AllowedContactTypeValues, validationContext, validationResults);
            }

            var errorMessage = (isValid)
                ? null
                : validationResults[0].ErrorMessage;

            return Json(new { IsValid = isValid, ErrorMessage = errorMessage, }, JsonRequestBehavior.AllowGet);
        }
        public virtual ActionResult Edit(InstitutionalAgreementConfigurationForm model)
        {
            if (model != null)
            {
                // look for current entity
                var existingEntity = _queryProcessor.Execute(
                    new GetInstitutionalAgreementConfigurationByGuidQuery(model.EntityId)
                        {
                            EagerLoad = new Expression<Func<InstitutionalAgreementConfiguration, object>>[]
                            {
                                c => c.ForEstablishment.Affiliates.Select(a => a.Person.User),
                                c => c.AllowedTypeValues,
                                c => c.AllowedStatusValues,
                                c => c.AllowedContactTypeValues,
                            },
                        });

                if (existingEntity == null)
                    return HttpNotFound();

                var compareConfiguration =
                    _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User));

                if (existingEntity.RevisionId != compareConfiguration.RevisionId || existingEntity.EntityId != compareConfiguration.EntityId)
                    ModelState.AddModelError(string.Empty, string.Format(
                        "You are not authorized to configure the Institutional Agreements module for {0}.", existingEntity.ForEstablishment.OfficialName));

                if (ModelState.IsValid)
                {
                    var command = new CreateOrUpdateConfigurationCommand(User, model.RevisionId)
                    {
                        IsCustomTypeAllowed = model.IsCustomTypeAllowed,
                        IsCustomStatusAllowed = model.IsCustomStatusAllowed,
                        IsCustomContactTypeAllowed = model.IsCustomTypeAllowed,
                        AllowedTypeValues = model.AllowedTypeValues.Select(x => x.Text),
                        AllowedStatusValues = model.AllowedStatusValues.Select(x => x.Text),
                        AllowedContactTypeValues = model.AllowedContactTypeValues.Select(x => x.Text),
                    };
                    _commandHandler.Handle(command);
                    SetFeedbackMessage("Module configuration was saved successfully.");
                    return RedirectToAction(MVC.InstitutionalAgreements.ConfigurationForms.Edit());
                }

                AddEmptyAllowedOptions(model);
                return View(model);
            }
            return HttpNotFound();
        }
        public virtual ActionResult Edit()
        {
            // even if there is no configuration, return default affiliation establishment info to view
            var model = new InstitutionalAgreementConfigurationForm();

            // find a configuration for the currently signed in user's default affiliation establishment
            var configuration = _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User));

            // when configuration exists, return corresponding viewmodel
            if (configuration != null)
            {
                model = Mapper.Map<InstitutionalAgreementConfigurationForm>(configuration);
                AddEmptyAllowedOptions(model);
            }
            else
            {
                // when configuration does not exist, get the default affiliation for the currently signed in user
                var person = GetConfigurationSupervisor();
                if (person == null)
                    return HttpNotFound();

                // allow the viewmodel to disclose the establishment official name
                model.ForEstablishmentOfficialName = person.DefaultAffiliation.Establishment.OfficialName;
            }
            return View(model);
        }