Exemplo n.º 1
0
        public async Task <IActionResult> RemoveClaim(string scope, string claim)
        {
            var editScope = await _scopeService.Find(scope);

            if (editScope == null)
            {
                ModelState.AddModelError("FindScope", $"Scope with the name {scope} could not be found.");
                return(PartialView("ScopeClaimList"));
            }

            var claimToRemove = editScope.Claims.SingleOrDefault(scopeClaim => scopeClaim.Name == claim);

            if (claimToRemove == default(ScopeClaim))
            {
                ModelState.AddModelError("FindClaim", $"Claim with the name {claim} was not found in the scope {scope}");
                return(PartialView("ScopeClaimList"));
            }

            editScope.Claims.Remove(claimToRemove);
            await _scopeService.Save(editScope);

            var scopeModel = new ScopeModel(editScope);

            return(PartialView("ScopeClaimList", scopeModel));
        }
Exemplo n.º 2
0
        public async Task <IActionResult> EditClaim(ScopeClaimModel claimModel)
        {
            var claimScope = await _scopeService.Find(claimModel.ScopeName);

            if (claimScope == null)
            {
                ModelState.AddModelError("FindScope", $"Scope with the name {claimModel.ScopeName} could not be found.");
                return(PartialView("ScopeClaimList"));
            }

            var claimToRemove = claimScope.Claims.SingleOrDefault(scopeClaim => scopeClaim.Name == claimModel.ClaimId);

            if (claimToRemove == default(ScopeClaim))
            {
                ModelState.AddModelError("FindClaim", $"Claim with the name {claimModel.ClaimId} was not found in the scope {claimModel.ScopeName}");
                return(PartialView("ScopeClaimList"));
            }

            int index = claimScope.Claims.IndexOf(claimToRemove);

            claimScope.Claims[index] = claimModel.ScopeClaim;

            await _scopeService.Save(claimScope);

            var scopeModel = new ScopeModel(claimScope);

            ModelState.Clear();
            PartialViewResult partialViewResult = PartialView("ScopeClaimList", scopeModel);

            return(partialViewResult);
        }
        public HttpResponseMessage Put(int id, ScopeModel model)
        {
            if (!ModelState.IsValid)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.GetErrors()));
            }

            var scope = config.Scopes.All.SingleOrDefault(x => x.ID == id);

            if (scope == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            var query =
                (from a in this.config.Applications.All
                 from s in a.Scopes
                 where s.ID == id
                 select a);
            var app = query.Single();

            if (app.Scopes.Any(x => x.Name == model.Name && x.ID != id))
            {
                ModelState.AddModelError("", "That Scope name is already in use.");
                return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.GetErrors()));
            }

            scope.DisplayName = model.DisplayName;
            scope.Description = model.Description;
            scope.Emphasize   = model.Emphasize;

            config.SaveChanges();

            return(Request.CreateResponse(HttpStatusCode.NoContent));
        }
        public async Task UpdateScope_ScopeExists_ScopeNameIsAccurate(int id, string expectedUpdatedName, string expectedDescriptionName, bool expectedDefaultValue)
        {
            // Arrange
            IScopeRepository scopeRepository = new ScopeRepository(new SQLServerGateway(), new ConnectionStringData());
            ScopeModel       scopeModel      = new ScopeModel();

            scopeModel.Id          = id;
            scopeModel.Type        = expectedUpdatedName;
            scopeModel.Description = expectedDescriptionName;
            scopeModel.IsDefault   = expectedDefaultValue;

            // Act
            await scopeRepository.UpdateScope(scopeModel);

            var actual = await scopeRepository.GetScopeById(id);

            var actualName            = actual.Type;
            var actualDescriptionName = actual.Description;
            var actualDefaultValue    = actual.IsDefault;


            // Assert
            Assert.IsTrue(actualName == expectedUpdatedName &&
                          actualDescriptionName == expectedDescriptionName &&
                          actualDefaultValue == expectedDefaultValue);
        }
