コード例 #1
0
        public static void SetUp(EntityFrameworkServiceOptions options)
        {
            using (var db = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Clients.Any())
                {
                    foreach (var c in Clients.Get())
                    {
                        var e = c.ToEntity();
                        db.Clients.Add(e);
                    }
                    db.SaveChanges();
                }
            }

            using (var db = new ScopeConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Scopes.Any())
                {
                    foreach (var s in Scopes.Get())
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }
                    db.SaveChanges();
                }
            }
        }
コード例 #2
0
        protected override void ProcessRecord()
        {
            var db = new ClientConfigurationDbContext(this.ConnectionString, this.Schema);

            var client = new Thinktecture.IdentityServer.Core.Models.Client
            {
                ClientId      = this.ClientId,
                ClientName    = this.ClientName,
                ClientSecrets = (from s in this.ClientSecrets
                                 select new Thinktecture.IdentityServer.Core.Models.ClientSecret(s)).ToList(),
                Flow                         = this.Flow,
                Enabled                      = this.Enabled,
                RequireConsent               = this.RequireConsent,
                AllowRememberConsent         = this.AllowRememberConsent,
                ClientUri                    = this.ClientUri,
                LogoUri                      = this.LogoUri,
                RedirectUris                 = this.RedirectUris,
                PostLogoutRedirectUris       = this.PostLogoutUris,
                ScopeRestrictions            = this.ScopeRestrictions,
                IdentityProviderRestrictions = this.IdentityProviderRestrictions,

                AccessTokenType           = this.AccessTokenType,
                AccessTokenLifetime       = this.TokensLifetime,
                IdentityTokenLifetime     = this.TokensLifetime,
                AuthorizationCodeLifetime = this.TokensLifetime // bad
            };

            db.Clients.Add(client.ToEntity());
            db.SaveChanges();
            WriteObject(client);
        }
コード例 #3
0
        public static void InitClientAndScopeSampleDatas(EntityFrameworkServiceOptions options)
        {
            var clients = InMemoryClient.clients;

            using (var db = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Clients.Any())
                {
                    foreach (var c in clients)
                    {
                        var e = c.ToEntity();
                        db.Clients.Add(e);
                    }
                    db.SaveChanges();
                }
            }

            var scopes = InMemoryScope.scopes;

            using (var db = new ScopeConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Scopes.Any())
                {
                    foreach (var s in scopes)
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }
                    db.SaveChanges();
                }
            }
        }
コード例 #4
0
        protected override void ProcessRecord()
        {
            var db = new ClientConfigurationDbContext(this.ConnectionString, this.Schema);

            var entity = db.Clients.First(s => s.ClientId == this.ClientId);

            db.Clients.Remove(entity);
            db.SaveChanges();
        }
コード例 #5
0
 public static void ConfigureClients(IEnumerable <Client> clients, EntityFrameworkServiceOptions options)
 {
     using (var db = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
     {
         if (!db.Clients.Any())
         {
             foreach (var c in clients)
             {
                 var e = c.ToEntity();
                 db.Clients.Add(e);
             }
             db.SaveChanges();
         }
     }
 }
コード例 #6
0
ファイル: Startup.cs プロジェクト: emmirsab/TimeKeeper
 public void SetupClients(IEnumerable <Client> clients, EntityFrameworkServiceOptions options)
 {
     using (var context = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
     {
         if (context.Clients.Any())
         {
             return;
         }
         foreach (var client in clients)
         {
             context.Clients.Add(client.ToEntity());
         }
         context.SaveChanges();
     }
 }
        public void CanAddAndDeleteClientRedirectUri()
        {
            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                db.Clients.Add(new Client
                {
                    ClientId   = "test-client",
                    ClientName = "Test Client"
                });

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client = db.Clients.First();

                client.RedirectUris.Add(new ClientRedirectUri
                {
                    Uri = "https://redirect-uri-1"
                });

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client      = db.Clients.First();
                var redirectUri = client.RedirectUris.First();

                client.RedirectUris.Remove(redirectUri);

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client = db.Clients.First();

                Assert.Equal(0, client.RedirectUris.Count());
            }
        }
        public void CanAddAndDeleteClientScopes()
        {
            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                db.Clients.Add(new Client
                {
                    ClientId   = "test-client-scopes",
                    ClientName = "Test Client"
                });

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client = db.Clients.First();

                client.AllowedScopes.Add(new ClientScope
                {
                    Scope = "test"
                });

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client = db.Clients.First();
                var scope  = client.AllowedScopes.First();

                client.AllowedScopes.Remove(scope);

                db.SaveChanges();
            }

            using (var db = new ClientConfigurationDbContext(ConfigConnectionStringName))
            {
                var client = db.Clients.First();

                Assert.Equal(0, client.AllowedScopes.Count());
            }
        }
