Example #1
0
        /// <summary>
        /// When replacing an existing chair of trustees/local govs with data from an existing governor, this method prepopulates the fields from the governor record.
        /// </summary>
        /// <param name="model"></param>
        /// <param name="viewModel"></param>
        private void PrepopulateFields(GovernorModel model, ReplaceChairViewModel viewModel)
        {
            viewModel.NewLocalGovernor = viewModel.NewLocalGovernor ?? new GovernorViewModel();

            viewModel.NewLocalGovernor.AppointingBodyId     = model.AppointingBodyId;
            viewModel.NewLocalGovernor.AppointmentEndDate   = new DateTimeViewModel(model.AppointmentEndDate);
            viewModel.NewLocalGovernor.AppointmentStartDate = new DateTimeViewModel(model.AppointmentStartDate);
            viewModel.NewLocalGovernor.DOB          = new DateTimeViewModel(model.DOB);
            viewModel.NewLocalGovernor.EmailAddress = model.EmailAddress;

            viewModel.NewLocalGovernor.GovernorTitleId = model.Person_TitleId;
            viewModel.NewLocalGovernor.FirstName       = model.Person_FirstName;
            viewModel.NewLocalGovernor.MiddleName      = model.Person_MiddleName;
            viewModel.NewLocalGovernor.LastName        = model.Person_LastName;

            viewModel.NewLocalGovernor.PreviousTitleId    = model.PreviousPerson_TitleId;
            viewModel.NewLocalGovernor.PreviousFirstName  = model.PreviousPerson_FirstName;
            viewModel.NewLocalGovernor.PreviousMiddleName = model.PreviousPerson_MiddleName;
            viewModel.NewLocalGovernor.PreviousLastName   = model.PreviousPerson_LastName;

            viewModel.NewLocalGovernor.TelephoneNumber = model.TelephoneNumber;
            viewModel.NewLocalGovernor.PostCode        = model.PostCode;

            viewModel.Urn = model.EstablishmentUrn;

            viewModel.SelectedPreviousExistingNonChairId = model.Id;
        }
        public async Task <ActionResult> ReplaceChair(int establishmentUrn, int gid)
        {
            var governor = await _governorsReadService.GetGovernorAsync(gid, User);

            var roles = new List <eLookupGovernorRole>
            {
                (eLookupGovernorRole)governor.RoleId
            };

            if (EnumSets.SharedGovernorRoles.Contains(governor.RoleId.Value))
            {
                var localEquivalent =
                    RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId);
                if (localEquivalent != null)
                {
                    roles.Add(localEquivalent.Value);
                }
            }
            else
            {
                roles.AddRange(RoleEquivalence.GetEquivalentToLocalRole((eLookupGovernorRole)governor.RoleId));
            }

            var governors = (await _governorsReadService.GetSharedGovernorsAsync(establishmentUrn, User)).Where(g => roles.Contains((eLookupGovernorRole)g.RoleId) && g.Id != gid).ToList();

            var model = new ReplaceChairViewModel
            {
                ExistingGovernorId = gid,
                GovernorFullName   = governor.GetFullName(),
                DateTermEnds       = new DateTimeViewModel(governor.AppointmentEndDate),
                NewLocalGovernor   = new GovernorViewModel
                {
                    DisplayPolicy = await _governorsReadService.GetEditorDisplayPolicyAsync((RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId.Value) ?? (eLookupGovernorRole)governor.RoleId.Value), false, User)
                },
                SharedGovernors = (await Task.WhenAll(governors.Select(async g => await SharedGovernorViewModel.MapFromGovernor(g, establishmentUrn, _cachedLookupService)))).ToList(),
                NewChairType    = ReplaceChairViewModel.ChairType.LocalChair,
                Role            = (eLookupGovernorRole)governor.RoleId,
                RoleName        = _nomenclatureService.GetGovernorRoleName((eLookupGovernorRole)governor.RoleId, eTextCase.Lowerase, false)
            };

            await PopulateSelectLists(model.NewLocalGovernor);

            await _layoutHelper.PopulateLayoutProperties(model, establishmentUrn, null, User);

            return(View(model));
        }