Exemplo n.º 5
0
        public override void FuncPreInitCreateView()
        {
            //get article types
            var articleTypes = new ArticleTypeModel <ArticleType>().GetData(isBlock: false);

            ViewBag.ArticleTypes = articleTypes.Select(x => new CustomSelectListItem()
            {
                Text = x.ArticleTypeName, Value = x.ArticleTypeID.ToString()
            });
            //get scopes
            var scopes = new ScopeModel <Scope>().GetData(isBlock: false);

            ViewBag.Scopes = scopes.Select(x => new CustomSelectListItem()
            {
                Text = x.ScopeName, Value = x.ScopeID.ToString()
            });
            //get authors
            var authors = new AuthorModel <Author>().GetData(isBlock: false);

            ViewBag.Authors = authors.Select(x => new CustomSelectListItem()
            {
                Text = x.AuthorName, Value = x.AuthorID.ToString()
            });
            base.FuncPreInitCreateView();
        }
Exemplo n.º 6
0
        public DataResult <int> AddScopeToApiResource(int apiResourceId, ScopeModel scope, IEnumerable <int> claimsIds)
        {
            var newScope = new ScopeEntity
            {
                Name                    = scope.Name,
                Description             = scope.Description,
                Required                = scope.Required,
                ShowInDiscoveryDocument = scope.ShowInDiscoveryDocument
            };

            try
            {
                var result = m_scopeUoW.AddScopeToApiResource(apiResourceId, newScope, claimsIds);
                return(Success(result));
            }
            catch (NoResultException <ApiResourceEntity> e)
            {
                m_logger.LogWarning(e);
                return(Error <int>(m_translator.Translate("invalid-api-resource-id"), DataResultErrorCode.ApiResourceNotExistId));
            }
            catch (DatabaseException e)
            {
                m_logger.LogWarning(e);
                return(Error <int>(e.Message));
            }
        }
Exemplo n.º 7
0
        public async Task <IActionResult> EditScope(EditScopeViewModel scope)
        {
            // INCREMENT SCOPE VERSION


            var NewScope = new ScopeModel
            {
                ProjectId   = scope.ProjectId,
                ParentScope = scope.ScopeParent,
                ScopeAuthor = scope.ScopeAuthor,

                ScopeExpectations   = scope.UpdatedScopeExpectations,
                ScopeGoals          = scope.UpdatedScopeGoals,
                ScopeLimitations    = scope.UpdatedScopeLimitations,
                ScopeManager        = scope.ScopeManager,
                ScopeSummary        = scope.UpdatedScopeSummary,
                ScopeVersion        = _context.Scopes.Where(S => S.ProjectId == scope.ProjectId).Count(),
                ScopeMaxPhaseNumber = scope.UpdatedScopePhaseNumberMax,
                ScopePhaseNumber    = scope.UpdatedScopePhaseNum,
                ScopePhase          = scope.UpdatedScopePhase,
                ScopeEndDate        = scope.ScopeEndDate,
                ScopeStartDate      = scope.ScopeStartDate,
            };

            _context.Scopes.Add(NewScope);
            await _context.SaveChangesAsync();

            ViewData["Msg"] = "Updated Scope and Added to Database";

            return(RedirectToAction("Index"));
        }
        public IActionResult DeleteScope(int apiId, int scopeId)
        {
            var scope = _configurationDbContext.Set <ApiScope>()
                        .Include(x => x.ApiResource)
                        .FirstOrDefault(x => x.Id == scopeId);

            return(View(ScopeModel.FromEntity(scope)));
        }
Exemplo n.º 9
0
        public void scope_model()
        {
            var scopeModel  = NewScopeModel;
            var scopeModel2 = new ScopeModel(scopeModel.ToScope());
            var scopeModel3 = NewScopeModel;

            scopeModel2.ShouldBe(scopeModel);
            scopeModel3.ShouldNotBe(scopeModel);
        }