コード例 #9
0
        public IdentityAdminCoreManagerTests()
        {
            _identityAdminManagerService = new IdentityAdminManagerService("IdSvr3ConfigAdmin");
            using (var db = new ClientConfigurationDbContext(ConnectionString))
            {
                var allClients = db.Clients.Where(p => true);
                foreach (var c in allClients)
                {
                    db.Clients.Remove(c);
                }
                db.SaveChanges();
                var testClient = new Client
                {
                    ClientId             = "IdToTest",
                    ClientName           = _clientName,
                    Enabled              = true,
                    Flow                 = Flows.Implicit,
                    RequireConsent       = true,
                    AllowRememberConsent = true,
                    RedirectUris         = new List <ClientRedirectUri>()
                    {
                        new ClientRedirectUri {
                            Id = 1, Uri = "www.redirect.com"
                        }
                    },
                    PostLogoutRedirectUris = new List <ClientPostLogoutRedirectUri>()
                    {
                        new ClientPostLogoutRedirectUri {
                            Id = 1, Uri = "www.postRedirectUri.com"
                        }
                    },
                    AllowedScopes = new List <ClientScope>()
                    {
                        new ClientScope {
                            Scope = "read", Id = 1
                        }
                    },
                    AccessTokenType = AccessTokenType.Jwt,
                    ClientSecrets   = new List <ClientSecret> {
                        new ClientSecret {
                            Id = 1, Description = "removeMe", Type = "ssssshhh", Value = "nothing to see here"
                        }
                    },
                    IdentityProviderRestrictions = new List <ClientIdPRestriction>()
                    {
                        new ClientIdPRestriction {
                            Id = 1, Provider = "www.provideme.com"
                        }
                    },
                    AllowedCustomGrantTypes = new List <ClientCustomGrantType> {
                        new ClientCustomGrantType {
                            Id = 1, GrantType = "Authorization Grant"
                        }
                    },
                    Claims = new List <ClientClaim> {
                        new ClientClaim {
                            Id = 1, Value = "tester", Type = "role"
                        }
                    },
                    AllowedCorsOrigins = new List <ClientCorsOrigin> {
                        new ClientCorsOrigin {
                            Id = 1, Origin = "www.CrossOriginMe.com"
                        }
                    }
                };
                db.Clients.Add(testClient);
                db.SaveChanges();
                _clientSubject = testClient.Id.ToString();
            }

            using (var db = new ScopeConfigurationDbContext(ConnectionString))
            {
                var allScopes = db.Scopes.Where(p => true);
                foreach (var c in allScopes)
                {
                    db.Scopes.Remove(c);
                }
                db.SaveChanges();
                var testScope = new Scope {
                    Name = _scopeName, ScopeClaims = new List <ScopeClaim> {
                        new ScopeClaim {
                            Id = 1, Description = "To Test", Name = "testScope"
                        }
                    }
                };
                db.Scopes.Add(testScope);
                db.SaveChanges();
                _scopeSubject = testScope.Id.ToString();
            }
        }