Example #3
0
        public async Task <ActionResult> ReplaceChair(ReplaceChairViewModel model)
        {
            if (ModelState.IsValid)
            {
                if (model.NewChairType == ReplaceChairViewModel.ChairType.SharedChair)
                {
                    var newGovernor = model.SharedGovernors.SingleOrDefault(s => s.Id == model.SelectedGovernorId);

                    var validation = await _governorsWriteService.AddSharedGovernorAppointmentAsync(model.SelectedGovernorId,
                                                                                                    model.Urn.Value,
                                                                                                    model.DateTermEnds.ToDateTime().Value.AddDays(1),
                                                                                                    newGovernor.AppointmentEndDate.ToDateTime(), User);

                    if (!validation.HasErrors)
                    {
                        var url =
                            $"{Url.RouteUrl("EstabDetails", new {id = model.Urn, saved = true})}#school-governance";
                        return(Redirect(url));
                    }

                    validation.ApplyToModelState(ControllerContext);
                }
                else
                {
                    var newGovernor = new GovernorModel
                    {
                        AppointingBodyId     = model.NewLocalGovernor.AppointingBodyId,
                        AppointmentEndDate   = model.NewLocalGovernor.AppointmentEndDate.ToDateTime(),
                        AppointmentStartDate = model.DateTermEnds.ToDateTime().Value.AddDays(1),
                        DOB                       = model.NewLocalGovernor.DOB.ToDateTime(),
                        EmailAddress              = model.NewLocalGovernor.EmailAddress,
                        EstablishmentUrn          = model.Urn,
                        Person_FirstName          = model.NewLocalGovernor.FirstName,
                        Person_MiddleName         = model.NewLocalGovernor.MiddleName,
                        Person_LastName           = model.NewLocalGovernor.LastName,
                        Person_TitleId            = model.NewLocalGovernor.GovernorTitleId,
                        PreviousPerson_FirstName  = model.NewLocalGovernor.PreviousFirstName,
                        PreviousPerson_MiddleName = model.NewLocalGovernor.PreviousMiddleName,
                        PreviousPerson_LastName   = model.NewLocalGovernor.PreviousLastName,
                        PreviousPerson_TitleId    = model.NewLocalGovernor.PreviousTitleId,
                        PostCode                  = model.NewLocalGovernor.PostCode,
                        RoleId                    = (int)(RoleEquivalence.GetLocalEquivalentToSharedRole(model.Role) ?? model.Role),
                        TelephoneNumber           = model.NewLocalGovernor.TelephoneNumber
                    };

                    var validation = await _governorsWriteService.ValidateAsync(newGovernor, User);

                    if (!validation.HasErrors)
                    {
                        GovernorModel oldGovernorModel = null;
                        if (model.Reinstate)
                        {
                            oldGovernorModel =
                                await _governorsReadService.GetGovernorAsync(model.ExistingGovernorId, User);
                        }

                        await _governorsWriteService.SaveAsync(newGovernor, User);

                        if (model.SelectedPreviousExistingNonChairId.HasValue)
                        {
                            await RetireGovernorAsync(model.SelectedPreviousExistingNonChairId.Value,
                                                      model.DateTermEnds.ToDateTime().GetValueOrDefault());
                        }

                        if (model.Reinstate) // re-instate the old chair to be the non-chair equivalent role.
                        {
                            await ReInstateChairAsNonChairAsync(model.ExistingGovernorId,
                                                                newGovernor.AppointmentStartDate.GetValueOrDefault(),
                                                                (oldGovernorModel?.AppointmentEndDate).GetValueOrDefault(),
                                                                eLookupGovernorRole.ChairOfLocalGoverningBody);
                        }

                        var url =
                            $"{Url.RouteUrl("EstabDetails", new {id = model.Urn, saved = true})}#school-governance";
                        return(Redirect(url));
                    }

                    validation.ApplyToModelState(ControllerContext, nameof(model.NewLocalGovernor), true);
                }
            }

            var governor = await _governorsReadService.GetGovernorAsync(model.ExistingGovernorId, User);

            var roles = new List <eLookupGovernorRole> {
                (eLookupGovernorRole)governor.RoleId
            };

            if (EnumSets.SharedGovernorRoles.Contains(governor.RoleId.Value))
            {
                var localEquivalent =
                    RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId);
                if (localEquivalent != null)
                {
                    roles.Add(localEquivalent.Value);
                }
            }
            else
            {
                roles.AddRange(RoleEquivalence.GetEquivalentToLocalRole((eLookupGovernorRole)governor.RoleId));
            }

            var governors = (await _governorsReadService.GetSharedGovernorsAsync(model.Urn.Value, User)).Where(g =>
                                                                                                               roles.Contains((eLookupGovernorRole)g.RoleId) && g.Id != model.ExistingGovernorId).ToList();

            model.NewLocalGovernor.DisplayPolicy = await _governorsReadService.GetEditorDisplayPolicyAsync(
                (RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId.Value) ??
                 (eLookupGovernorRole)governor.RoleId.Value), false, User);

            var sourceGovernors = (await Task.WhenAll(governors.Select(async g => await SharedGovernorViewModel.MapFromGovernor(g, model.Urn.Value, _cachedLookupService)))).ToList();

            if (model.SharedGovernors == null)
            {
                model.SharedGovernors = sourceGovernors;
            }
            else
            {
                for (var i = 0; i < model.SharedGovernors?.Count; i++)
                {
                    // if this is the one the user selected, we dont want to change any of the values they entered
                    if (model.SharedGovernors[i].Selected)
                    {
                        model.SharedGovernors[i].SharedWith =
                            sourceGovernors.First(x => x.Id == model.SharedGovernors[i].Id).SharedWith;
                    }
                    else
                    {
                        model.SharedGovernors[i]          = sourceGovernors.First(x => x.Id == model.SharedGovernors[i].Id);
                        model.SharedGovernors[i].Selected = false;
                    }
                }
            }

            await PopulateSelectLists(model.NewLocalGovernor);

            await _layoutHelper.PopulateLayoutProperties(model, model.Urn, null, User);


            var models = await _governorsReadService.GetGovernorListAsync(model.Urn, principal : User);

            var localGovernors = models.CurrentGovernors.Where(x => x.RoleId == (int)eLookupGovernorRole.LocalGovernor).OrderBy(x => x.Person_LastName).ToArray();

            if (model.SelectedPreviousExistingNonChairId.HasValue)
            {
                model.SelectedNonChair = localGovernors.FirstOrDefault(x => x.Id == model.SelectedPreviousExistingNonChairId);
            }

            model.ExistingNonChairs = localGovernors.Select(x => new SelectListItem
            {
                Text     = x.Person_FirstName + " " + x.Person_LastName,
                Value    = x.Id.ToString(),
                Selected = model.SelectedPreviousExistingNonChairId.HasValue &&
                           model.SelectedPreviousExistingNonChairId.Value == x.Id
            });


            return(View(model));
        }