Exemplo n.º 10
0
        public async Task Init()
        {
            await TestCleaner.CleanDatabase();

            var numTestRows = 20;

            IDataGateway                   dataGateway                   = new SQLServerGateway();
            IConnectionStringData          connectionString              = new ConnectionStringData();
            IScopeRepository               scopeRepository               = new ScopeRepository(dataGateway, connectionString);
            IResourceRepository            resourceRepository            = new ResourceRepository(dataGateway, connectionString);
            IClaimRepository               claimRepository               = new ClaimRepository(dataGateway, connectionString);
            IAccessPolicyRepository        accessPolicyRepository        = new AccessPolicyRepository(dataGateway, connectionString);
            IAccessPolicyPairingRepository accessPolicyPairingRepository = new AccessPolicyPairingRepository(dataGateway, connectionString);


            for (int i = 1; i <= numTestRows; ++i)
            {
                ResourceModel resourceModel = new ResourceModel();
                resourceModel.Id   = i;
                resourceModel.Name = "TestResource" + i;

                ScopeModel scopeModel = new ScopeModel();
                scopeModel.Id          = i;
                scopeModel.Type        = "TestScope" + i;
                scopeModel.Description = "TestDescription" + i;

                ClaimModel claimModel = new ClaimModel();
                claimModel.Id        = i;
                claimModel.Type      = "TestClaim" + i;
                claimModel.Value     = "TestDescription" + i;
                claimModel.IsDefault = true;

                var resourceId = await resourceRepository.CreateResource(resourceModel);

                var claimId = await claimRepository.CreateClaim(claimModel);

                var scopeId = await scopeRepository.CreateScope(scopeModel);

                AccessPolicyModel accessPolicyModel = new AccessPolicyModel();
                accessPolicyModel.Id         = i;
                accessPolicyModel.Name       = "TestAccessPolicy" + i;
                accessPolicyModel.ResourceId = resourceId;
                accessPolicyModel.Priority   = i % 4;

                var accessPolicyId = await accessPolicyRepository.CreateAccessPolicy(accessPolicyModel);

                AccessPolicyPairingModel accessPolicyPairingModel = new AccessPolicyPairingModel();
                accessPolicyPairingModel.Id             = i;
                accessPolicyPairingModel.ScopeId        = scopeId;
                accessPolicyPairingModel.ClaimId        = claimId;
                accessPolicyPairingModel.AccessPolicyId = accessPolicyId;

                await accessPolicyPairingRepository.CreateAccessPolicyPairing(accessPolicyPairingModel);
            }
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var source = (Scope)value;

            var target = new ScopeModel
            {
                Name = source.Name
            };

            serializer.Serialize(writer, target);
        }
        public IActionResult DeleteScope(ScopeModel model)
        {
            var api = _configurationDbContext.ApiResources
                      .Include(x => x.Scopes)
                      .FirstOrDefault(x => x.Id == model.ApiResourceId);
            var scope = api.Scopes.FirstOrDefault(x => x.Id == model.Id);

            api.Scopes.Remove(scope);
            _configurationDbContext.SaveChanges();

            return(RedirectToAction(nameof(Scopes), new { id = api.Id }));
        }
Exemplo n.º 13
0
 public override void FuncPreInitEditView(object id, ref Scope EditItem, ref ScopeEditModel model)
 {
     if (EditItem == null)
     {
         //get the item by id
         EditItem = new ScopeModel <Scope>().Get(id);
     }
     if (EditItem != null)
     {
         model          = new ScopeEditModel();
         model.EditItem = EditItem;
     }
 }
Exemplo n.º 14
0
        /// <summary>
        /// SaveScope: Save scope into database.
        /// </summary>
        /// <param name="service"></param>
        /// <returns></returns>
        public int SaveScope(ScopeModel scope)
        {
            ScopeModel s = database.Table <ScopeModel>().Where(i => i.Id == scope.Id).FirstOrDefault();

            if (s != null)
            {
                return(database.Update(scope));
            }
            else
            {
                return(database.Insert(scope));
            }
        }
Exemplo n.º 15
0
        public async Task <IActionResult> CreateScope(ScopeModel newScope)
        {
            Scope dupe = await _scopeService.Find(newScope.Name);

            if (dupe != null)
            {
                ModelState.AddModelError("FindScope", $"A scope with name {newScope.Name} already exists.");
                return(RedirectToAction("Index"));
            }

            await _scopeService.Save(newScope.IdsScope);

            return(RedirectToAction("Index"));
        }