コード例 #10
0
        protected override void ProcessRecord()
        {
            var db = new ClientConfigurationDbContext(this.ConnectionString, this.Schema);

            var entity        = db.Clients.Single(c => c.ClientId == this.Client.ClientId);
            var currentId     = entity.Id;
            var currentclient = entity.ToModel();

            var attachedEntry = db.Entry(entity);
            var newentity     = this.Client.ToEntity();

            newentity.Id = currentId;
            attachedEntry.CurrentValues.SetValues(newentity);

            // Synchronize nav properties - FIXME ugly
            foreach (var uri in currentclient.RedirectUris.Union(this.Client.RedirectUris).Distinct())
            {
                if (currentclient.RedirectUris.Contains(uri) && !this.Client.RedirectUris.Contains(uri))
                {
                    var urientity = entity.RedirectUris.First(x => x.Uri == uri);
                    db.Entry(urientity).State = System.Data.Entity.EntityState.Deleted;
                    entity.RedirectUris.Remove(urientity);
                }
                else if (!currentclient.RedirectUris.Contains(uri) && this.Client.RedirectUris.Contains(uri))
                {
                    entity.RedirectUris.Add(new ClientRedirectUri()
                    {
                        Uri = uri
                    });
                }
            }
            foreach (var uri in currentclient.PostLogoutRedirectUris.Union(this.Client.PostLogoutRedirectUris).Distinct())
            {
                if (currentclient.PostLogoutRedirectUris.Contains(uri) && !this.Client.PostLogoutRedirectUris.Contains(uri))
                {
                    var urientity = entity.PostLogoutRedirectUris.First(x => x.Uri == uri);
                    db.Entry(urientity).State = System.Data.Entity.EntityState.Deleted;
                    entity.PostLogoutRedirectUris.Remove(urientity);
                }
                else if (!currentclient.PostLogoutRedirectUris.Contains(uri) && this.Client.PostLogoutRedirectUris.Contains(uri))
                {
                    entity.PostLogoutRedirectUris.Add(new ClientPostLogoutRedirectUri()
                    {
                        Uri = uri
                    });
                }
            }
            foreach (var gt in currentclient.CustomGrantTypeRestrictions.Union(this.Client.CustomGrantTypeRestrictions).Distinct())
            {
                if (currentclient.CustomGrantTypeRestrictions.Contains(gt) && !this.Client.CustomGrantTypeRestrictions.Contains(gt))
                {
                    var gtentity = entity.CustomGrantTypeRestrictions.First(x => x.GrantType == gt);
                    db.Entry(gtentity).State = System.Data.Entity.EntityState.Deleted;
                    entity.CustomGrantTypeRestrictions.Remove(gtentity);
                }
                else if (!currentclient.CustomGrantTypeRestrictions.Contains(gt) && this.Client.CustomGrantTypeRestrictions.Contains(gt))
                {
                    entity.CustomGrantTypeRestrictions.Add(new ClientGrantTypeRestriction()
                    {
                        GrantType = gt
                    });
                }
            }
            foreach (var scope in currentclient.ScopeRestrictions.Union(this.Client.ScopeRestrictions).Distinct())
            {
                if (currentclient.ScopeRestrictions.Contains(scope) && !this.Client.ScopeRestrictions.Contains(scope))
                {
                    var scopenetity = entity.ScopeRestrictions.First(x => x.Scope == scope);
                    db.Entry(scopenetity).State = System.Data.Entity.EntityState.Deleted;
                    entity.ScopeRestrictions.Remove(scopenetity);
                }
                else if (!currentclient.ScopeRestrictions.Contains(scope) && this.Client.ScopeRestrictions.Contains(scope))
                {
                    entity.ScopeRestrictions.Add(new ClientScopeRestriction()
                    {
                        Scope = scope
                    });
                }
            }
            foreach (var provider in currentclient.IdentityProviderRestrictions.Union(this.Client.IdentityProviderRestrictions).Distinct())
            {
                if (currentclient.IdentityProviderRestrictions.Contains(provider) && !this.Client.ScopeRestrictions.Contains(provider))
                {
                    var idpentity = entity.IdentityProviderRestrictions.First(x => x.Provider == provider);
                    db.Entry(idpentity).State = System.Data.Entity.EntityState.Deleted;
                    entity.IdentityProviderRestrictions.Remove(idpentity);
                }
                else if (!currentclient.IdentityProviderRestrictions.Contains(provider) && this.Client.IdentityProviderRestrictions.Contains(provider))
                {
                    entity.IdentityProviderRestrictions.Add(new ClientIdPRestriction()
                    {
                        Provider = provider
                    });
                }
            }
            foreach (var secret in currentclient.ClientSecrets.Union(this.Client.ClientSecrets).Distinct())
            {
                if (currentclient.ClientSecrets.Any(x => x.Value == secret.Value) && !this.Client.ClientSecrets.Any(x => x.Value == secret.Value))
                {
                    entity.ClientSecrets.Remove(entity.ClientSecrets.First(x => x.Value == secret.Value));
                }
                else if (!currentclient.ClientSecrets.Any(x => x.Value == secret.Value) && this.Client.ClientSecrets.Any(x => x.Value == secret.Value))
                {
                    entity.ClientSecrets.Add(new Thinktecture.IdentityServer.EntityFramework.Entities.ClientSecret
                    {
                        ClientSecretType = secret.ClientSecretType,
                        Description      = secret.ClientSecretType,
                        Expiration       = secret.Expiration,
                        Value            = secret.Value
                    });
                }
            }
            foreach (var claim in currentclient.Claims.Union(this.Client.Claims).Distinct())
            {
                if (currentclient.Claims.Any(x => x.Type == claim.Type) && !this.Client.Claims.Any(x => x.Type == claim.Type))
                {
                    entity.Claims.Remove(entity.Claims.First(x => x.Type == claim.Type && x.Value == claim.Value));
                }
                else if (!currentclient.Claims.Any(x => x.Type == claim.Type) && this.Client.Claims.Any(x => x.Type == claim.Type))
                {
                    entity.Claims.Add(new Thinktecture.IdentityServer.EntityFramework.Entities.ClientClaim()
                    {
                        Type  = claim.Type,
                        Value = claim.Value
                    });
                }
            }

            try
            {
                db.SaveChanges();
            }
            catch (System.Data.Entity.Infrastructure.DbUpdateException dbue)
            {
                WriteError(new ErrorRecord(dbue.InnerException, "DbUpdateException", ErrorCategory.WriteError, entity));
                throw dbue;
            }
            WriteObject(entity.ToModel());
        }
        public Result <int> Update(ClientModel model, int id)
        {
            try
            {
                var result         = new Result <int>();
                var existingClient = clientContext.Clients
                                     .Where(x => x.Id == id)
                                     .Include(x => x.AllowedScopes)
                                     .Include(x => x.ClientSecrets)
                                     .Include(x => x.RedirectUris)
                                     .Include(x => x.PostLogoutRedirectUris)
                                     .Include(x => x.AllowedCorsOrigins)
                                     .Include(x => x.IdentityProviderRestrictions)
                                     .Include(x => x.Claims)
                                     .Include(x => x.AllowedCustomGrantTypes)
                                     .SingleOrDefault();


                if (existingClient == null)
                {
                    result.Exists = false;
                    return(result);
                }

                var duplicateClientId = clientContext.Clients
                                        .Where(x => x.ClientId == model.ClientId)
                                        .FirstOrDefault();

                if (duplicateClientId != null && duplicateClientId.Id != id)
                {
                    throw new Exception("pre-existing clientid");
                }

                clientContext.Entry(existingClient).CurrentValues.SetValues(model); // copy all values from object

                #region Update related properties


                var exRedirectUris = existingClient.RedirectUris.ToList();
                //delete redirect uri's that have been removed
                foreach (var item in exRedirectUris)
                {
                    if (!model.RedirectUris.Any(x => x.Id == item.Id))
                    {
                        existingClient.RedirectUris.Remove(item);
                    }
                }
                if (model.RedirectUris != null && model.RedirectUris.Any())
                {
                    //update and add new uris
                    foreach (var item in model.RedirectUris)
                    {
                        var exRedirectUri = existingClient.RedirectUris.FirstOrDefault(x => x.Id == item.Id);
                        if (exRedirectUri != null)
                        {
                            clientContext.Entry(exRedirectUri).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var redirectUri = new ClientRedirectUri
                            {
                                Uri = item.Uri,
                            };
                            existingClient.RedirectUris.Add(redirectUri);
                        }
                    }
                }


                //delete post redirect uri's that have been removed

                var exPostRedirectUris = existingClient.PostLogoutRedirectUris.ToList();
                foreach (var item in exPostRedirectUris)
                {
                    if (!model.PostLogoutRedirectUris.Any(x => x.Id == item.Id))
                    {
                        existingClient.PostLogoutRedirectUris.Remove(item);
                    }
                }

                if (model.PostLogoutRedirectUris != null && model.PostLogoutRedirectUris.Any())
                {
                    foreach (var item in model.PostLogoutRedirectUris)
                    {
                        var exPostRedirectUri = existingClient.PostLogoutRedirectUris.FirstOrDefault(x => x.Id == item.Id);
                        if (exPostRedirectUri != null)
                        {
                            clientContext.Entry(exPostRedirectUri).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var postRedirectUri = new ClientPostLogoutRedirectUri
                            {
                                Uri = item.Uri,
                            };
                            existingClient.PostLogoutRedirectUris.Add(postRedirectUri);
                        }
                    }
                }
                //update and add new post redirect uris



                var exIdProvRestrictions = existingClient.IdentityProviderRestrictions.ToList();
                foreach (var item in exIdProvRestrictions)
                {
                    if (!model.IdentityProviderRestrictions.Any(x => x.Id == item.Id))
                    {
                        existingClient.IdentityProviderRestrictions.Remove(item);
                    }
                }

                if (model.IdentityProviderRestrictions != null && model.IdentityProviderRestrictions.Any())
                {
                    foreach (var item in model.IdentityProviderRestrictions)
                    {
                        var exIdProvRestriction = existingClient.IdentityProviderRestrictions.FirstOrDefault(x => x.Id == item.Id);
                        if (exIdProvRestriction != null)
                        {
                            clientContext.Entry(exIdProvRestriction).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var IdentityProvRestriction = new ClientIdPRestriction
                            {
                                Provider = item.Provider,
                            };
                            existingClient.IdentityProviderRestrictions.Add(exIdProvRestriction);
                        }
                    }
                }
                //update and add new post redirect uris



                //delete post redirect uri's that have been removed


                //delete allowed scopes that have been removed

                var exScopes = existingClient.AllowedScopes.ToList();
                foreach (var item in exScopes)
                {
                    if (!model.AllowedScopes.Any(x => x.Id == item.Id))
                    {
                        existingClient.AllowedScopes.Remove(item);
                    }
                }

                if (model.AllowedScopes != null && model.AllowedScopes.Any())
                {
                    foreach (var item in model.AllowedScopes)
                    {
                        var exScope = existingClient.AllowedScopes.FirstOrDefault(x => x.Id == item.Id);
                        if (exScope != null)
                        {
                            clientContext.Entry(exScope).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var newScope = new ClientScope
                            {
                                Scope = item.Scope,
                            };
                            existingClient.AllowedScopes.Add(newScope);
                        }
                    }
                }



                //delete client claims that have been removed
                var exClaims = existingClient.Claims.ToList();
                foreach (var item in exClaims)
                {
                    if (!model.Claims.Any(x => x.Id == item.Id))
                    {
                        existingClient.Claims.Remove(item);
                    }
                }

                if (model.Claims != null && model.Claims.Any())
                {
                    //update and add new post redirect uris
                    foreach (var item in model.Claims)
                    {
                        var exClaim = existingClient.Claims.FirstOrDefault(x => x.Id == item.Id);
                        if (exClaim != null)
                        {
                            clientContext.Entry(exClaim).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var newClaim = new ClientClaim
                            {
                                Type  = item.Type,
                                Value = item.Value
                            };
                            existingClient.Claims.Add(newClaim);
                        }
                    }
                }

                //delete client claims that have been removed

                var exAllowedCors = existingClient.AllowedCorsOrigins.ToList();
                foreach (var item in exAllowedCors)
                {
                    if (!model.AllowedCorsOrigins.Any(x => x.Id == item.Id))
                    {
                        existingClient.AllowedCorsOrigins.Remove(item);
                    }
                }

                if (model.AllowedCorsOrigins != null && model.AllowedCorsOrigins.Any())
                {
                    //update and add new post redirect uris
                    foreach (var item in model.AllowedCorsOrigins)
                    {
                        var exAllowedCor = existingClient.AllowedCorsOrigins.FirstOrDefault(x => x.Id == item.Id);
                        if (exAllowedCor != null)
                        {
                            clientContext.Entry(exAllowedCor).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var newClientCor = new ClientCorsOrigin
                            {
                                Origin = item.Origin
                            };
                            existingClient.AllowedCorsOrigins.Add(newClientCor);
                        }
                    }
                }



                //delete custom grant types that have been removed

                var exCustomGrants = existingClient.AllowedCustomGrantTypes.ToList();
                foreach (var item in exCustomGrants)
                {
                    if (!model.AllowedCustomGrantTypes.Any(x => x.Id == item.Id))
                    {
                        existingClient.AllowedCustomGrantTypes.Remove(item);
                    }
                }

                if (model.AllowedCustomGrantTypes != null && model.AllowedCustomGrantTypes.Any())
                {
                    //update and add new post redirect uris
                    foreach (var item in model.AllowedCustomGrantTypes)
                    {
                        var exCustomGrant = existingClient.AllowedCustomGrantTypes.FirstOrDefault(x => x.Id == item.Id);
                        if (exCustomGrant != null)
                        {
                            clientContext.Entry(exCustomGrant).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var newCustomGrant = new ClientCustomGrantType
                            {
                                GrantType = item.GrantType
                            };
                            existingClient.AllowedCustomGrantTypes.Add(newCustomGrant);
                        }
                    }
                }



                //delete custom grant types that have been removed

                var exSecrets = existingClient.ClientSecrets.ToList();
                foreach (var item in exSecrets)
                {
                    if (!model.ClientSecrets.Any(x => x.Id == item.Id))
                    {
                        existingClient.ClientSecrets.Remove(item);
                    }
                }

                if (model.ClientSecrets != null && model.ClientSecrets.Any())
                {
                    //update and add new post redirect uris
                    foreach (var item in model.ClientSecrets)
                    {
                        var exSecret = existingClient.ClientSecrets.FirstOrDefault(x => x.Id == item.Id);
                        if (exSecret != null)
                        {
                            exSecret.Value = exSecret.Value;
                            clientContext.Entry(exSecret).CurrentValues.SetValues(item);
                        }
                        else
                        {
                            var newSecret = new ClientSecret
                            {
                                Type        = item.Type,
                                Value       = item.Value.Sha256(),
                                Expiration  = item.Expiration,
                                Description = item.Description,
                            };
                            existingClient.ClientSecrets.Add(newSecret);
                        }
                    }
                }


                #endregion


                clientContext.SaveChanges();
                result.Exists      = true;
                result.Response    = existingClient.Id;
                result.CustomValue = existingClient.ClientName;
                return(result);
            }
            catch (Exception ex)
            {
                ErrorLogger.Log(ex);
                throw;
            }
        }