Example #4
0
        public async Task <ActionResult> ReplaceChair(int establishmentUrn, int gid)
        {
            var replaceGovernorState = new
            {
                ReplacementGovernorId = Request.QueryString["rgid"].ToInteger(),
                DateTermEndsDay       = Request.QueryString["d"].ToInteger(),
                DateTermEndsMonth     = Request.QueryString["m"].ToInteger(),
                DateTermEndsYear      = Request.QueryString["y"].ToInteger(),
                Reinstate             = Request.QueryString["ri"] == "true"
            };

            var governor = await _governorsReadService.GetGovernorAsync(gid, User);

            var roles = new List <eLookupGovernorRole>
            {
                (eLookupGovernorRole)governor.RoleId
            };

            if (EnumSets.SharedGovernorRoles.Contains(governor.RoleId.Value))
            {
                var localEquivalent =
                    RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId);
                if (localEquivalent != null)
                {
                    roles.Add(localEquivalent.Value);
                }
            }
            else
            {
                roles.AddRange(RoleEquivalence.GetEquivalentToLocalRole((eLookupGovernorRole)governor.RoleId));
            }

            var governors = (await _governorsReadService.GetSharedGovernorsAsync(establishmentUrn, User)).Where(g => roles.Contains((eLookupGovernorRole)g.RoleId) && g.Id != gid).ToList();

            var model = new ReplaceChairViewModel
            {
                ExistingGovernorId = gid,
                GovernorFullName   = governor.GetFullName(),
                DateTermEnds       = new DateTimeViewModel(governor.AppointmentEndDate),
                NewLocalGovernor   = new GovernorViewModel
                {
                    DisplayPolicy = await _governorsReadService.GetEditorDisplayPolicyAsync((RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId.Value) ?? (eLookupGovernorRole)governor.RoleId.Value), false, User)
                },
                SharedGovernors = (await Task.WhenAll(governors.Select(async g => await SharedGovernorViewModel.MapFromGovernor(g, establishmentUrn, _cachedLookupService)))).ToList(),
                NewChairType    = ReplaceChairViewModel.ChairType.LocalChair,
                Role            = (eLookupGovernorRole)governor.RoleId,
                RoleName        = _nomenclatureService.GetGovernorRoleName((eLookupGovernorRole)governor.RoleId, eTextCase.Lowerase, false)
            };

            var models = await _governorsReadService.GetGovernorListAsync(establishmentUrn, principal : User);

            var localGovernors = models.CurrentGovernors.Where(x => x.RoleId == (int)eLookupGovernorRole.LocalGovernor).OrderBy(x => x.Person_LastName).ToArray();

            if (replaceGovernorState.ReplacementGovernorId.HasValue)
            {
                model.SelectedNonChair = localGovernors.FirstOrDefault(x => x.Id == replaceGovernorState.ReplacementGovernorId);
                PrepopulateFields(model.SelectedNonChair, model);
            }

            model.ExistingNonChairs = localGovernors.Select(x => new SelectListItem {
                Text = x.Person_FirstName + " " + x.Person_LastName, Value = x.Id.ToString(), Selected = replaceGovernorState.ReplacementGovernorId.HasValue && replaceGovernorState.ReplacementGovernorId.Value == x.Id
            });

            await PopulateSelectLists(model.NewLocalGovernor);

            await _layoutHelper.PopulateLayoutProperties(model, establishmentUrn, null, User);

            if (replaceGovernorState.DateTermEndsDay.HasValue)
            {
                model.Reinstate          = replaceGovernorState.Reinstate;
                model.DateTermEnds.Day   = replaceGovernorState.DateTermEndsDay;
                model.DateTermEnds.Month = replaceGovernorState.DateTermEndsMonth;
                model.DateTermEnds.Year  = replaceGovernorState.DateTermEndsYear;
            }

            return(View(model));
        }
        public async Task <ActionResult> ReplaceChair(ReplaceChairViewModel model)
        {
            if (ModelState.IsValid)
            {
                if (model.NewChairType == ReplaceChairViewModel.ChairType.SharedChair)
                {
                    var newGovernor = model.SharedGovernors.SingleOrDefault(s => s.Id == model.SelectedGovernorId);

                    await _governorsWriteService.AddSharedGovernorAppointmentAsync(model.SelectedGovernorId, model.Urn.Value,
                                                                                   model.DateTermEnds.ToDateTime().Value.AddDays(1),
                                                                                   newGovernor.AppointmentEndDate.ToDateTime(), User);

                    var url = $"{Url.RouteUrl("EstabDetails", new { id = model.Urn, saved = true })}#school-governance";
                    return(Redirect(url));
                }
                else
                {
                    var newGovernor = new GovernorModel
                    {
                        AppointingBodyId     = model.NewLocalGovernor.AppointingBodyId,
                        AppointmentEndDate   = model.NewLocalGovernor.AppointmentEndDate.ToDateTime(),
                        AppointmentStartDate = model.DateTermEnds.ToDateTime().Value.AddDays(1),
                        DOB                       = model.NewLocalGovernor.DOB.ToDateTime(),
                        EmailAddress              = model.NewLocalGovernor.EmailAddress,
                        EstablishmentUrn          = model.Urn,
                        Person_FirstName          = model.NewLocalGovernor.FirstName,
                        Person_MiddleName         = model.NewLocalGovernor.MiddleName,
                        Person_LastName           = model.NewLocalGovernor.LastName,
                        Person_TitleId            = model.NewLocalGovernor.GovernorTitleId,
                        PreviousPerson_FirstName  = model.NewLocalGovernor.PreviousFirstName,
                        PreviousPerson_MiddleName = model.NewLocalGovernor.PreviousMiddleName,
                        PreviousPerson_LastName   = model.NewLocalGovernor.PreviousLastName,
                        PreviousPerson_TitleId    = model.NewLocalGovernor.PreviousTitleId,
                        PostCode                  = model.NewLocalGovernor.PostCode,
                        RoleId                    = (int)(RoleEquivalence.GetLocalEquivalentToSharedRole(model.Role) ?? model.Role),
                        TelephoneNumber           = model.NewLocalGovernor.TelephoneNumber
                    };

                    var validation = await _governorsWriteService.ValidateAsync(newGovernor, User);

                    if (!validation.HasErrors)
                    {
                        await _governorsWriteService.SaveAsync(newGovernor, User);

                        var url = $"{Url.RouteUrl("EstabDetails", new { id = model.Urn, saved = true })}#school-governance";
                        return(Redirect(url));
                    }

                    validation.ApplyToModelState(ControllerContext, nameof(model.NewLocalGovernor));
                }
            }

            var governor = await _governorsReadService.GetGovernorAsync(model.ExistingGovernorId, User);

            var roles = new List <eLookupGovernorRole>
            {
                (eLookupGovernorRole)governor.RoleId
            };

            if (EnumSets.SharedGovernorRoles.Contains(governor.RoleId.Value))
            {
                var localEquivalent = RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId);
                if (localEquivalent != null)
                {
                    roles.Add(localEquivalent.Value);
                }
            }
            else
            {
                roles.AddRange(RoleEquivalence.GetEquivalentToLocalRole((eLookupGovernorRole)governor.RoleId));
            }

            var governors = (await _governorsReadService.GetSharedGovernorsAsync(model.Urn.Value, User)).Where(g => roles.Contains((eLookupGovernorRole)g.RoleId) && g.Id != model.ExistingGovernorId).ToList();

            model.NewLocalGovernor.DisplayPolicy = await _governorsReadService.GetEditorDisplayPolicyAsync((RoleEquivalence.GetLocalEquivalentToSharedRole((eLookupGovernorRole)governor.RoleId.Value) ?? (eLookupGovernorRole)governor.RoleId.Value), false, User);

            model.SharedGovernors = (await Task.WhenAll(governors.Select(async g => await SharedGovernorViewModel.MapFromGovernor(g, model.Urn.Value, _cachedLookupService)))).ToList();

            await PopulateSelectLists(model.NewLocalGovernor);

            await _layoutHelper.PopulateLayoutProperties(model, model.Urn, null, User);

            return(View(model));
        }