Exemplo n.º 16
0
        public override void FuncPreDetailsView(object id, ref List <ScopeDetailsViewModel> items)
        {
            filters = new List <GenericDataFormat.FilterItems>();
            filters.Add(new GenericDataFormat.FilterItems()
            {
                Property = "ScopeID", Operation = GenericDataFormat.FilterOperations.Equal, Value = id
            });
            var requestBody = new GenericDataFormat()
            {
                Filters = filters
            };

            items = new ScopeModel <ScopeDetailsViewModel>().Get(requestBody);
        }
        public IActionResult AddScope(ScopeModel model)
        {
            var api = _configurationDbContext.ApiResources
                      .Include(x => x.Scopes)
                      .FirstOrDefault(x => x.Id == model.ApiResourceId);

            api.Scopes.Add(new ApiResourceScope {
                Scope = model.Scope
            });

            _configurationDbContext.SaveChanges();

            return(RedirectToAction(nameof(Scopes), new { id = api.Id }));
        }
Exemplo n.º 18
0
        public async Task <IActionResult> Edit(string scopeName, ScopeModel scope)
        {
            var editScope = await _scopeService.Find(scopeName);

            if (editScope == null)
            {
                ModelState.AddModelError("FindScope", $"Scope with the name {scopeName} could not be found.");
                return(RedirectToAction("Index"));
            }

            await _scopeService.Delete(scopeName);

            scope.IdsScope.Claims = editScope.Claims;

            await _scopeService.Save(scope.IdsScope);

            return(RedirectToAction("Index"));
        }
        public async Task <bool> UpdateScope(ScopeModel scopeModel)
        {
            try
            {
                var dataScope   = ModelConverterService.ConvertTo(scopeModel, new Models.User_Access_Control.ScopeModel());
                var changesMade = await _scopeRepository.UpdateScope(dataScope);

                if (changesMade == 0)
                {
                    return(false);
                }

                return(true);
            }
            catch (SqlCustomException e)
            {
                throw new SqlCustomException("Scope could not be updated.", e.InnerException);
            }
        }
Exemplo n.º 20
0
        /// <summary>
        /// SaveScope: Save scopes into database.
        /// </summary>
        /// <param name="scopes"></param>
        /// <returns></returns>
        public int SaveScope(List <ScopeModel> scopes)
        {
            int result = 0;

            foreach (ScopeModel scope in scopes)
            {
                ScopeModel s = database.Table <ScopeModel>().Where(i => i.Id == scope.Id).FirstOrDefault();
                if (s != null)
                {
                    result = database.Update(scope);
                }
                else
                {
                    result = database.Insert(scope);
                }
            }

            return(result);
        }
        public IActionResult EditScope(int apiId, int scopeId)
        {
            var api = _configurationDbContext.ApiResources
                      .Include("Scopes.UserClaims")
                      .FirstOrDefault(x => x.Id == apiId);

            if (scopeId != 0)
            {
                var scopeEntity = api.Scopes.FirstOrDefault(x => x.Id == scopeId);
                return(View(ScopeModel.FromEntity(scopeEntity)));
            }
            else
            {
                return(View(new ScopeModel
                {
                    ApiResourceId = api.Id,
                    ApiResourceName = api.Name,
                    ApiResource = api,
                }));
            }
        }
        public async Task Init()
        {
            await TestCleaner.CleanDatabase();

            var numTestRows = 20;

            IDataGateway          dataGateway      = new SQLServerGateway();
            IConnectionStringData connectionString = new ConnectionStringData();
            IScopeRepository      scopeRepository  = new ScopeRepository(dataGateway, connectionString);

            for (int i = 1; i <= numTestRows; ++i)
            {
                ScopeModel scopeModel = new ScopeModel();
                scopeModel.Id          = i;
                scopeModel.Type        = "TestScope" + i;
                scopeModel.Description = "TestDescription" + i;
                scopeModel.IsDefault   = true;

                await scopeRepository.CreateScope(scopeModel);
            }
        }
Exemplo n.º 23
0
        public async Task <int> UpdateScope(ScopeModel model)
        {
            try
            {
                var storedProcedure = "dbo.Scope_Update";

                return(await _dataGateway.Execute(storedProcedure,
                                                  new
                {
                    Id = model.Id,
                    type = model.Type,
                    description = model.Description,
                    isDefault = model.IsDefault
                },
                                                  _connectionString.SqlConnectionString));
            }
            catch (SqlCustomException e)
            {
                throw new SqlCustomException("Scope could not be updated.", e.InnerException);
            }
        }