コード例 #12
0
        public static void Configure(EntityFrameworkServiceOptions options)
        {
            using (var db = new ScopeConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Scopes.Any())
                {
                    foreach (var s in StandardScopes.All)
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }

                    foreach (var s in StandardScopes.AllAlwaysInclude)
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }

                    db.SaveChanges();
                }
            }

            using (var db = new Context(options.ConnectionString))
            {
                if (!db.Users.Any())
                {
                    using (var userManager = new UserManager(new UserStore(db)))
                    {
                        var defaultUserPassword = "******"; // Must be atleast 6 characters
                        var user = new User
                        {
                            UserName       = "******",
                            FirstName      = "Luke",
                            LastName       = "Skywalker",
                            Email          = "*****@*****.**",
                            EmailConfirmed = true
                        };
                        userManager.Create(user, defaultUserPassword);
                        userManager.AddClaim(user.Id,
                                             new Claim(Core.Constants.ClaimTypes.WebSite, "https://www.johanbostrom.se/"));
                    }

                    db.SaveChanges();
                }
            }

            using (var db = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Clients.Any())
                {
                    var defaultHybridClient = new Client
                    {
                        ClientName    = "Default Hybrid Client",
                        ClientId      = "default.hybrid",
                        Flow          = Flows.Hybrid,
                        ClientSecrets = new List <Secret>
                        {
                            new Secret("default.hybrid.password".Sha256())
                        },
                        AllowedScopes = new List <string>
                        {
                            Core.Constants.StandardScopes.OpenId,
                            Core.Constants.StandardScopes.Profile,
                            Core.Constants.StandardScopes.Email,
                            Core.Constants.StandardScopes.Roles,
                            Core.Constants.StandardScopes.Address,
                            Core.Constants.StandardScopes.Phone,
                            Core.Constants.StandardScopes.OfflineAccess
                        },
                        ClientUri              = "https://localhost:44300/",
                        RequireConsent         = false,
                        AccessTokenType        = AccessTokenType.Reference,
                        RedirectUris           = new List <string>(),
                        PostLogoutRedirectUris = new List <string>
                        {
                            "https://localhost:44300/"
                        },
                        LogoutSessionRequired = true
                    };

                    db.Clients.Add(defaultHybridClient.ToEntity());
                    db.SaveChanges();
                }
            }
        }