Exemplo n.º 24
0
        private void CreateConsentViewModel(string returnUrl, AuthorizationRequest request)
        {
            var model           = this.Input;
            var check           = model == null;
            var scopesConsented = model?.ScopesConsented.ToArray() ?? Array.Empty <string>();

            this.Input = new InputModel
            {
                RememberConsent = model?.RememberConsent ?? true,
                ScopesConsented = scopesConsented,
                Description     = model?.Description,

                ReturnUrl = returnUrl
            };

            this.ClientName           = request.Client.ClientName ?? request.Client.ClientId;
            this.ClientUrl            = request.Client.ClientUri;
            this.ClientLogoUrl        = request.Client.LogoUri;
            this.AllowRememberConsent = request.Client.AllowRememberConsent;
            this.IdentityScopes       = ScopeModel.GetIdentityResourcesFromRequest(request.ValidatedResources, scopesConsented, check);
            this.ApiScopes            = ScopeModel.GetApiScopeModelsFromRequest(request.ValidatedResources, scopesConsented, check);
        }
Exemplo n.º 25
0
        public async Task <int> CreateScope(ScopeModel model)
        {
            try
            {
                var storedProcedure = "dbo.Scope_Create";

                DynamicParameters p = new DynamicParameters();

                p.Add("type", model.Type);
                p.Add("description", model.Description);
                p.Add("isDefault", model.IsDefault);
                p.Add("Id", DbType.Int32, direction: ParameterDirection.Output);

                await _dataGateway.Execute(storedProcedure, p, _connectionString.SqlConnectionString);

                return(p.Get <int>("Id"));
            }
            catch (SqlCustomException e)
            {
                throw new SqlCustomException("Scope could not be created.", e.InnerException);
            }
        }
        public async Task Init()
        {
            await TestCleaner.CleanDatabase();

            var numTestRows = 20;

            IDataGateway                       dataGateway                       = new SQLServerGateway();
            IConnectionStringData              connectionString                  = new ConnectionStringData();
            IScopeRepository                   scopeRepository                   = new ScopeRepository(dataGateway, connectionString);
            IAssignmentPolicyRepository        assignmentPolicyRepository        = new AssignmentPolicyRepository(dataGateway, connectionString);
            IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(dataGateway, connectionString);

            for (int i = 1; i <= numTestRows; ++i)
            {
                ScopeModel scopeModel = new ScopeModel();
                scopeModel.Id          = i;
                scopeModel.Type        = "TestScope" + i;
                scopeModel.Description = "TestDescription" + i;

                var scopeId = await scopeRepository.CreateScope(scopeModel);

                scopeModel.IsDefault = true;
                AssignmentPolicyModel assignmentPolicyModel = new AssignmentPolicyModel();
                assignmentPolicyModel.Id                  = i;
                assignmentPolicyModel.Name                = "TestClaim" + i;
                assignmentPolicyModel.IsDefault           = true;
                assignmentPolicyModel.RequiredAccountType = "TestAccountType" + i;
                assignmentPolicyModel.Priority            = i % 4;

                var policyId = await assignmentPolicyRepository.CreateAssignmentPolicy(assignmentPolicyModel);

                AssignmentPolicyPairingModel assignmentPolicyPairingModel = new AssignmentPolicyPairingModel();
                assignmentPolicyPairingModel.Id       = i;
                assignmentPolicyPairingModel.PolicyId = policyId;
                assignmentPolicyPairingModel.ScopeId  = scopeId;

                await assignmentPolicyPairingRepository.CreateAssignmentPolicyPairing(assignmentPolicyPairingModel);
            }
        }
        public IActionResult EditScope(ScopeModel model)
        {
            var api = _configurationDbContext.ApiResources
                      .Include("Scopes.UserClaims")
                      .FirstOrDefault(x => x.Id == model.ApiResourceId);

            ApiScope scope;

            if (model.Id == 0)
            {
                scope = new ApiScope
                {
                    UserClaims = new List <ApiScopeClaim>(),
                };
                api.Scopes.Add(scope);
            }
            else
            {
                scope = api.Scopes.FirstOrDefault(x => x.Id == model.Id);
                scope.UserClaims.Clear();
            }

            model.UpdateEntity(scope);

            if (!string.IsNullOrEmpty(model.UserClaimsItems))
            {
                var userClaims = JsonConvert.DeserializeObject <List <string> >(model.UserClaimsItems);

                scope.UserClaims.AddRange(userClaims.Select(x => new ApiScopeClaim
                {
                    Type = x,
                }));
            }

            _configurationDbContext.SaveChanges();

            return(RedirectToAction(nameof(Scopes), new { id = api.Id }));
        }
        public HttpResponseMessage Post(int id, ScopeModel model)
        {
            if (!ModelState.IsValid)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.GetErrors()));
            }

            var app = config.Applications.All.SingleOrDefault(x => x.ID == id);

            if (app == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            if (app.Scopes.Any(x => x.Name == model.Name))
            {
                ModelState.AddModelError("", "That Scope name is already in use.");
                return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.GetErrors()));
            }

            var scope = new Scope();

            scope.Name        = model.Name;
            scope.DisplayName = model.DisplayName;
            scope.Description = model.Description;
            scope.Emphasize   = model.Emphasize;

            app.Scopes.Add(scope);
            config.SaveChanges();

            return(Request.CreateResponse(HttpStatusCode.OK, new {
                scope.ID,
                scope.Name,
                scope.DisplayName,
                scope.Description,
                scope.Emphasize
            }));
        }
        public async Task <int> CreateScope(ScopeModel scopeModel)
        {
            try
            {
                var dataScope = ModelConverterService.ConvertTo(scopeModel, new Models.User_Access_Control.ScopeModel());
                var scopeId   = await _scopeRepository.CreateScope(dataScope);

                foreach (var claim in scopeModel.Claims)
                {
                    await _scopeClaimRepository.CreateScopeClaim(new Models.User_Access_Control.ScopeClaimModel()
                    {
                        ScopeId = scopeId,
                        ClaimId = claim.Id
                    });
                }

                return(scopeId);
            }
            catch (SqlCustomException e)
            {
                throw new SqlCustomException(e.InnerException.Message, e.InnerException);
            }
        }
        public HelperCompleteRegister(RegisterUserModel user)
        {
            InitializeComponent();

            currentService = 0;
            instance       = this;
            NavigationPage.SetHasNavigationBar(this, false);
            currentUser = user;

            btnHelperRegSelectedService.isSelected = true;
            //btnHelperRegTbd.isSelected = false;

            entryHelperRegUsername1.Text = user.UserName;
            entryHelperRegPhone1.Text    = user.MobileNumber;
            entryHelperRegEmail1.Text    = user.Email;

            IEnumerable <string> genders = new List <string>()
            {
                "Male", "Female", "Rather no to say"
            };

            SetRadioList(genders, rgHelperGender);

            //IEnumerable<String> locationTypes = new List<string>() { "Helper's Home", "Mobile Helper"};
            //SetRadioList(locationTypes, rgHelperLocationType);

            IEnumerable <string> statusList = new List <string>()
            {
                "Available", "Not available"
            };

            SetRadioList(statusList, rgHelperStatus);

            SetServices();

            //if (user.IsServiced)
            //    GoToBuildTrust();
            //else
            //if (user.IsCompleted)
            //    GoToEditServices();
            //else
            //if (user.IsRegistered)
            //{
            //    GoToBasicInfo();
            //}

            MessagingCenter.Subscribe <HelperRegister2, string>(this, "Current Address", (sender, currLoc) =>
            {
                string[] locations          = currLoc.Split(new char[] { ';' });
                entryHelperRegLocation.Text = locations[0];
                helperServices.Service[currentService].LocationName = locations[0];
                helperServices.Service[currentService].Latitude     = locations[1];
                helperServices.Service[currentService].Longitude    = locations[2];
            });

            MessagingCenter.Subscribe <HelperRegister3, string>(this, "Selected Address", (sender, selectedAddress) =>
            {
                entryHelperRegLocation.Text = selectedAddress;
            });

            MessagingCenter.Subscribe <ServiceButton, bool>(this, "Select Or Unselect Service", (sender, isSelected) =>
            {
                try
                {
                    string serviceName = ((ServiceButton)sender).serviceName;

                    if (string.Equals(serviceName, "Hourly"))
                    {
                        if (((ServiceButton)sender).isSelected)
                        {
                            gridPriceHour.IsVisible = true;
                        }
                        else
                        {
                            gridPriceHour.IsVisible = false;
                        }
                    }
                    else if (string.Equals(serviceName, "Daily"))
                    {
                        if (((ServiceButton)sender).isSelected)
                        {
                            gridPriceDay.IsVisible = true;
                        }
                        else
                        {
                            gridPriceDay.IsVisible = false;
                        }
                    }
                    else if (string.Equals(serviceName, "Monthly"))
                    {
                        if (((ServiceButton)sender).isSelected)
                        {
                            gridPriceMonth.IsVisible = true;
                        }
                        else
                        {
                            gridPriceMonth.IsVisible = false;
                        }
                    }
                    else
                    {
                        List <ServiceModel> services = App.Database.GetServices();
                        ServiceModel service         = services.Where(a => a.ServiceName == serviceName).FirstOrDefault();
                        //var selectedService = helperServices.Service.Where(a => a.ServiceId == service.Id).FirstOrDefault();
                        int serviceIndex = services.IndexOf(service);
                        var gService     = gridServices.Children.Where(c => Grid.GetRow(c) == (serviceIndex) / 3 && Grid.GetColumn(c) == (serviceIndex) % 3);
                        gService.ElementAt(1).IsVisible = !gService.ElementAt(1).IsVisible;

                        if (isSelected)
                        {
                            AddGrid(gridHelperEditServices);

                            HelperServices helperService = new HelperServices();
                            helperService.ServiceId      = service.Id;
                            helperService.ServiceName    = service.ServiceName;
                            helperServices.Service.Add(helperService);

                            //selectedService.isSelected = true;
                            //App.Database.SaveServiceAsync(selectedService);
                        }
                        else
                        {
                            int count = gridHelperEditServices.ColumnDefinitions.Count;

                            for (int i = count - 1; i >= 0; i--)
                            {
                                gridHelperEditServices.ColumnDefinitions.RemoveAt(i);
                                gridHelperEditServices.Children.RemoveAt(i);
                            }

                            for (int i = 0; i < count - 1; i++)
                            {
                                AddGrid(gridHelperEditServices);
                            }

                            HelperServices helperService = helperServices.Service.Where(a => a.ServiceId == service.Id).FirstOrDefault();
                            helperServices.Service.Remove(helperService);

                            //selectedService.isSelected = false;
                            //App.Database.SaveServiceAsync(selectedService);
                        }

                        var g             = gridHelperEditServices.Children.Where(c => Grid.GetRow(c) == 0 && Grid.GetColumn(c) == 0).First();
                        g.BackgroundColor = Color.FromHex("#FF748C");
                    }
                }
                catch (Exception e)
                {
                    Console.Write(e.StackTrace);
                }
            });

            MessagingCenter.Subscribe <ScopeButton, bool>(this, "Select Or Unselect Service", (sender, isSelected) =>
            {
                try
                {
                    string scopeName         = ((ScopeButton)sender).scopeName;
                    List <ScopeModel> scopes = App.Database.GetScopes();
                    ScopeModel scope         = scopes.Where(a => a.ScopeName == scopeName).FirstOrDefault();

                    if (isSelected)
                    {
                        HelperScopes helperScope = new HelperScopes()
                        {
                            ScopeId = scope.Id
                        };
                        helperServices.Service[currentService].Scopes.Add(helperScope);
                    }
                    else
                    {
                        HelperScopes helperScope = helperServices.Service[currentService].Scopes.Where(x => x.ScopeId == scope.Id).FirstOrDefault();
                        helperServices.Service[currentService].Scopes.Remove(helperScope);
                    }

                    //App.Database.SaveScopeAsync(selectedScope);
                }
                catch (Exception e)
                {
                    Console.Write(e.StackTrace);
                }
            });
        }