├── test
    ├── WebTest
    │   ├── Views
    │   │   ├── _ViewStart.cshtml
    │   │   ├── _ViewImports.cshtml
    │   │   ├── Home
    │   │   │   ├── Privacy.cshtml
    │   │   │   └── Index.cshtml
    │   │   └── Shared
    │   │   │   ├── _ValidationScriptsPartial.cshtml
    │   │   │   ├── Error.cshtml
    │   │   │   ├── _LoginPartial.cshtml
    │   │   │   ├── _Layout.cshtml.css
    │   │   │   └── _Layout.cshtml
    │   ├── Areas
    │   │   └── Identity
    │   │   │   └── Pages
    │   │   │       └── _ViewStart.cshtml
    │   ├── wwwroot
    │   │   ├── favicon.ico
    │   │   ├── js
    │   │   │   └── site.js
    │   │   ├── css
    │   │   │   └── site.css
    │   │   └── lib
    │   │   │   ├── jquery
    │   │   │       └── LICENSE.txt
    │   │   │   ├── jquery-validation
    │   │   │       └── LICENSE.md
    │   │   │   ├── bootstrap
    │   │   │       ├── LICENSE
    │   │   │       └── dist
    │   │   │       │   └── css
    │   │   │       │       ├── bootstrap-reboot.min.css
    │   │   │       │       ├── bootstrap-reboot.rtl.min.css
    │   │   │       │       ├── bootstrap-reboot.rtl.css
    │   │   │       │       └── bootstrap-reboot.css
    │   │   │   └── jquery-validation-unobtrusive
    │   │   │       ├── LICENSE.txt
    │   │   │       └── jquery.validate.unobtrusive.min.js
    │   ├── appsettings.Development.json
    │   ├── Models
    │   │   ├── ErrorViewModel.cs
    │   │   ├── PagedResultModel.cs
    │   │   └── ToDoItemModel.cs
    │   ├── appsettings.json
    │   ├── Properties
    │   │   └── launchSettings.json
    │   ├── Repositories
    │   │   ├── ITodoItemRepository.cs
    │   │   └── TodoItemRepository.cs
    │   ├── Entities
    │   │   ├── AppRole.cs
    │   │   ├── City.cs
    │   │   ├── AppRole.hbm.xml
    │   │   ├── City.hbm.xml
    │   │   ├── AppRoleMapping.cs
    │   │   ├── TodoItem.hbm.xml
    │   │   ├── TodoItem.cs
    │   │   ├── AppUser.cs
    │   │   ├── AppUser.hbm.xml
    │   │   ├── CityMapping.cs
    │   │   ├── TodoItemMapping.cs
    │   │   └── AppUserMapping.cs
    │   ├── Program.cs
    │   ├── MappingProfile.cs
    │   ├── hibernate.config
    │   ├── Controllers
    │   │   ├── HomeController.cs
    │   │   ├── RolesController.cs
    │   │   ├── UsersController.cs
    │   │   └── TodoController.cs
    │   ├── WebTest.csproj
    │   └── Startup.cs
    └── UnitTest
    │   ├── LoggingBuilderTest.cs
    │   ├── LoggingBuilder.cs
    │   ├── hibernate.config
    │   ├── UnitTest.csproj
    │   ├── BaseTest.cs
    │   ├── IdentityTest.cs
    │   └── Identity
    │       ├── RoleStoreTest.cs
    │       ├── ConfigTest.cs
    │       └── UserStoreTest.cs
├── .gitignore
├── database
    ├── db_schema.png
    ├── sqlite
    │   ├── 102_cities.sql
    │   ├── 02_app_roles.sql
    │   ├── 101_todo_items.sql
    │   ├── 01_app_users.sql
    │   └── 00_aspnet_core_identity.sql
    ├── mssql
    │   ├── 02_app_roles.sql
    │   ├── 01_app_users.sql
    │   ├── 101_todo_items.sql
    │   └── 00_aspnet_core_identity.sql
    ├── mysql
    │   ├── 02_app_roles.sql
    │   ├── 01_app_users.sql
    │   ├── 101_todo_items.sql
    │   └── 00_aspnet_core_identity.sql
    ├── postgres
    │   ├── 01_app_users.sql
    │   ├── 02_app_roles.sql
    │   ├── 101_todo_items.sql
    │   ├── 102_cities.sql
    │   └── 00_aspnet_core_identity.sql
    └── up.md
├── src
    └── NHibernate.AspNetCore.Identity
    │   ├── Entities
    │       ├── IdentityRole.cs
    │       ├── IdentityRoleClaim.cs
    │       ├── IdentityUserClaim.cs
    │       ├── IdentityUser.cs
    │       ├── IdentityUserRole.cs
    │       ├── IdentityUserLogin.cs
    │       └── IdentityUserToken.cs
    │   ├── IdentityResultExtensions.cs
    │   ├── NHibernate.AspNetCore.Identity.csproj
    │   ├── IdentityBuilderExtensions.cs
    │   ├── ConfigurationExtensions.cs
    │   ├── ConfigurationHelper.cs
    │   ├── Mappings
    │       ├── IdentityUserRole.cs
    │       ├── IdentityUserToken.cs
    │       ├── IdentityUserClaim.cs
    │       ├── IdentityRoleClaim.cs
    │       ├── IdentityUserLogin.cs
    │       └── IdentityRole.cs
    │   ├── RoleStore.cs
    │   └── UserOnlyStore.cs
├── push-package.sh
├── .vscode
    ├── tasks.json
    └── launch.json
├── NHibernate.AspNetCore.Identity.slnx
├── Directory.Packages.props
├── CHANGELOG.md
├── README.md
└── .editorconfig


/test/WebTest/Views/_ViewStart.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     Layout = "_Layout";
3 | }
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | .vs
3 | .vscode
4 | obj
5 | bin
6 | *.user
7 | *.db3
8 | .DS_Store
9 | 


--------------------------------------------------------------------------------
/test/WebTest/Areas/Identity/Pages/_ViewStart.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     Layout = "/Views/Shared/_Layout.cshtml";
3 | }
4 | 


--------------------------------------------------------------------------------
/database/db_schema.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nhibernate/NHibernate.AspNetCore.Identity/HEAD/database/db_schema.png


--------------------------------------------------------------------------------
/test/WebTest/Views/_ViewImports.cshtml:
--------------------------------------------------------------------------------
1 | @using WebTest
2 | @using WebTest.Models
3 | @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
4 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nhibernate/NHibernate.AspNetCore.Identity/HEAD/test/WebTest/wwwroot/favicon.ico


--------------------------------------------------------------------------------
/test/WebTest/Views/Home/Privacy.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     ViewData["Title"] = "Privacy Policy";
3 | }
4 | <h1>@ViewData["Title"]</h1>
5 | 
6 | <p>Use this page to detail your site's privacy policy.</p>
7 | 


--------------------------------------------------------------------------------
/database/sqlite/102_cities.sql:
--------------------------------------------------------------------------------
1 | drop table if exists cities;
2 | 
3 | create table cities (
4 |     id bigint not null,
5 |     name text not null unique,
6 |     population int,
7 |     primary key (id)
8 | );
9 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityRole.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.Identity;
2 | 
3 | namespace NHibernate.AspNetCore.Identity;
4 | 
5 | public class IdentityRole : IdentityRole<string> { }
6 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityRoleClaim.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.Identity;
2 | 
3 | namespace NHibernate.AspNetCore.Identity;
4 | 
5 | public class IdentityRoleClaim : IdentityRoleClaim<string> { }
6 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityUserClaim.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.Identity;
2 | 
3 | namespace NHibernate.AspNetCore.Identity;
4 | 
5 | public class IdentityUserClaim : IdentityUserClaim<string> { }
6 | 


--------------------------------------------------------------------------------
/test/WebTest/appsettings.Development.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Logging": {
 3 |     "LogLevel": {
 4 |       "Default": "Debug",
 5 |       "System": "Information",
 6 |       "Microsoft": "Information"
 7 |     }
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Shared/_ValidationScriptsPartial.cshtml:
--------------------------------------------------------------------------------
1 | <script src="~/lib/jquery-validation/dist/jquery.validate.min.js"></script>
2 | <script src="~/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script>
3 | 


--------------------------------------------------------------------------------
/database/sqlite/02_app_roles.sql:
--------------------------------------------------------------------------------
1 | drop table if exists app_roles;
2 | 
3 | create table app_roles (
4 |   id text not null,
5 |   description text,
6 |   primary key (id),
7 |   constraint fk_98b95005 foreign key (id) references aspnet_roles
8 | );
9 | 


--------------------------------------------------------------------------------
/test/WebTest/Models/ErrorViewModel.cs:
--------------------------------------------------------------------------------
 1 | namespace WebTest.Models;
 2 | 
 3 | public class ErrorViewModel {
 4 | 
 5 |     public string? RequestId { get; set; }
 6 | 
 7 |     public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
 8 | 
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/WebTest/appsettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "ConnectionStrings": {
 3 |     "DefaultConnection": "DataSource=app.db"
 4 |   },
 5 |   "Logging": {
 6 |     "LogLevel": {
 7 |       "Default": "Warning"
 8 |     }
 9 |   },
10 |   "AllowedHosts": "*"
11 | }
12 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/js/site.js:
--------------------------------------------------------------------------------
1 | // Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
2 | // for details on configuring this project to bundle and minify static web assets.
3 | 
4 | // Write your JavaScript code.
5 | 


--------------------------------------------------------------------------------
/database/sqlite/101_todo_items.sql:
--------------------------------------------------------------------------------
 1 | drop table if exists todo_items;
 2 | 
 3 | create table todo_items (
 4 |     id bigint not null,
 5 |     title text not null unique,
 6 |     description text,
 7 |     completed bool not null,
 8 |     user_id text,
 9 |     primary key (id)
10 | );
11 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Home/Index.cshtml:
--------------------------------------------------------------------------------
1 | @{
2 |     ViewData["Title"] = "Home Page";
3 | }
4 | 
5 | <div class="text-center">
6 |     <h1 class="display-4">Welcome</h1>
7 |     <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
8 | </div>
9 | 


--------------------------------------------------------------------------------
/test/WebTest/Properties/launchSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "profiles": {
 3 |     "WebTest": {
 4 |       "commandName": "Project",
 5 |       "launchBrowser": true,
 6 |       "environmentVariables": {
 7 |         "ASPNETCORE_ENVIRONMENT": "Development"
 8 |       },
 9 |       "applicationUrl": "http://localhost:5050"
10 |     }
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/test/WebTest/Models/PagedResultModel.cs:
--------------------------------------------------------------------------------
 1 | namespace WebTest.Models;
 2 | 
 3 | public class PagedRequestModel {
 4 |     public int Take { get; set; } = 10;
 5 |     public int Skip { get; set; }
 6 | }
 7 | 
 8 | public class PagedResultModel<T> : PagedRequestModel {
 9 |     public long Total { get; set; }
10 |     public IList<T>? Data { get; set; }
11 | }
12 | 


--------------------------------------------------------------------------------
/database/sqlite/01_app_users.sql:
--------------------------------------------------------------------------------
 1 | drop table if exists app_users;
 2 | 
 3 | create table app_users (
 4 |     id text not null,
 5 |     create_time datetime not null,
 6 |     last_login datetime,
 7 |     login_count int not null,
 8 |     city_id bigint,
 9 |     primary key (id),
10 |     constraint fk_ec9767ed foreign key (id) references aspnet_users
11 | );
12 | 


--------------------------------------------------------------------------------
/database/mssql/02_app_roles.sql:
--------------------------------------------------------------------------------
 1 | -- auto-generated definition
 2 | create table AppRoles (
 3 |   Id nvarchar(32) not null,
 4 |   Description nvarchar(256) not null,
 5 |   constraint PK_AppRoles primary key (Id),
 6 |   constraint FK_AppRoles_AspNetRoles
 7 |   foreign key (Id) references AspNetRoles (Id)
 8 |     on update cascade
 9 |     on delete cascade
10 | )
11 | go
12 | 


--------------------------------------------------------------------------------
/database/mysql/02_app_roles.sql:
--------------------------------------------------------------------------------
 1 | create table app_roles (
 2 |   id varchar(32) not null comment 'app user id',
 3 |   description varchar(256) null,
 4 |   constraint pk_app_roles primary key (id),
 5 |   constraint fk_app_roles_aspnet_roles foreign key (id)
 6 |     references aspnet_roles (id)
 7 |     on update cascade
 8 |     on delete cascade
 9 | ) comment 'App roles table.';
10 | 


--------------------------------------------------------------------------------
/database/mssql/01_app_users.sql:
--------------------------------------------------------------------------------
 1 | -- auto-generated definition
 2 | create table AppUsers (
 3 |   Id nvarchar(32) not null,
 4 |   CreateTime datetime,
 5 |   LastLogin datetime,
 6 |   LoginCount int not null,
 7 |   constraint PK_AppUsers primary key (Id),
 8 |   constraint FK_AppUsers_AspNetUsers
 9 |     foreign key (Id) references AspNetUsers (Id)
10 |     on update cascade
11 |     on delete cascade
12 | )
13 | go
14 | 


--------------------------------------------------------------------------------
/database/mssql/101_todo_items.sql:
--------------------------------------------------------------------------------
 1 | create table TodoItems (
 2 |   Id bigint identity,
 3 |   Title nvarchar(32) not null,
 4 |   Description nvarchar(128),
 5 |   Completed bit default 0 not null,
 6 |   UserId nvarchar(32) not null,
 7 |   constraint pk_TodoItems primary key (Id),
 8 |   constraint fk_TodoItems_AppUsers
 9 |       foreign key (UserId) references AppUsers (Id)
10 |       on update cascade
11 |       on delete cascade
12 | )
13 | go
14 | 
15 | 


--------------------------------------------------------------------------------
/database/mysql/01_app_users.sql:
--------------------------------------------------------------------------------
 1 | create table app_users (
 2 |   id varchar(32) not null comment 'app user id',
 3 |   create_time datetime null default now(),
 4 |   last_login datetime null,
 5 |   login_count int default 0,
 6 |   constraint pk_app_users primary key (id),
 7 |   constraint fk_app_users_aspnet_users foreign key (id)
 8 |     references aspnet_users (id)
 9 |     on update cascade
10 |     on delete cascade
11 | ) comment 'App users table.';
12 | 


--------------------------------------------------------------------------------
/test/WebTest/Repositories/ITodoItemRepository.cs:
--------------------------------------------------------------------------------
 1 | using WebTest.Models;
 2 | 
 3 | namespace WebTest.Repositories;
 4 | 
 5 | public interface ITodoItemRepository {
 6 | 
 7 |     Task CreateAsync(TodoItemModel model);
 8 | 
 9 |     Task DeleteAsync(long id);
10 | 
11 |     Task<TodoItemModel?> GetByIdAsync(long id);
12 | 
13 |     Task UpdateAsync(long id, TodoItemModel model);
14 | 
15 |     Task<PagedResultModel<TodoItemModel>> SearchAsync(TodoItemSearchModel model);
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/css/site.css:
--------------------------------------------------------------------------------
 1 | html {
 2 |   font-size: 14px;
 3 | }
 4 | 
 5 | @media (min-width: 768px) {
 6 |   html {
 7 |     font-size: 16px;
 8 |   }
 9 | }
10 | 
11 | .btn:focus, .btn:active:focus, .btn-link.nav-link:focus, .form-control:focus, .form-check-input:focus {
12 |   box-shadow: 0 0 0 0.1rem white, 0 0 0 0.25rem #258cfb;
13 | }
14 | 
15 | html {
16 |   position: relative;
17 |   min-height: 100%;
18 | }
19 | 
20 | body {
21 |   margin-bottom: 60px;
22 | }


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppRole.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Mapping.Attributes;
 2 | using NHIdentityRole = NHibernate.AspNetCore.Identity.IdentityRole;
 3 | 
 4 | namespace WebTest.Entities;
 5 | 
 6 | [JoinedSubclass(0, Schema = "public", Table = "app_roles", ExtendsType = typeof(NHIdentityRole))]
 7 | [Key(1, Column = "id")]
 8 | public class AppRole : NHIdentityRole {
 9 | 
10 |     [Property(Column = "description", Type = "string", Length = 256, NotNull = false)]
11 |     public virtual string? Description { get; set; }
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/test/UnitTest/LoggingBuilderTest.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.Extensions.Logging;
 2 | 
 3 | namespace UnitTest;
 4 | 
 5 | [TestFixture]
 6 | public class LoggingBuilderTest {
 7 | 
 8 |     [Test]
 9 |     public void _01_CanBuildLoggingFactory() {
10 |         var target = new LoggingBuilder();
11 |         var factory = target.BuildLoggerFactory();
12 |         That(factory, Is.Not.Null);
13 |         var logger = factory.CreateLogger("LoggingBuilderTest");
14 |         Console.WriteLine(logger.GetType());
15 |         logger.LogInformation("_01_CanBuildLoggingFactory");
16 |     }
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/test/WebTest/Program.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | var builder = WebApplication.CreateBuilder(args);
 3 | builder.Logging.ClearProviders().AddConsole();
 4 | var startup = new WebTest.Startup(builder.Configuration);
 5 | startup.ConfigureServices(builder.Services);
 6 | var app = builder.Build();
 7 | 
 8 | var loggerFactory = app.Services.GetService<ILoggerFactory>();
 9 | 
10 | if (loggerFactory == null) {
11 |     throw new ApplicationException("Logger Factory is not configured!");
12 | }
13 | 
14 | startup.Configure(
15 |     app,
16 |     builder.Environment,
17 |     loggerFactory
18 | );
19 | app.Run();
20 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/City.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Mapping.Attributes;
 2 | 
 3 | namespace WebTest.Entities;
 4 | 
 5 | [Class(Schema = "public", Table = "cities")]
 6 | public class City {
 7 | 
 8 |     [Id(Name = "Id", Column = "id", Type = "long", Generator = "trigger-identity")]
 9 |     public virtual long Id { get; set; }
10 | 
11 |     [Property(Column = "name", Type = "string", Length = 64, NotNull = true, Unique = true)]
12 |     public virtual string? Name { get; set; }
13 | 
14 |     [Property(Column = "population", Type = "int", NotNull = false)]
15 |     public virtual int Population { get; set; }
16 | 
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/push-package.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -e
 2 | export PACKAGE_VERSION="9.0.7"
 3 | export PACKAGE_RELEASE_NOTES="Update to .NET 9.0.10;Update NHibernate to 5.6.0;Update other nuget packages;"
 4 | export PACKAGE_TAGS="nhibernate, aspnetcore, identity"
 5 | 
 6 | PROJECTS=( \
 7 |   "src/NHibernate.AspNetCore.Identity/NHibernate.AspNetCore.Identity.csproj" \
 8 | )
 9 | 
10 | for PROJ in "${PROJECTS[@]}"
11 | do
12 |   echo "packing $PROJ"
13 |   dotnet pack $PROJ -c Release --output ./nupkgs/
14 | done
15 | 
16 | dotnet nuget push ./nupkgs/*.nupkg -s nuget.org -k $(cat ~/.nuget/github.txt) \
17 |   --skip-duplicate
18 | 
19 | rm -rf ./nupkgs
20 | 


--------------------------------------------------------------------------------
/database/mysql/101_todo_items.sql:
--------------------------------------------------------------------------------
 1 | -- auto-generated definition
 2 | create table todo_items
 3 | (
 4 |   id bigint auto_increment comment 'todo item id',
 5 |   title varchar(32)not null comment 'todo item title',
 6 |   description varchar(128) null comment 'todo item description',
 7 |   completed tinyint(1) default 0 not null comment 'todo item is completed.',
 8 |   user_id varchar(32)not null comment 'todo item user id',
 9 |   constraint pk_todo_items primary key (id),
10 |   constraint fk_todo_items_users
11 |     foreign key (user_id) references app_users (id)
12 |       on update cascade
13 |       on delete cascade
14 | )
15 | comment 'todo items table';
16 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "2.0.0",
 3 |   "tasks": [
 4 |     {
 5 |       "label": "build",
 6 |       "command": "dotnet",
 7 |       "type": "process",
 8 |       "args": [
 9 |         "build",
10 |         "${workspaceFolder}/NHibernate.AspNetCore.Identity.sln"
11 |       ],
12 |       "problemMatcher": "$msCompile",
13 |       "group": "build"
14 |     },
15 |     {
16 |       "label": "test",
17 |       "command": "dotnet",
18 |       "type": "process",
19 |       "args": [
20 |         "test"
21 |       ],
22 |       "options": {
23 |         "cwd": "${workspaceFolder}/test/UnitTest"
24 |       },
25 |       "dependsOn": ["build"]
26 |     }
27 |   ]
28 | }
29 | 


--------------------------------------------------------------------------------
/test/UnitTest/LoggingBuilder.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.Extensions.DependencyInjection;
 2 | using Microsoft.Extensions.Logging;
 3 | 
 4 | namespace UnitTest;
 5 | 
 6 | public class LoggingBuilder {
 7 | 
 8 |     private ServiceProvider? provider;
 9 | 
10 |     private readonly IServiceCollection services = new ServiceCollection();
11 | 
12 |     public ILoggerFactory BuildLoggerFactory() {
13 |         if (provider == null) {
14 |             services.AddLogging(logging => {
15 |                 logging.AddConsole();
16 |             });
17 |             provider = services.BuildServiceProvider();
18 |         }
19 |         return provider.GetService<ILoggerFactory>()!;
20 |     }
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppRole.hbm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <hibernate-mapping
 3 |   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 5 |   xmlns="urn:nhibernate-mapping-2.2"
 6 |   namespace="WebTest.Entities" assembly="WebTest">
 7 | 
 8 |   <joined-subclass name="AppRole" schema="public" table="app_roles" extends="NHibernate.AspNetCore.Identity.IdentityRole, NHibernate.AspNetCore.Identity, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
 9 |     <key column="id" />
10 |     <property name="Description" column="description" type="string" length="256" />
11 |   </joined-subclass>
12 | 
13 | </hibernate-mapping>
14 | 


--------------------------------------------------------------------------------
/test/UnitTest/hibernate.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
 3 |   <session-factory>
 4 |     <property name="connection.connection_string">server=127.0.0.1;port=5432;database=nhibernate;user id=postgres;password=pgsql@17;</property>
 5 |     <property name="dialect">NHibernate.Dialect.PostgreSQL83Dialect</property>
 6 |     <property name="connection.driver_class">NHibernate.Driver.NpgsqlDriver</property>
 7 |     <property name="show_sql">false</property>
 8 |     <property name="format_sql">false</property>
 9 |     <property name="adonet.batch_size">10</property>
10 |   </session-factory>
11 | </hibernate-configuration>
12 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/City.hbm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <hibernate-mapping
 3 |   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 5 |   xmlns="urn:nhibernate-mapping-2.2"
 6 |   namespace="WebTest.Entities" assembly="WebTest">
 7 | 
 8 |   <class name="City" schema="public" table="cities">
 9 |     <id name="Id" column="id" type="long">
10 |       <generator class="trigger-identity" />
11 |     </id>
12 |     <property name="Name" column="name" type="string" length="64" not-null="true" unique="true" />
13 |     <property name="Population" column="population" type="int" not-null="false" />
14 |   </class>
15 | 
16 | </hibernate-mapping>
17 | 


--------------------------------------------------------------------------------
/NHibernate.AspNetCore.Identity.slnx:
--------------------------------------------------------------------------------
 1 | <Solution>
 2 |   <Configurations>
 3 |     <Platform Name="Any CPU" />
 4 |     <Platform Name="x64" />
 5 |     <Platform Name="x86" />
 6 |   </Configurations>
 7 |   <Folder Name="/assets/">
 8 |     <File Path="CHANGELOG.md" />
 9 |     <File Path="push-package.sh" />
10 |     <File Path="README.md" />
11 |     <File Path="Directory.Packages.props" />
12 |   </Folder>
13 |   <Folder Name="/src/">
14 |     <Project Path="src/NHibernate.AspNetCore.Identity/NHibernate.AspNetCore.Identity.csproj" />
15 |   </Folder>
16 |   <Folder Name="/test/">
17 |     <Project Path="test/UnitTest/UnitTest.csproj" />
18 |     <Project Path="test/WebTest/WebTest.csproj" />
19 |   </Folder>
20 | </Solution>


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/IdentityResultExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System.Text;
 2 | using Microsoft.AspNetCore.Identity;
 3 | 
 4 | namespace NHibernate.AspNetCore.Identity;
 5 | 
 6 | public static class IdentityResultExtensions {
 7 | 
 8 |     public static string GetErrorsString(this IdentityResult result) {
 9 |         if (result == null) {
10 |             throw new ArgumentNullException(nameof(result));
11 |         }
12 |         if (result.Succeeded) {
13 |             return string.Empty;
14 |         }
15 |         var err = new StringBuilder();
16 |         foreach (var error in result.Errors) {
17 |             err.AppendLine($"{error.Code}:{error.Description}");
18 |         }
19 |         return err.ToString();
20 |     }
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/test/WebTest/MappingProfile.cs:
--------------------------------------------------------------------------------
 1 | using AutoMapper;
 2 | using WebTest.Entities;
 3 | using WebTest.Models;
 4 | 
 5 | namespace WebTest;
 6 | 
 7 | public class MappingProfile : Profile {
 8 | 
 9 |     public MappingProfile() {
10 |         CreateMap<TodoItem, TodoItemModel>()
11 |             .ForMember(
12 |                 dest => dest.UserId,
13 |                 map => map.MapFrom(e => e.User!.Id!)
14 |             )
15 |             .ForMember(
16 |                 d => d.UserName,
17 |                 m => m.MapFrom(e => e.User!.UserName)
18 |             )
19 |             .ReverseMap()
20 |             .ForMember(
21 |                 d => d.User,
22 |                 m => m.MapFrom(s => new AppUser { Id = s.UserId! })
23 |             );
24 |     }
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/database/postgres/01_app_users.sql:
--------------------------------------------------------------------------------
 1 | -- table: public.app_users
 2 | 
 3 | -- drop table public.app_users;
 4 | 
 5 | create table public.app_users
 6 | (
 7 |     id character varying(32) collate pg_catalog."default" not null,
 8 |     create_time timestamp without time zone not null default now(),
 9 |     last_login timestamp without time zone,
10 |     login_count integer default 0,
11 |     constraint pk_app_users primary key (id),
12 |     constraint fk_aspnet_users_id foreign key (id)
13 |         references public.aspnet_users (id) match simple
14 |         on update cascade
15 |         on delete cascade
16 | )
17 | with (
18 |     oids = false
19 | )
20 | tablespace pg_default;
21 | 
22 | alter table public.app_users
23 |     owner to postgres;
24 | comment on table public.app_users
25 |     is 'application users table.';
26 | 


--------------------------------------------------------------------------------
/database/postgres/02_app_roles.sql:
--------------------------------------------------------------------------------
 1 | -- table: public.app_roles
 2 | 
 3 | -- drop table public.app_roles;
 4 | 
 5 | create table public.app_roles
 6 | (
 7 |     id character varying(32) collate pg_catalog."default" not null,
 8 |     description character varying(256) collate pg_catalog."default",
 9 |     constraint pk_app_roles primary key (id),
10 |     constraint fk_aspnet_roles_id foreign key (id)
11 |         references public.aspnet_roles (id) match simple
12 |         on update cascade
13 |         on delete cascade
14 | )
15 | with (
16 |     oids = false
17 | )
18 | tablespace pg_default;
19 | 
20 | alter table public.app_roles
21 |     owner to postgres;
22 | comment on table public.app_roles
23 |     is 'application roles table.';
24 | 
25 | comment on column public.app_roles.description
26 |     is 'roles description';
27 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppRoleMapping.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate;
 2 | using NHibernate.Mapping.ByCode.Conformist;
 3 | using NHIdentityRole = NHibernate.AspNetCore.Identity.IdentityRole;
 4 | 
 5 | namespace WebTest.Entities;
 6 | 
 7 | public class AppRoleMapping : JoinedSubclassMapping<AppRole> {
 8 | 
 9 |     public AppRoleMapping() {
10 |         ExplicitDeclarationsHolder
11 |             .AddAsRootEntity(typeof(NHIdentityRole));
12 |         Extends(typeof(NHIdentityRole));
13 |         Schema("public");
14 |         Table("app_roles");
15 |         Key(k => k.Column("id"));
16 |         Property(
17 |             p => p.Description,
18 |             maping => {
19 |                 maping.Column("description");
20 |                 maping.Type(NHibernateUtil.String);
21 |                 maping.Length(256);
22 |             }
23 |         );
24 |     }
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/TodoItem.hbm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <hibernate-mapping
 3 |   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 5 |   xmlns="urn:nhibernate-mapping-2.2"
 6 |   namespace="WebTest.Entities" assembly="WebTest">
 7 | 
 8 |   <class name="TodoItem" schema="public" table="todo_items">
 9 |     <id name="Id" column="id" type="long">
10 |       <generator class="trigger-identity" />
11 |     </id>
12 |     <property name="Title" column="title" type="string" length="32" not-null="true" unique="true" />
13 |     <property name="Description" column="description" type="string" length="128" not-null="false" />
14 |     <property name="Completed" column="completed" type="bool" not-null="true" />
15 |     <many-to-one name="User" column="user_id" not-found="ignore" />
16 |   </class>
17 | 
18 | </hibernate-mapping>
19 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/TodoItem.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Mapping.Attributes;
 2 | 
 3 | namespace WebTest.Entities;
 4 | 
 5 | [Class(Schema = "public", Table = "todo_items")]
 6 | public class TodoItem {
 7 | 
 8 |     [Id(Name = "Id", Column = "id", Type = "long", Generator = "trigger-identity")]
 9 |     public virtual long Id { get; set; }
10 | 
11 |     [Property(Column = "title", Type = "string", Length = 32, NotNull = true, Unique = true)]
12 |     public virtual string? Title { get; set; }
13 | 
14 |     [Property(Column = "description", Type = "string", Length = 128, NotNull = false)]
15 |     public virtual string? Description { get; set; }
16 | 
17 |     [Property(Column = "completed", Type = "bool", NotNull = true)]
18 |     public virtual bool Completed { get; set; }
19 | 
20 |     [ManyToOne(Column = "user_id", NotFound = NotFoundMode.Ignore)]
21 |     public virtual AppUser? User { get; set; }
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/test/WebTest/Models/ToDoItemModel.cs:
--------------------------------------------------------------------------------
 1 | namespace WebTest.Models;
 2 | 
 3 | /// <summary></summary>
 4 | public class TodoItemModel {
 5 |     /// <summary> to do item summary</summary>
 6 |     public string? Id { get; set; }
 7 |     /// <summary>  </summary>
 8 |     public string? Title { get; set; }
 9 |     /// <summary>  </summary>
10 |     public string? Description { get; set; }
11 |     /// <summary>  </summary>
12 |     public bool? Completed { get; set; }
13 |     /// <summary>  </summary>
14 |     public string? UserId { get; set; }
15 |     /// <summary>  </summary>
16 |     public string? UserName { get; set; }
17 | }
18 | 
19 | public class TodoItemSearchModel : PagedRequestModel {
20 |     public string? Title { get; set; }
21 |     public string? Description { get; set; }
22 |     public bool? Completed { get; set; }
23 |     public string? UserId { get; set; }
24 |     public string? UserName { get; set; }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/WebTest/hibernate.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
 3 |   <session-factory>
 4 |     <property name="connection.connection_string">server=127.0.0.1;port=5432;database=nhibernate;user id=postgres;password=aJv6YoG0CkM9YdqP;</property>
 5 |     <property name="connection.driver_class">NHibernate.Extensions.Npgsql.NpgsqlDriver,NHibernate.Extensions.Npgsql</property>
 6 |     <property name="dialect">NHibernate.Extensions.Npgsql.NpgsqlDialect,NHibernate.Extensions.Npgsql</property>
 7 |     <property name="linqtohql.generatorsregistry">NHibernate.Extensions.Npgsql.LinqToHqlGeneratorsRegistry,NHibernate.Extensions.Npgsql</property>
 8 |     <property name="show_sql">true</property>
 9 |     <property name="format_sql">true</property>
10 |     <property name="adonet.batch_size">10</property>
11 |   </session-factory>
12 | </hibernate-configuration>
13 | 


--------------------------------------------------------------------------------
/test/WebTest/Controllers/HomeController.cs:
--------------------------------------------------------------------------------
 1 | using System.Diagnostics;
 2 | using Microsoft.AspNetCore.Mvc;
 3 | using WebTest.Models;
 4 | 
 5 | namespace WebTest.Controllers;
 6 | 
 7 |     public class HomeController : Controller {
 8 | 
 9 |     private readonly ILogger<HomeController> logger;
10 | 
11 |     public HomeController(ILogger<HomeController> logger) {
12 |         this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
13 |     }
14 | 
15 |     public IActionResult Index() {
16 |         return View();
17 |     }
18 | 
19 |     public IActionResult Privacy() {
20 |         return View();
21 |     }
22 | 
23 |     [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
24 |     public IActionResult Error() {
25 |         logger.LogError("Error caught.");
26 |         return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
27 |     }
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/test/WebTest/Controllers/RolesController.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | using Microsoft.AspNetCore.Mvc;
 3 | using WebTest.Entities;
 4 | 
 5 | namespace WebTest.Controllers;
 6 | 
 7 | [ApiController]
 8 | [Route("api/[controller]")]
 9 | public class RolesController : ControllerBase {
10 | 
11 |     private readonly RoleManager<AppRole> manager;
12 | 
13 |     public RolesController(RoleManager<AppRole> manager) {
14 |         this.manager = manager ?? throw new ArgumentNullException(nameof(manager));
15 |     }
16 | 
17 |     [Route("")]
18 |     public async Task<ActionResult<IList<AppRole>>> GetAll() {
19 |         if (!await manager.RoleExistsAsync("TestRole")) {
20 |             var role = new AppRole {
21 |                 Name = "TestRole",
22 |                 Description = "Test Role"
23 |             };
24 |             var result = await manager.CreateAsync(role);
25 |         }
26 |         return manager.Roles.ToList();
27 |     }
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppUser.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Mapping.Attributes;
 2 | using NHIdentityUser = NHibernate.AspNetCore.Identity.IdentityUser;
 3 | 
 4 | namespace WebTest.Entities;
 5 | 
 6 | [JoinedSubclass(0, Schema = "public", Table = "app_users", ExtendsType = typeof(NHIdentityUser))]
 7 | [Key(1, Column = "id")]
 8 | public class AppUser : NHIdentityUser {
 9 | 
10 |     [Property(Column = "create_time", Type = "datetime", NotNull = true, Generated = PropertyGeneration.Insert, Update = false, Insert = false)]
11 |     public virtual DateTime? CreateTime { get; set; }
12 | 
13 |     [Property(Column = "last_login", Type = "datetime", NotNull = false)]
14 |     public virtual DateTime? LastLogin { get; set; }
15 | 
16 |     [Property(Column = "login_count", Type = "int", NotNull = true)]
17 |     public virtual int LoginCount { get; set; }
18 | 
19 |     [ManyToOne(Column = "city_id", NotFound = NotFoundMode.Ignore)]
20 |     public virtual City? City { get; set; }
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityUser.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | 
 3 | namespace NHibernate.AspNetCore.Identity;
 4 | 
 5 | public class IdentityUser : IdentityUser<string> {
 6 | 
 7 |     public virtual long? LockoutEndUnixTimeSeconds { get; set; }
 8 | 
 9 |     public override DateTimeOffset? LockoutEnd {
10 |         get {
11 |             if (!LockoutEndUnixTimeSeconds.HasValue) {
12 |                 return null;
13 |             }
14 |             var offset = DateTimeOffset.FromUnixTimeSeconds(
15 |                 LockoutEndUnixTimeSeconds.Value
16 |             );
17 |             return TimeZoneInfo.ConvertTime(offset, TimeZoneInfo.Local);
18 |         }
19 |         set {
20 |             if (value.HasValue) {
21 |                 LockoutEndUnixTimeSeconds = value.Value.ToUnixTimeSeconds();
22 |             }
23 |             else {
24 |                 LockoutEndUnixTimeSeconds = null;
25 |             }
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppUser.hbm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <hibernate-mapping
 3 |   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 5 |   xmlns="urn:nhibernate-mapping-2.2"
 6 |   namespace="WebTest.Entities" assembly="WebTest">
 7 | 
 8 |   <joined-subclass name="AppUser" table="app_users" schema="public" extends="NHibernate.AspNetCore.Identity.IdentityUser, NHibernate.AspNetCore.Identity, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
 9 |     <key column="id" />
10 |     <property name="CreateTime" column="create_time" type="datetime" not-null="true" generated="insert" update="false" insert="false" />
11 |     <property name="LastLogin" column="last_login" type="datetime" not-null="false" />
12 |     <property name="LoginCount" column="login_count" type="int" not-null="true" />
13 |     <!-- <many-to-one name="City" column="city_id" not-found="ignore" /> -->
14 |   </joined-subclass>
15 | 
16 | </hibernate-mapping>
17 | 
18 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Shared/Error.cshtml:
--------------------------------------------------------------------------------
 1 | @model ErrorViewModel
 2 | @{
 3 |     ViewData["Title"] = "Error";
 4 | }
 5 | 
 6 | <h1 class="text-danger">Error.</h1>
 7 | <h2 class="text-danger">An error occurred while processing your request.</h2>
 8 | 
 9 | @if (Model.ShowRequestId)
10 | {
11 |     <p>
12 |         <strong>Request ID:</strong> <code>@Model.RequestId</code>
13 |     </p>
14 | }
15 | 
16 | <h3>Development Mode</h3>
17 | <p>
18 |     Swapping to <strong>Development</strong> environment will display more detailed information about the error that occurred.
19 | </p>
20 | <p>
21 |     <strong>The Development environment shouldn't be enabled for deployed applications.</strong>
22 |     It can result in displaying sensitive information from exceptions to end users.
23 |     For local debugging, enable the <strong>Development</strong> environment by setting the <strong>ASPNETCORE_ENVIRONMENT</strong> environment variable to <strong>Development</strong>
24 |     and restarting the app.
25 | </p>
26 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   // Use IntelliSense to find out which attributes exist for C# debugging
 3 |   // Use hover for the description of the existing attributes
 4 |   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
 5 |   "version": "0.2.0",
 6 |   "configurations": [
 7 |     {
 8 |       "name": "WebTest",
 9 |       "type": "coreclr",
10 |       "request": "launch",
11 |       "preLaunchTask": "build",
12 |       // If you have changed target frameworks, make sure to update the program path.
13 |       "program": "${workspaceFolder}/test/WebTest/bin/Debug/net7.0/WebTest.dll",
14 |       "args": [],
15 |       "cwd": "${workspaceFolder}/test/WebTest",
16 |       // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
17 |       "console": "internalConsole",
18 |       "stopAtEntry": false,
19 |       "internalConsoleOptions": "openOnSessionStart"
20 |     }
21 |   ]
22 | }
23 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityUserRole.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | 
 3 | namespace NHibernate.AspNetCore.Identity;
 4 | 
 5 | public class IdentityUserRole : IdentityUserRole<string> {
 6 | 
 7 |     protected bool Equals(IdentityUserRole other) {
 8 |         return RoleId == other.RoleId
 9 |             && UserId == other.UserId;
10 |     }
11 | 
12 |     public override bool Equals(object? obj) {
13 |         if (ReferenceEquals(null, obj)) {
14 |             return false;
15 |         }
16 |         if (ReferenceEquals(this, obj)) {
17 |             return true;
18 |         }
19 |         if (obj.GetType() != GetType()) {
20 |             return false;
21 |         }
22 |         return Equals((IdentityUserRole)obj);
23 |     }
24 | 
25 |     public override int GetHashCode() {
26 |         unchecked {
27 |             var hashCode = 0;
28 |             hashCode = RoleId.GetHashCode();
29 |             hashCode = (hashCode * 397) ^ UserId.GetHashCode();
30 |             return hashCode;
31 |         }
32 |     }
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/database/postgres/101_todo_items.sql:
--------------------------------------------------------------------------------
 1 | create table public.todo_items
 2 | (
 3 |     id bigint not null default public.snow_flake_id(),
 4 |     title character varying(32) not null,
 5 |     description character varying(128),
 6 |     completed boolean not null default false,
 7 |     user_id character varying(32) not null,
 8 |     constraint pk_todo_items primary key (id),
 9 |     constraint fk_todo_items_users foreign key (user_id)
10 |         references public.app_users (id) match simple
11 |         on update cascade
12 |         on delete cascade
13 | )
14 | with (
15 |     oids = false
16 | );
17 | 
18 | alter table public.todo_items
19 |     owner to postgres;
20 | comment on table public.todo_items
21 |     is 'todo items';
22 | 
23 | comment on column public.todo_items.id
24 |     is 'todo item id';
25 | 
26 | comment on column public.todo_items.title
27 |     is 'todo item title.';
28 | 
29 | comment on column public.todo_items.description
30 |     is 'todo item description';
31 | 
32 | comment on column public.todo_items.completed
33 |     is 'is completed?';
34 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityUserLogin.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | 
 3 | namespace NHibernate.AspNetCore.Identity;
 4 | 
 5 | public class IdentityUserLogin : IdentityUserLogin<string> {
 6 | 
 7 |     protected bool Equals(IdentityUserLogin other) {
 8 |         return LoginProvider == other.LoginProvider
 9 |             && ProviderKey == other.ProviderKey;
10 |     }
11 | 
12 |     public override bool Equals(object? obj) {
13 |         if (ReferenceEquals(null, obj)) {
14 |             return false;
15 |         }
16 |         if (ReferenceEquals(this, obj)) {
17 |             return true;
18 |         }
19 |         if (obj.GetType() != GetType()) {
20 |             return false;
21 |         }
22 |         return Equals((IdentityUserLogin)obj);
23 |     }
24 | 
25 |     public override int GetHashCode() {
26 |         unchecked {
27 |             var hashCode = 0;
28 |             hashCode = LoginProvider.GetHashCode();
29 |             hashCode = (hashCode * 397) ^ ProviderKey.GetHashCode();
30 |             return hashCode;
31 |         }
32 |     }
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Shared/_LoginPartial.cshtml:
--------------------------------------------------------------------------------
 1 | @using Microsoft.AspNetCore.Identity
 2 | @inject SignInManager<WebTest.Entities.AppUser> SignInManager
 3 | @inject UserManager<WebTest.Entities.AppUser> UserManager
 4 | 
 5 | <ul class="navbar-nav">
 6 | @if (SignInManager.IsSignedIn(User))
 7 | {
 8 |     <li class="nav-item">
 9 |         <a  class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" title="Manage">Hello @User.Identity?.Name!</a>
10 |     </li>
11 |     <li class="nav-item">
12 |         <form  class="form-inline" asp-area="Identity" asp-page="/Account/Logout" asp-route-returnUrl="@Url.Action("Index", "Home", new { area = "" })">
13 |             <button  type="submit" class="nav-link btn btn-link text-dark">Logout</button>
14 |         </form>
15 |     </li>
16 | }
17 | else
18 | {
19 |     <li class="nav-item">
20 |         <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
21 |     </li>
22 |     <li class="nav-item">
23 |         <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
24 |     </li>
25 | }
26 | </ul>
27 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Shared/_Layout.cshtml.css:
--------------------------------------------------------------------------------
 1 | /* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
 2 | for details on configuring this project to bundle and minify static web assets. */
 3 | 
 4 | a.navbar-brand {
 5 |   white-space: normal;
 6 |   text-align: center;
 7 |   word-break: break-all;
 8 | }
 9 | 
10 | a {
11 |   color: #0077cc;
12 | }
13 | 
14 | .btn-primary {
15 |   color: #fff;
16 |   background-color: #1b6ec2;
17 |   border-color: #1861ac;
18 | }
19 | 
20 | .nav-pills .nav-link.active, .nav-pills .show > .nav-link {
21 |   color: #fff;
22 |   background-color: #1b6ec2;
23 |   border-color: #1861ac;
24 | }
25 | 
26 | .border-top {
27 |   border-top: 1px solid #e5e5e5;
28 | }
29 | .border-bottom {
30 |   border-bottom: 1px solid #e5e5e5;
31 | }
32 | 
33 | .box-shadow {
34 |   box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
35 | }
36 | 
37 | button.accept-policy {
38 |   font-size: 1rem;
39 |   line-height: inherit;
40 | }
41 | 
42 | .footer {
43 |   position: absolute;
44 |   bottom: 0;
45 |   width: 100%;
46 |   white-space: nowrap;
47 |   line-height: 60px;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Entities/IdentityUserToken.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | 
 3 | namespace NHibernate.AspNetCore.Identity;
 4 | 
 5 | public class IdentityUserToken : IdentityUserToken<string> {
 6 | 
 7 |     protected bool Equals(IdentityUserToken other) {
 8 |         return UserId == other.UserId
 9 |             && LoginProvider == other.LoginProvider
10 |             && Name == other.Name;
11 |     }
12 | 
13 |     public override bool Equals(object? obj) {
14 |         if (ReferenceEquals(null, obj)) {
15 |             return false;
16 |         }
17 |         if (ReferenceEquals(this, obj)) {
18 |             return true;
19 |         }
20 |         if (obj.GetType() != GetType()) {
21 |             return false;
22 |         }
23 |         return Equals((IdentityUserToken)obj);
24 |     }
25 | 
26 |     public override int GetHashCode() {
27 |         unchecked {
28 |             var hashCode = 0;
29 |             hashCode = UserId.GetHashCode();
30 |             hashCode = (hashCode * 397) ^ LoginProvider.GetHashCode();
31 |             hashCode = (hashCode * 397) ^ Name.GetHashCode();
32 |             return hashCode;
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/jquery/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright OpenJS Foundation and other contributors, https://openjsf.org/
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining
 5 | a copy of this software and associated documentation files (the
 6 | "Software"), to deal in the Software without restriction, including
 7 | without limitation the rights to use, copy, modify, merge, publish,
 8 | distribute, sublicense, and/or sell copies of the Software, and to
 9 | permit persons to whom the Software is furnished to do so, subject to
10 | the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/jquery-validation/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | =====================
 3 | 
 4 | Copyright Jörn Zaefferer
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/bootstrap/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2011-2021 Twitter, Inc.
 4 | Copyright (c) 2011-2021 The Bootstrap Authors
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/test/WebTest/WebTest.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.Web">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net9.0</TargetFramework>
 4 |     <Nullable>enable</Nullable>
 5 |     <ImplicitUsings>enable</ImplicitUsings>
 6 |     <UserSecretsId>aspnet-WebTest-2248A449-FB12-43B9-B501-6761982E7A88</UserSecretsId>
 7 |   </PropertyGroup>
 8 |   <ItemGroup>
 9 |     <PackageReference Include="Microsoft.AspNetCore.Identity.UI" />
10 |     <PackageReference Include="AutoMapper" />
11 |     <PackageReference Include="NHibernate" />
12 |     <PackageReference Include="NHibernate.Mapping.Attributes" />
13 |     <PackageReference Include="NHibernate.Extensions.Npgsql" />
14 |     <PackageReference Include="NHibernate.Extensions.NetCore" />
15 |     <PackageReference Include="Npgsql" />
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ProjectReference Include="..\..\src\NHibernate.AspNetCore.Identity\NHibernate.AspNetCore.Identity.csproj" />
19 |   </ItemGroup>
20 |   <ItemGroup>
21 |     <None Remove="Entities\*.hbm.xml" />
22 |     <EmbeddedResource Include="Entities\*.hbm.xml" />
23 |   </ItemGroup>
24 | 
25 |   <ItemGroup>
26 |     <Content Update="hibernate.config">
27 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
28 |     </Content>
29 |   </ItemGroup>
30 | 
31 | </Project>
32 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/CityMapping.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate;
 2 | using NHibernate.Mapping.ByCode;
 3 | using NHibernate.Mapping.ByCode.Conformist;
 4 | 
 5 | namespace WebTest.Entities;
 6 | 
 7 | public class CityMapping : ClassMapping<City> {
 8 | 
 9 |     public CityMapping() {
10 |         Schema("public");
11 |         Table("cities");
12 |         Id(
13 |             e => e.Id,
14 |             mapping => {
15 |                 mapping.Column("id");
16 |                 mapping.Type(NHibernateUtil.Int64);
17 |                 mapping.Generator(Generators.TriggerIdentity);
18 |             }
19 |         );
20 |         Property(
21 |             e => e.Name,
22 |             mapping => {
23 |                 mapping.Column("name");
24 |                 mapping.Type(NHibernateUtil.String);
25 |                 mapping.Length(64);
26 |                 mapping.NotNullable(true);
27 |                 mapping.Unique(true);
28 |             }
29 |         );
30 |         Property(
31 |             e => e.Population,
32 |             mapping => {
33 |                 mapping.Column("population");
34 |                 mapping.Type(NHibernateUtil.Int32);
35 |                 mapping.NotNullable(true);
36 |                 mapping.Unique(true);
37 |             }
38 |         );
39 |     }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/jquery-validation-unobtrusive/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) .NET Foundation and Contributors
 4 | 
 5 | All rights reserved.
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy
 8 | of this software and associated documentation files (the "Software"), to deal
 9 | in the Software without restriction, including without limitation the rights
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | copies of the Software, and to permit persons to whom the Software is
12 | furnished to do so, subject to the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be included in all
15 | copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 | SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/database/postgres/102_cities.sql:
--------------------------------------------------------------------------------
 1 | -- table: public.cities
 2 | 
 3 | -- drop table public.cities;
 4 | -- create cities table;
 5 | create table public.cities
 6 | (
 7 |     id bigint not null default public.snow_flake_id(),
 8 |     name character varying(64) collate pg_catalog."default",
 9 |     population integer,
10 |     constraint pk_cities primary key (id)
11 | )
12 | with (
13 |     oids = false
14 | )
15 | tablespace pg_default;
16 | 
17 | alter table public.cities
18 |     owner to postgres;
19 | -- insert sample city data
20 | insert into cities(name, population) values('bratislava', 432000);
21 | insert into cities(name, population) values('budapest', 1759000);
22 | insert into cities(name, population) values('prague', 1280000);
23 | insert into cities(name, population) values('warsaw', 1748000);
24 | insert into cities(name, population) values('los angeles', 3971000);
25 | insert into cities(name, population) values('new york', 8550000);
26 | insert into cities(name, population) values('edinburgh', 464000);
27 | insert into cities(name, population) values('berlin', 3671000);
28 | 
29 | -- add city_id to app_users, constraint as foreign key;
30 | alter table public.app_users
31 |     add column city_id bigint;
32 | alter table public.app_users
33 |     add constraint fk_app_users_city_id foreign key (city_id)
34 |     references public.cities (id) match simple
35 |     on update cascade
36 |     on delete cascade
37 |     not valid;
38 | 


--------------------------------------------------------------------------------
/test/UnitTest/UnitTest.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net9.0</TargetFramework>
 4 |     <IsPackable>false</IsPackable>
 5 |     <Nullable>enable</Nullable>
 6 |     <ImplicitUsings>enable</ImplicitUsings>
 7 |   </PropertyGroup>
 8 |   <ItemGroup>
 9 |     <Using Include="NUnit.Framework" />
10 |     <Using Static="true" Include="NUnit.Framework.Assert" />
11 |   </ItemGroup>
12 |   <ItemGroup>
13 |     <FrameworkReference Include="Microsoft.AspNetCore.App" />
14 |   </ItemGroup>
15 |   <ItemGroup>
16 |     <PackageReference Include="Microsoft.NET.Test.Sdk" />
17 |     <PackageReference Include="NUnit" />
18 |     <PackageReference Include="NUnit3TestAdapter">
19 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
20 |       <PrivateAssets>all</PrivateAssets>
21 |     </PackageReference>
22 |   </ItemGroup>
23 |   <ItemGroup>
24 |     <None Remove="**/*.hbm.xml" />
25 |     <EmbeddedResource Include="**/*.hbm.xml" />
26 |   </ItemGroup>
27 |   <ItemGroup>
28 |     <None Update="hibernate.config">
29 |       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
30 |     </None>
31 |   </ItemGroup>
32 |   <ItemGroup>
33 |     <ProjectReference Include="..\..\src\NHibernate.AspNetCore.Identity\NHibernate.AspNetCore.Identity.csproj" />
34 |     <ProjectReference Include="..\WebTest\WebTest.csproj" />
35 |   </ItemGroup>
36 | </Project>
37 | 


--------------------------------------------------------------------------------
/Directory.Packages.props:
--------------------------------------------------------------------------------
 1 | <Project>
 2 |   <PropertyGroup>
 3 |     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
 4 |   </PropertyGroup>
 5 |   <!--
 6 |   <ItemDefinitionGroup>
 7 |     <PackageReference>
 8 |       <PrivateAssets>Compile</PrivateAssets>
 9 |     </PackageReference>
10 |   </ItemDefinitionGroup>
11 |   -->
12 |   <ItemGroup>
13 |     <PackageVersion Include="Microsoft.Extensions.Identity.Core" Version="9.0.10" />
14 |     <PackageVersion Include="Microsoft.Extensions.Identity.Stores" Version="9.0.10" />
15 |     <PackageVersion Include="Microsoft.AspNetCore.Identity.UI" Version="9.0.10" />
16 |     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
17 |     <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.11" />
18 |     <PackageVersion Include="AutoMapper" Version="15.0.1" />
19 |     <PackageVersion Include="Dapper" Version="2.1.66" />
20 |     <PackageVersion Include="NHibernate" Version="5.6.0" />
21 |     <PackageVersion Include="NHibernate.Mapping.Attributes" Version="5.1.0" />
22 |     <PackageVersion Include="NHibernate.Extensions.Npgsql" Version="9.0.9" />
23 |     <PackageVersion Include="NHibernate.Extensions.NetCore" Version="9.0.9" />
24 |     <PackageVersion Include="Npgsql" Version="9.0.4" />
25 |     <PackageVersion Include="NUnit" Version="4.4.0" />
26 |     <PackageVersion Include="NUnit3TestAdapter" Version="5.2.0" />
27 |   </ItemGroup>
28 | </Project>
29 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/NHibernate.AspNetCore.Identity.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net9.0</TargetFramework>
 4 |     <LangVersion>latest</LangVersion>
 5 |     <Nullable>enable</Nullable>
 6 |     <ImplicitUsings>enable</ImplicitUsings>
 7 |     <Title>NHibernate.AspNetCore.Identity</Title>
 8 |     <Authors>beginor</Authors>
 9 |     <Description>ASPNET Core Identity provider that uses NHibernate for storage. (Build in support for PostgreSQL, SqlServer, MySql, Sqlite)</Description>
10 |     <PackageId>NHibernate.AspNetCore.Identity</PackageId>
11 |     <PackageVersion>$(PACKAGE_VERSION)</PackageVersion>
12 |     <PackageReleaseNotes>$(PACKAGE_RELEASE_NOTES)</PackageReleaseNotes>
13 |     <PackageTags></PackageTags>
14 |     <PackageProjectUrl>https://github.com/nhibernate/NHibernate.AspNetCore.Identity</PackageProjectUrl>
15 |     <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
16 |     <PackageReadmeFile>README.md</PackageReadmeFile>
17 |   </PropertyGroup>
18 |   <ItemGroup>
19 |     <PackageReference Include="Microsoft.Extensions.Identity.Core" />
20 |     <PackageReference Include="Microsoft.Extensions.Identity.Stores" />
21 |     <PackageReference Include="NHibernate" />
22 |   </ItemGroup>
23 | 
24 |   <ItemGroup>
25 |     <None Include="../../README.md" Pack="true" PackagePath="\" />
26 |     <None Include="../../LICENSE.txt" Pack="true" PackagePath="\" />
27 |   </ItemGroup>
28 | </Project>
29 | 


--------------------------------------------------------------------------------
/test/UnitTest/BaseTest.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Cfg;
 2 | using NHibernate.Mapping.Attributes;
 3 | using NHibernate.Mapping.ByCode;
 4 | using WebTest.Entities;
 5 | 
 6 | namespace UnitTest;
 7 | 
 8 | public abstract class BaseTest {
 9 | 
10 |     protected Configuration ConfigNHibernate() {
11 |         var cfg = new Configuration();
12 |         var file = Path.Combine(
13 |             AppDomain.CurrentDomain.BaseDirectory,
14 |             "hibernate.config"
15 |         );
16 |         cfg.Configure(file);
17 |         return cfg;
18 |     }
19 | 
20 |     protected void AddByCodeMapping(Configuration cfg) {
21 |         var modelMapper = new ModelMapper();
22 |         modelMapper.AddMapping<AppRoleMapping>();
23 |         modelMapper.AddMapping<AppUserMapping>();
24 |         modelMapper.AddMapping<TodoItemMapping>();
25 |         var mappings = modelMapper.CompileMappingForAllExplicitlyAddedEntities();
26 |         cfg.AddMapping(mappings);
27 |     }
28 | 
29 |     protected void AddXmlMapping(Configuration cfg) {
30 |         cfg.AddAssembly(typeof(AppUser).Assembly);
31 |     }
32 | 
33 |     protected void AddAttributesMapping(Configuration cfg) {
34 |         HbmSerializer.Default.Validate = true;
35 |         var stream = HbmSerializer.Default.Serialize(
36 |             typeof(AppUser).Assembly
37 |         );
38 |         // cfg.AddInputStream(stream);
39 |         var streamReader = new System.IO.StreamReader(stream);
40 |         var xml = streamReader.ReadToEnd();
41 |         Console.WriteLine(xml);
42 |         cfg.AddXml(xml);
43 |     }
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/IdentityBuilderExtensions.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | using Microsoft.Extensions.DependencyInjection;
 3 | 
 4 | namespace NHibernate.AspNetCore.Identity;
 5 | 
 6 | public static class IdentityBuilderExtensions {
 7 | 
 8 |     public static IdentityBuilder AddHibernateStores(
 9 |         this IdentityBuilder builder
10 |     ) {
11 |         AddStores(builder.Services, builder.UserType, builder.RoleType!);
12 |         return builder;
13 |     }
14 | 
15 |     private static void AddStores(
16 |         IServiceCollection services,
17 |         System.Type userType,
18 |         System.Type? roleType
19 |     ) {
20 |         if (roleType != null) {
21 |             // register user store type
22 |             var userStoreServiceType = typeof(IUserStore<>).MakeGenericType(userType);
23 |             var userStoreImplType = typeof(UserStore<,>).MakeGenericType(userType, roleType);
24 |             services.AddScoped(userStoreServiceType, userStoreImplType);
25 |             // add role store type
26 |             var roleStoreSvcType = typeof(IRoleStore<>).MakeGenericType(roleType);
27 |             var roleStoreImplType = typeof(RoleStore<>).MakeGenericType(roleType);
28 |             services.AddScoped(roleStoreSvcType, roleStoreImplType);
29 |         }
30 |         else {
31 |             // register user only store type
32 |             var userStoreServiceType = typeof(IUserStore<>).MakeGenericType(userType);
33 |             var userStoreImplType = typeof(UserOnlyStore<>).MakeGenericType(userType);
34 |             services.AddScoped(userStoreServiceType, userStoreImplType);
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/TodoItemMapping.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate;
 2 | using NHibernate.Mapping.ByCode;
 3 | using NHibernate.Mapping.ByCode.Conformist;
 4 | 
 5 | namespace WebTest.Entities;
 6 | 
 7 | public class TodoItemMapping : ClassMapping<TodoItem> {
 8 | 
 9 |     public TodoItemMapping() {
10 |         Schema("public");
11 |         Table("todo_items");
12 |         Id(
13 |             e => e.Id,
14 |             mapping => {
15 |                 mapping.Column("id");
16 |                 mapping.Type(NHibernateUtil.Int64);
17 |                 mapping.Generator(Generators.TriggerIdentity);
18 |             }
19 |         );
20 |         Property(
21 |             e => e.Title,
22 |             mapping => {
23 |                 mapping.Column("title");
24 |                 mapping.Type(NHibernateUtil.String);
25 |                 mapping.Length(32);
26 |                 mapping.NotNullable(true);
27 |                 mapping.Unique(true);
28 |             }
29 |         );
30 |         Property(
31 |             e => e.Description,
32 |             mapping => {
33 |                 mapping.Column("description");
34 |                 mapping.Type(NHibernateUtil.String);
35 |                 mapping.Length(128);
36 |                 mapping.NotNullable(false);
37 |             }
38 |         );
39 |         Property(
40 |             e => e.Completed,
41 |             mapping => {
42 |                 mapping.Column("completed");
43 |                 mapping.Type(NHibernateUtil.Boolean);
44 |                 mapping.NotNullable(false);
45 |             }
46 |         );
47 |         ManyToOne(
48 |             e => e.User,
49 |             mapping => {
50 |                 mapping.Column("user_id");
51 |                 mapping.NotFound(NotFoundMode.Ignore);
52 |             }
53 |         );
54 |     }
55 | 
56 | }
57 | 


--------------------------------------------------------------------------------
/test/WebTest/Entities/AppUserMapping.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate;
 2 | using NHibernate.Mapping.ByCode;
 3 | using NHibernate.Mapping.ByCode.Conformist;
 4 | using NHIdentityUser = NHibernate.AspNetCore.Identity.IdentityUser;
 5 | 
 6 | namespace WebTest.Entities;
 7 | 
 8 | public class AppUserMapping : JoinedSubclassMapping<AppUser> {
 9 | 
10 |     public AppUserMapping() {
11 |         Extends(typeof(NHIdentityUser));
12 |         ExplicitDeclarationsHolder
13 |             .AddAsRootEntity(typeof(NHIdentityUser));
14 |         Schema("public");
15 |         Table("app_users");
16 |         Key(k => k.Column("id"));
17 |         Property(
18 |             e => e.CreateTime,
19 |             mapping => {
20 |                 mapping.Column("create_time");
21 |                 mapping.Type(NHibernateUtil.DateTime);
22 |                 mapping.NotNullable(true);
23 |                 mapping.Generated(PropertyGeneration.Insert);
24 |                 mapping.Update(false);
25 |                 mapping.Insert(false);
26 |             }
27 |         );
28 |         Property(
29 |             e => e.LastLogin,
30 |             mapping => {
31 |                 mapping.Column("last_login");
32 |                 mapping.Type(NHibernateUtil.DateTime);
33 |                 mapping.NotNullable(false);
34 |             }
35 |         );
36 |         Property(
37 |             e => e.LoginCount,
38 |             mapping => {
39 |                 mapping.Column("login_count");
40 |                 mapping.Type(NHibernateUtil.Int32);
41 |                 mapping.NotNullable(true);
42 |             }
43 |         );
44 |         ManyToOne(
45 |             e => e.City,
46 |             mapping => {
47 |                 mapping.Column("city_id");
48 |                 mapping.NotFound(NotFoundMode.Ignore);
49 |             }
50 |         );
51 |     }
52 | 
53 | }
54 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/ConfigurationExtensions.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Cfg;
 2 | using NHibernate.Mapping.ByCode;
 3 | 
 4 | namespace NHibernate.AspNetCore.Identity;
 5 | 
 6 | public static class ConfigurationExtensions {
 7 | 
 8 |     public static Configuration AddIdentityMappings(this Configuration cfg) {
 9 |         var dialect = cfg.GetProperty(NHibernate.Cfg.Environment.Dialect);
10 |         if (dialect.IndexOf("PostgreSQL", StringComparison.OrdinalIgnoreCase) > -1 || dialect.IndexOf("Npgsql", StringComparison.OrdinalIgnoreCase) > -1) {
11 |             cfg.AddIdentityMappingsForPostgres();
12 |         }
13 |         else if (dialect.IndexOf("MySQL", StringComparison.OrdinalIgnoreCase) > -1) {
14 |             cfg.AddIdentityMappingsForMySql();
15 |         }
16 |         else if (dialect.IndexOf("MsSql", StringComparison.OrdinalIgnoreCase) > -1) {
17 |             cfg.AddIdentityMappingsForMsSql();
18 |         }
19 |         else if (dialect.IndexOf("Sqlite", StringComparison.OrdinalIgnoreCase) > -1) {
20 |             cfg.AddIdentityMappingsForSqlite();
21 |         }
22 |         else {
23 |             throw new NotSupportedException(
24 |                 "Only support PostgreSQL, MsSql, MySQL, Sqlite, your dialect must contain one of these words!"
25 |             );
26 |         }
27 |         return cfg;
28 |     }
29 | 
30 |     public static Configuration AddIdentityMappingsForPostgres(
31 |         this Configuration cfg
32 |     ) {
33 |         var mapping = ConfigurationHelper.GetIdentityMappingForPostgreSql();
34 |         cfg.AddXml(mapping.AsString());
35 |         return cfg;
36 |     }
37 | 
38 |     public static Configuration AddIdentityMappingsForMsSql(
39 |         this Configuration cfg
40 |     ) {
41 |         var mapping = ConfigurationHelper.GetIdentityMappingForMsSql();
42 |         cfg.AddXml(mapping.AsString());
43 |         return cfg;
44 |     }
45 | 
46 |     public static Configuration AddIdentityMappingsForMySql(
47 |         this Configuration cfg
48 |     ) {
49 |         var mapping = ConfigurationHelper.GetIdentityMappingForMySql();
50 |         cfg.AddXml(mapping.AsString());
51 |         return cfg;
52 |     }
53 | 
54 |     public static Configuration AddIdentityMappingsForSqlite(
55 |         this Configuration cfg
56 |     ) {
57 |         var mapping = ConfigurationHelper.GetIdentityMappingForSqlite();
58 |         cfg.AddXml(mapping.AsString());
59 |         return cfg;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/database/sqlite/00_aspnet_core_identity.sql:
--------------------------------------------------------------------------------
 1 | drop table if exists aspnet_roles;
 2 | 
 3 | create table aspnet_roles (
 4 |   id varchar(32) not null constraint pk_aspnet_roles primary key,
 5 |   name varchar(64) not null,
 6 |   normalized_name   varchar(64) not null,
 7 |   concurrency_stamp varchar(36)
 8 | );
 9 | 
10 | drop table if exists aspnet_role_claims;
11 | 
12 | create table aspnet_role_claims (
13 |   id integer
14 |     constraint pk_aspnet_role_claims
15 |       primary key autoincrement,
16 |   claim_type varchar(1024) not null,
17 |   claim_value varchar(1024) not null,
18 |   role_id varchar(32) not null
19 |     constraint fk_aspnet_role_claims_role_id
20 |       references aspnet_roles(id)
21 |       on update cascade
22 |       on delete cascade
23 | );
24 | 
25 | drop table if exists aspnet_users;
26 | 
27 | create table aspnet_users (
28 |     id text not null,
29 |     user_name text not null unique,
30 |     normalized_user_name text not null unique,
31 |     email text not null,
32 |     normalized_email text not null,
33 |     email_confirmed bool not null,
34 |     password_hash text,
35 |     security_stamp text,
36 |     concurrency_stamp text,
37 |     phone_number text,
38 |     phone_number_confirmed bool not null,
39 |     two_factor_enabled bool not null,
40 |     lockout_end_unix_time_seconds bigint,
41 |     lockout_enabled bool not null,
42 |     access_failed_count int not null,
43 |     primary key (id)
44 | );
45 | 
46 | drop table if exists aspnet_user_claims;
47 | 
48 | create table aspnet_user_claims (
49 |     id  integer primary key autoincrement,
50 |     claim_type text not null,
51 |     claim_value text not null,
52 |     user_id text not null
53 | );
54 | 
55 | drop table if exists aspnet_user_logins;
56 | 
57 | create table aspnet_user_logins (
58 |     login_provider text not null,
59 |     provider_key text not null,
60 |     provider_display_name text not null,
61 |     user_id text not null,
62 |     primary key (login_provider, provider_key)
63 | );
64 | 
65 | drop table if exists aspnet_user_roles;
66 | 
67 | create table aspnet_user_roles (
68 |     user_id text not null,
69 |     role_id text not null,
70 |     primary key (user_id, role_id)
71 | );
72 | 
73 | drop table if exists aspnet_user_tokens;
74 | 
75 | create table aspnet_user_tokens (
76 |     user_id text not null,
77 |     login_provider text not null,
78 |     name text not null,
79 |     value text not null,
80 |     primary key (user_id, login_provider, name)
81 | );
82 | 


--------------------------------------------------------------------------------
/test/WebTest/Views/Shared/_Layout.cshtml:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="utf-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <title>@ViewData["Title"] - MvcApp</title>
 7 |     <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
 8 |     <link rel="stylesheet" href="~/css/site.css" asp-append-version="true" />
 9 |     <link rel="stylesheet" href="~/WebTest.styles.css" asp-append-version="true" />
10 | </head>
11 | <body>
12 |     <header>
13 |         <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
14 |             <div class="container-fluid">
15 |                 <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">MvcApp</a>
16 |                 <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
17 |                         aria-expanded="false" aria-label="Toggle navigation">
18 |                     <span class="navbar-toggler-icon"></span>
19 |                 </button>
20 |                 <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
21 |                     <ul class="navbar-nav flex-grow-1">
22 |                         <li class="nav-item">
23 |                             <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
24 |                         </li>
25 |                         <li class="nav-item">
26 |                             <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
27 |                         </li>
28 |                     </ul>
29 |                     <partial name="_LoginPartial" />
30 |                 </div>
31 |             </div>
32 |         </nav>
33 |     </header>
34 |     <div class="container">
35 |         <main role="main" class="pb-3">
36 |             @RenderBody()
37 |         </main>
38 |     </div>
39 | 
40 |     <footer class="border-top footer text-muted">
41 |         <div class="container">
42 |             &copy; 2022 - MvcApp - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
43 |         </div>
44 |     </footer>
45 |     <script src="~/lib/jquery/dist/jquery.min.js"></script>
46 |     <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
47 |     <script src="~/js/site.js" asp-append-version="true"></script>
48 |     @await RenderSectionAsync("Scripts", required: false)
49 | </body>
50 | </html>
51 | 


--------------------------------------------------------------------------------
/test/UnitTest/IdentityTest.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate;
 2 | using NHibernate.AspNetCore.Identity;
 3 | using WebTest.Entities;
 4 | 
 5 | namespace UnitTest;
 6 | 
 7 | [TestFixture]
 8 | public class IdentityTest : BaseTest {
 9 | 
10 |     [Test]
11 |     public void _01_CanExtendByCodeWithByCode() {
12 |         var cfg = ConfigNHibernate();
13 |         cfg.AddIdentityMappings();
14 |         AddByCodeMapping(cfg);
15 |         cfg.BuildMappings();
16 |         var sf = cfg.BuildSessionFactory();
17 |         That(sf, Is.Not.Null);
18 |         QueryUsers(sf);
19 |     }
20 | 
21 |     [Test]
22 |     public void _02_CanExtendByCodeWithXml() {
23 |         var cfg = ConfigNHibernate();
24 |         cfg.AddIdentityMappings();
25 |         AddXmlMapping(cfg);
26 |         cfg.BuildMappings();
27 |         var sf = cfg.BuildSessionFactory();
28 |         That(sf, Is.Not.Null);
29 |         QueryUsers(sf);
30 |     }
31 | 
32 |     [Test]
33 |     public void _03_CanExtendByByCodeWithAttributes() {
34 |         var cfg = ConfigNHibernate();
35 |         cfg.AddIdentityMappings();
36 |         AddAttributesMapping(cfg);
37 |         cfg.BuildMappings();
38 |         var sf = cfg.BuildSessionFactory();
39 |         That(sf, Is.Not.Null);
40 |         QueryUsers(sf);
41 |     }
42 | 
43 |     [Test]
44 |     public void _04_CanQueryCities() {
45 |         var cfg = ConfigNHibernate();
46 |         cfg.AddIdentityMappings();
47 |         AddAttributesMapping(cfg);
48 |         cfg.BuildMappings();
49 |         var sf = cfg.BuildSessionFactory();
50 |         That(sf, Is.Not.Null);
51 |         using var session = sf.OpenSession();
52 |         var cities = session.Query<City>().ToList();
53 |         That(sf, Is.Not.Empty);
54 |         foreach (var city in cities) {
55 |             That(city.Id, Is.GreaterThan(0));
56 |             That(city.Name, Is.Not.Null);
57 |         }
58 |     }
59 | 
60 |     [Test]
61 |     public void _05_CanInsertDeleteCities() {
62 |         var cfg = ConfigNHibernate();
63 |         cfg.AddIdentityMappings();
64 |         AddAttributesMapping(cfg);
65 |         cfg.BuildMappings();
66 |         var sf = cfg.BuildSessionFactory();
67 |         That(sf, Is.Not.Null);
68 |         using var session = sf.OpenSession();
69 |         var tx = session.BeginTransaction();
70 |         var city = new City {
71 |             Name = "Test City"
72 |         };
73 |         session.Save(city);
74 |         session.Flush();
75 |         That(city.Id, Is.GreaterThan(0));
76 |         tx.Rollback();
77 |     }
78 | 
79 |     private void QueryUsers(ISessionFactory sf) {
80 |         using var session = sf.OpenSession();
81 |         var users = session.Query<AppUser>()
82 |             .Where(u => u.LoginCount > 0)
83 |             .ToList();
84 |         That(users.Count, Is.GreaterThanOrEqualTo(0));
85 |     }
86 | 
87 | }
88 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/ConfigurationHelper.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.AspNetCore.Identity.Mappings;
 2 | using NHibernate.Cfg.MappingSchema;
 3 | using NHibernate.Mapping.ByCode;
 4 | 
 5 | namespace NHibernate.AspNetCore.Identity;
 6 | 
 7 | public static class ConfigurationHelper {
 8 | 
 9 |     public static HbmMapping GetIdentityMappingForPostgreSql() {
10 |         var mapper = new ModelMapper();
11 |         mapper.AddMapping<IdentityRoleMappingPostgreSql>();
12 |         mapper.AddMapping<IdentityRoleClaimMappingPostgreSql>();
13 |         mapper.AddMapping<IdentityUserMappingPostgreSql>();
14 |         mapper.AddMapping<IdentityUserClaimMappingPostgreSql>();
15 |         mapper.AddMapping<IdentityUserLoginMappingPostgreSql>();
16 |         mapper.AddMapping<IdentityUserRoleMappingPostgreSql>();
17 |         mapper.AddMapping<IdentityUserTokenMappingPostgreSql>();
18 |         return mapper.CompileMappingForAllExplicitlyAddedEntities();
19 |     }
20 | 
21 |     public static HbmMapping GetIdentityMappingForMsSql() {
22 |         var mapper = new ModelMapper();
23 |         mapper.AddMapping<IdentityRoleMappingMsSql>();
24 |         mapper.AddMapping<IdentityRoleClaimMappingMsSql>();
25 |         mapper.AddMapping<IdentityUserMappingMsSql>();
26 |         mapper.AddMapping<IdentityUserClaimMappingMsSql>();
27 |         mapper.AddMapping<IdentityUserLoginMappingMsSql>();
28 |         mapper.AddMapping<IdentityUserRoleMappingMsSql>();
29 |         mapper.AddMapping<IdentityUserTokenMappingMsSql>();
30 |         return mapper.CompileMappingForAllExplicitlyAddedEntities();
31 |     }
32 | 
33 |     public static HbmMapping GetIdentityMappingForMySql() {
34 |         var mapper = new ModelMapper();
35 |         mapper.AddMapping<IdentityRoleMappingMySql>();
36 |         mapper.AddMapping<IdentityRoleClaimMappingMySql>();
37 |         mapper.AddMapping<IdentityUserMappingMySql>();
38 |         mapper.AddMapping<IdentityUserClaimMappingMySql>();
39 |         mapper.AddMapping<IdentityUserLoginMappingMySql>();
40 |         mapper.AddMapping<IdentityUserRoleMappingMySql>();
41 |         mapper.AddMapping<IdentityUserTokenMappingMySql>();
42 |         return mapper.CompileMappingForAllExplicitlyAddedEntities();
43 |     }
44 | 
45 |     public static HbmMapping GetIdentityMappingForSqlite() {
46 |         var mapper = new ModelMapper();
47 |         mapper.AddMapping<IdentityRoleMappingSqlite>();
48 |         mapper.AddMapping<IdentityRoleClaimMappingSqlite>();
49 |         mapper.AddMapping<IdentityUserMappingSqlite>();
50 |         mapper.AddMapping<IdentityUserClaimMappingSqlite>();
51 |         mapper.AddMapping<IdentityUserLoginMappingSqlite>();
52 |         mapper.AddMapping<IdentityUserRoleMappingSqlite>();
53 |         mapper.AddMapping<IdentityUserTokenMappingSqlite>();
54 |         return mapper.CompileMappingForAllExplicitlyAddedEntities();
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityUserRole.cs:
--------------------------------------------------------------------------------
 1 | using NHibernate.Mapping.ByCode.Conformist;
 2 | 
 3 | namespace NHibernate.AspNetCore.Identity.Mappings;
 4 | 
 5 | public class IdentityUserRoleMappingPostgreSql : ClassMapping<IdentityUserRole> {
 6 | 
 7 |     public IdentityUserRoleMappingPostgreSql() {
 8 |         Schema("public");
 9 |         Table("aspnet_user_roles");
10 |         ComposedId(id => {
11 |             id.Property(e => e.UserId, prop => {
12 |                 prop.Column("user_id");
13 |                 prop.Type(NHibernateUtil.String);
14 |                 prop.Length(32);
15 |             });
16 |             id.Property(e => e.RoleId, prop => {
17 |                 prop.Column("role_id");
18 |                 prop.Type(NHibernateUtil.String);
19 |                 prop.Length(32);
20 |             });
21 |         });
22 |     }
23 | 
24 | }
25 | 
26 | public class IdentityUserRoleMappingMsSql : ClassMapping<IdentityUserRole> {
27 | 
28 |     public IdentityUserRoleMappingMsSql() {
29 |         Schema("dbo");
30 |         Table("AspNetUserRoles");
31 |         ComposedId(id => {
32 |             id.Property(e => e.UserId, prop => {
33 |                 prop.Column("UserId");
34 |                 prop.Type(NHibernateUtil.String);
35 |                 prop.Length(32);
36 |             });
37 |             id.Property(e => e.RoleId, prop => {
38 |                 prop.Column("RoleId");
39 |                 prop.Type(NHibernateUtil.String);
40 |                 prop.Length(32);
41 |             });
42 |         });
43 |     }
44 | 
45 | }
46 | 
47 | public class IdentityUserRoleMappingMySql : ClassMapping<IdentityUserRole> {
48 | 
49 |     public IdentityUserRoleMappingMySql() {
50 |         Table("aspnet_user_roles");
51 |         ComposedId(id => {
52 |             id.Property(e => e.UserId, prop => {
53 |                 prop.Column("user_id");
54 |                 prop.Type(NHibernateUtil.String);
55 |                 prop.Length(32);
56 |             });
57 |             id.Property(e => e.RoleId, prop => {
58 |                 prop.Column("role_id");
59 |                 prop.Type(NHibernateUtil.String);
60 |                 prop.Length(32);
61 |             });
62 |         });
63 |     }
64 | 
65 | }
66 | 
67 | public class IdentityUserRoleMappingSqlite : ClassMapping<IdentityUserRole> {
68 | 
69 |     public IdentityUserRoleMappingSqlite() {
70 |         Table("aspnet_user_roles");
71 |         ComposedId(id => {
72 |             id.Property(e => e.UserId, prop => {
73 |                 prop.Column("user_id");
74 |                 prop.Type(NHibernateUtil.String);
75 |                 prop.Length(32);
76 |             });
77 |             id.Property(e => e.RoleId, prop => {
78 |                 prop.Column("role_id");
79 |                 prop.Type(NHibernateUtil.String);
80 |                 prop.Length(32);
81 |             });
82 |         });
83 |     }
84 | 
85 | }
86 | 


--------------------------------------------------------------------------------
/test/WebTest/Controllers/UsersController.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Identity;
 2 | using Microsoft.AspNetCore.Mvc;
 3 | using WebTest.Entities;
 4 | 
 5 | namespace WebTest.Controllers;
 6 | 
 7 | [Route("api/[controller]")]
 8 | public class UsersController : Controller {
 9 | 
10 |     private readonly UserManager<AppUser> userMgr;
11 | 
12 |     public UsersController(
13 |         UserManager<AppUser> userMgr
14 |     ) {
15 |         this.userMgr = userMgr ?? throw new ArgumentNullException(nameof(userMgr));
16 |     }
17 | 
18 |     protected override void Dispose(bool disposing) {
19 |         if (disposing) {
20 |             // dispose managed resource here.
21 |         }
22 |     }
23 | 
24 |     [HttpGet("")]
25 |     public ActionResult<IList<AppUser>> GetAll() {
26 |         var users = userMgr.Users.ToList();
27 |         return users;
28 |     }
29 | 
30 |     [HttpPost]
31 |     public ActionResult Create() {
32 |         var provider = HttpContext.RequestServices;
33 |         var session = provider.GetService<NHibernate.ISession>();
34 |         if (session == null) {
35 |             return StatusCode(StatusCodes.Status500InternalServerError, "Can not get sql session");
36 |         }
37 |         var newYork = session.Query<City>()
38 |             .First(c => c.Name == "new york");
39 |         var user = new AppUser() {
40 |             UserName = "newyork_user",
41 |             Email = "newyork_user@newyork.city",
42 |             City = newYork
43 |         };
44 |         var task = userMgr.CreateAsync(user);
45 |         task.Wait();
46 |         var result = task.Result;
47 |         return Ok(result);
48 |     }
49 | 
50 |     [HttpGet("batch-create")]
51 |     public async Task<ActionResult> BatchCreate() {
52 |         var provider = HttpContext.RequestServices;
53 |         using var scope = provider.CreateScope();
54 |         var session = provider.GetService<NHibernate.ISession>();
55 |         if (session == null) {
56 |             return StatusCode(StatusCodes.Status500InternalServerError, "Can not get sql connection");
57 |         }
58 |         var manager = provider.GetService<UserManager<AppUser>>();
59 |         if (manager == null) {
60 |             return StatusCode(StatusCodes.Status500InternalServerError, "Can not get user manager");
61 |         }
62 |         using var tx = session.BeginTransaction();
63 |         try {
64 |             var user1 = new AppUser {
65 |                 UserName = "user1",
66 |                 Email = "user1@nonexit.com"
67 |             };
68 |             await manager.CreateAsync(user1);
69 |             var user2 = new AppUser {
70 |                 UserName = "user2",
71 |                 Email = "user2@nonexit.com"
72 |             };
73 |             await manager.CreateAsync(user2);
74 |             await tx.CommitAsync();
75 |             return Ok();
76 |         }
77 |         catch (Exception ex) {
78 |             await tx.RollbackAsync();
79 |             Console.WriteLine(ex);
80 |             return StatusCode(500);
81 |         }
82 |     }
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelogs for NHibernate.AspNetCore.Identity
  2 | 
  3 | # 9.0.7
  4 | 
  5 | - Update to .NET 9.0.10;
  6 | - Update NHibernate to 5.6.0;
  7 | - Update other nuget packages;
  8 | 
  9 | # 9.0.6
 10 | 
 11 | - Update NHibernate to 5.5.3;
 12 | 
 13 | ## 9.0.5
 14 | 
 15 | - Update to .NET 9.0.8;
 16 | - Update Identity.Core to 9.0.8;
 17 | 
 18 | ## 9.0.4
 19 | 
 20 | - Update to .NET 9.0.7;
 21 | - Update Identity.Core to 9.0.7;
 22 | - Manage package versions centrally;
 23 | 
 24 | ## 9.0.3
 25 | 
 26 | - Update to .NET 9.0.5;
 27 | - Update Identity.Core to 9.0.5;
 28 | 
 29 | ## 9.0.2
 30 | 
 31 | - Update to .NET 9.0.3;
 32 | - Update Identity.Core to 9.0.3;
 33 | - Migrate to new slnx solution format;
 34 | 
 35 | ## 9.0.1
 36 | 
 37 | - Update to .NET 9.0.2;
 38 | - Update Identity.Core to 9.0.2;
 39 | 
 40 | ## 9.0.0
 41 | 
 42 | - Update to .NET 9.0.0;
 43 | - Update Identity.Core to 9.0.0;
 44 | 
 45 | ## 8.0.11
 46 | 
 47 | - Update to .NET 8.0.10;
 48 | - Update Identity.Core to 8.0.10;
 49 | 
 50 | ## 8.0.10
 51 | 
 52 | - Update to .NET 8.0.8;
 53 | - Update Identity.Core to 8.0.8;
 54 | 
 55 | ## 8.0.9
 56 | 
 57 | - Update to .NET 8.0.7;
 58 | - Update Identity.Core to 8.0.7;
 59 | 
 60 | ## 8.0.8
 61 | 
 62 | - Update NHibernate to 5.5.2;
 63 | 
 64 | ## 8.0.7
 65 | 
 66 | - Update to .NET 8.0.6;
 67 | - Update Identity.Core to 8.0.6;
 68 | 
 69 | ## 8.0.6
 70 | 
 71 | - Update to .NET 8.0.4;
 72 | - Update Identity.Core to 8.0.4;
 73 | 
 74 | ## 8.0.5
 75 | 
 76 | - Update NHibernate to 5.5.1;
 77 | 
 78 | ## 8.0.4
 79 | 
 80 | - Update to .NET 8.0.3;
 81 | - Update Identity.Core to 8.0.3;
 82 | 
 83 | ## 8.0.3
 84 | 
 85 | - Update to .NET 8.0.2;
 86 | - Update Identity.Core to 8.0.2;
 87 | 
 88 | ## 8.0.2
 89 | - Update to .NET 8.0.1;
 90 | - Update Identity.Core to 8.0.1;
 91 | 
 92 | ## 8.0.1
 93 | 
 94 | - Update NHibernate to 5.5.0;
 95 | - Update Npgsql to 8.0.1;
 96 | - Other nuget package updates.
 97 | 
 98 | ## 8.0.0
 99 | 
100 | - Update to .NET 8.0.0;
101 | - Update Identity.Core to 8.0.0;
102 | 
103 | ## 7.0.12
104 | 
105 | - Update to .NET 7.0.11;
106 | - Update Identity.Core to 7.0.11;
107 | - Update other packages;
108 | 
109 | ## 7.0.11
110 | 
111 | - Update NHibernate to 5.4.6;
112 | 
113 | ## 7.0.10
114 | 
115 | - Update to .NET 7.0.10;
116 | - Update Identity.Core to 7.0.10;
117 | - Update NHibernate to 5.4.5;
118 | 
119 | ## 7.0.9
120 | 
121 | - Update to .NET 7.0.9;
122 | - Update Identity.Core to 7.0.9;
123 | - Update NHibernate to 5.4.4;
124 | 
125 | ## 7.0.8
126 | 
127 | - Update to .NET 7.0.8;
128 | - Update Identity.Core to 7.0.8;
129 | - Update NHibernate to 5.4.3;
130 | - Include README.md and License to package;
131 | 
132 | ## 7.0.6
133 | 
134 | - Update to .NET 7.0.7;
135 | - Update other packages;
136 | 
137 | ## 7.0.5
138 | 
139 | - Update to .NET 7.0.5;
140 | 
141 | ## 7.0.4
142 | 
143 | - Update NHibernate to 5.4.2;
144 | 
145 | ## 7.0.3
146 | 
147 | - Update to .NET 7.0.4;
148 | 
149 | ## 7.0.2
150 | 
151 | - Update to .NET 7.0.2;
152 | - Update NHibernate to 5.4.1;
153 | - Update other packages;
154 | 
155 | ## 7.0.1
156 | 
157 | - Update to .net 7.0.1 ;
158 | 
159 | ## 7.0.0
160 | 
161 | - Update to .net 7.0.0 ;
162 | - Update to NHibernate 5.4.0 ;
163 | - Update to Npgsql 7.0.0 ;
164 | 


--------------------------------------------------------------------------------
/test/UnitTest/Identity/RoleStoreTest.cs:
--------------------------------------------------------------------------------
 1 | using System.Security.Claims;
 2 | using NHibernate.AspNetCore.Identity;
 3 | using NHibernate.Extensions.NetCore;
 4 | using NHibernate.Linq;
 5 | using Microsoft.AspNetCore.Identity;
 6 | using NHIdentityRole = NHibernate.AspNetCore.Identity.IdentityRole;
 7 | 
 8 | namespace UnitTest.Identity;
 9 | 
10 | [TestFixture]
11 | public class RoleStoreTest : BaseTest, IDisposable {
12 | 
13 |     private RoleStore<NHIdentityRole> store;
14 | 
15 |     public RoleStoreTest() {
16 |         var builder = new LoggingBuilder();
17 |         var loggerFactory = builder.BuildLoggerFactory();
18 |         loggerFactory.UseAsHibernateLoggerFactory();
19 |         var cfg = ConfigNHibernate();
20 |         cfg.AddIdentityMappings();
21 |         AddXmlMapping(cfg);
22 |         var sessionFactory = cfg.BuildSessionFactory();
23 |         store = new RoleStore<NHIdentityRole>(
24 |             sessionFactory.OpenSession(),
25 |             new IdentityErrorDescriber()
26 |         );
27 |     }
28 | 
29 |     public void Dispose() {
30 |         store.Dispose();
31 |     }
32 | 
33 |     [Test]
34 |     public async Task _01_CanQueryAllRoles() {
35 |         var roleList = await store.Roles.ToListAsync();
36 |         That(roleList, Is.Not.Null);
37 |         That(roleList.Count, Is.GreaterThanOrEqualTo(0));
38 |         foreach (var role in roleList) {
39 |             Console.WriteLine($"role:: id: {role.Id}, name: {role.Name}, normalized name: {role.NormalizedName}, concurrency stamp: {role.ConcurrencyStamp}");
40 |         }
41 |     }
42 | 
43 |     [Test]
44 |     public async Task _02_CanDoCURD() {
45 |         var role = new NHIdentityRole();
46 |         role.Name = "Role 1";
47 |         role.NormalizedName = role.Name.ToUpperInvariant();
48 |         var result = await store.CreateAsync(role, CancellationToken.None);
49 |         That(result.Succeeded);
50 |         That(role.Id, Is.Not.Empty);
51 |         That(role.ConcurrencyStamp, Is.Not.Empty);
52 | 
53 |         role.Name = "role 1 updated";
54 |         role.NormalizedName = role.Name.ToUpperInvariant();
55 |         result = await store.UpdateAsync(role, CancellationToken.None);
56 |         That(result.Succeeded);
57 | 
58 |         role = await store.FindByIdAsync(role.Id, CancellationToken.None);
59 |         That(role, Is.Not.Null);
60 |         That(role!.Id, Is.EqualTo(role.Id));
61 |         That(role.Name, Is.EqualTo(role.Name));
62 | 
63 |         var normalizedName = role.NormalizedName!;
64 |         role = await store.FindByNameAsync(normalizedName, CancellationToken.None);
65 |         That(normalizedName, Is.EqualTo(role!.NormalizedName));
66 | 
67 |         var claim = new Claim("test", "test");
68 | 
69 |         await store.AddClaimAsync(role, claim, CancellationToken.None);
70 | 
71 |         var roleClaims = await store.GetClaimsAsync(role, CancellationToken.None);
72 |         That(roleClaims, Is.Not.Null);
73 |         That(roleClaims.Count, Is.GreaterThan(0));
74 | 
75 |         await store.RemoveClaimAsync(role, claim, CancellationToken.None);
76 | 
77 |         roleClaims = await store.GetClaimsAsync(role, CancellationToken.None);
78 |         That(roleClaims, Is.Not.Null);
79 |         That(roleClaims.Count, Is.EqualTo(0));
80 | 
81 |         result = await store.DeleteAsync(role, CancellationToken.None);
82 |         That(result.Succeeded);
83 |     }
84 | 
85 | }
86 | 


--------------------------------------------------------------------------------
/database/mssql/00_aspnet_core_identity.sql:
--------------------------------------------------------------------------------
  1 | -- auto-generated definition
  2 | create table AspNetRoles (
  3 |   Id nvarchar(32) not null,
  4 |   Name nvarchar(256),
  5 |   NormalizedName nvarchar(256),
  6 |   ConcurrencyStamp nvarchar(1024),
  7 |   constraint pk_AspNetRoles primary key (id)
  8 | )
  9 | go
 10 | 
 11 | -- auto-generated definition
 12 | create table AspNetRoleClaims (
 13 |   Id int identity,
 14 |   RoleId nvarchar(32) not null,
 15 |   ClaimType nvarchar(1024),
 16 |   ClaimValue nvarchar(1024),
 17 |   constraint pk_AspNetRoleClaims primary key (Id),
 18 |   constraint fk_AspNetRoleClaims_AspNetRoles
 19 |     foreign key (RoleId) references AspNetRoles (Id)
 20 |     on delete cascade
 21 |     on update cascade
 22 | )
 23 | go
 24 | 
 25 | -- auto-generated definition
 26 | create table AspNetUsers (
 27 |   Id nvarchar(32) not null,
 28 |   UserName nvarchar(256),
 29 |   NormalizedUserName nvarchar(256),
 30 |   Email nvarchar(256),
 31 |   NormalizedEmail nvarchar(256),
 32 |   EmailConfirmed bit not null,
 33 |   PasswordHash nvarchar(1024),
 34 |   SecurityStamp nvarchar(1024),
 35 |   ConcurrencyStamp nvarchar(1024),
 36 |   PhoneNumber nvarchar(1024),
 37 |   PhoneNumberConfirmed bit not null,
 38 |   TwoFactorEnabled bit not null,
 39 |   LockoutEnd datetimeoffset,
 40 |   LockoutEnabled bit not null,
 41 |   AccessFailedCount int not null,
 42 |   constraint pk_AspNetUsers primary key (Id)
 43 | )
 44 | go
 45 | 
 46 | -- auto-generated definition
 47 | create table AspNetUserClaims (
 48 |   Id int identity,
 49 |   UserId nvarchar(32) not null,
 50 |   ClaimType nvarchar(1024),
 51 |   ClaimValue nvarchar(1024),
 52 |   constraint pk_AspNetUserClaims primary key (Id),
 53 |   constraint fk_AspNetUserClaims_AspNetUsers
 54 |     foreign key (UserId) references AspNetUsers (Id)
 55 |     on delete cascade
 56 |     on update cascade
 57 | )
 58 | go
 59 | 
 60 | -- auto-generated definition
 61 | create table AspNetUserLogins (
 62 |   LoginProvider nvarchar(128) not null,
 63 |   ProviderKey nvarchar(128) not null,
 64 |   ProviderDisplayName nvarchar(1024),
 65 |   UserId nvarchar(32) not null,
 66 |   constraint pk_AspNetUserLogins primary key (LoginProvider, ProviderKey),
 67 |   constraint fk_AspNetUserLogins_AspNetUsers
 68 |     foreign key (UserId) references AspNetUsers (Id)
 69 |     on delete cascade
 70 |     on update cascade
 71 | )
 72 | go
 73 | 
 74 | -- auto-generated definition
 75 | create table AspNetUserRoles (
 76 |   UserId nvarchar(32) not null,
 77 |   RoleId nvarchar(32) not null,
 78 |   constraint pk_AspNetUserRoles primary key (UserId, RoleId),
 79 |   constraint fk_AspNetUserRoles_AspNetUsers
 80 |     foreign key (UserId) references AspNetUsers (Id)
 81 |     on delete cascade
 82 |     on update cascade,
 83 |   constraint fk_AspNetUserRoles_AspNetRoles
 84 |     foreign key (RoleId) references AspNetRoles (Id)
 85 |     on delete cascade
 86 |     on update cascade
 87 | )
 88 | go
 89 | 
 90 | -- auto-generated definition
 91 | create table AspNetUserTokens (
 92 |   UserId nvarchar(32) not null,
 93 |   LoginProvider nvarchar(128) not null,
 94 |   Name nvarchar(128) not null,
 95 |   Value nvarchar(1024),
 96 |   constraint pk_AspNetUserTokens primary key (UserId, LoginProvider, Name),
 97 |   constraint fk_AspNetUserTokens_AspNetUsers
 98 |     foreign key (UserId) references AspNetUsers
 99 |     on delete cascade
100 |     on update cascade
101 | )
102 | go
103 | 
104 | 


--------------------------------------------------------------------------------
/test/WebTest/Repositories/TodoItemRepository.cs:
--------------------------------------------------------------------------------
  1 | using AutoMapper;
  2 | using AutoMapper.QueryableExtensions;
  3 | using NHibernate;
  4 | using NHibernate.Linq;
  5 | using WebTest.Entities;
  6 | using WebTest.Models;
  7 | 
  8 | namespace WebTest.Repositories;
  9 | 
 10 | public class TodoItemRepository : ITodoItemRepository, IDisposable {
 11 | 
 12 |     private readonly ISessionFactory factory;
 13 |     private readonly IMapper mapper;
 14 |     private bool disposed;
 15 | 
 16 |     public TodoItemRepository(
 17 |         ISessionFactory factory,
 18 |         IMapper mapper
 19 |     ) {
 20 |         this.factory = factory ?? throw new ArgumentNullException(nameof(factory));
 21 |         this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
 22 |     }
 23 | 
 24 |     ~TodoItemRepository() {
 25 |         Dispose(false);
 26 |     }
 27 | 
 28 |     public void Dispose() {
 29 |         Dispose(true);
 30 |     }
 31 | 
 32 |     public void Dispose(bool disposing) {
 33 |         if (disposed) {
 34 |             return;
 35 |         }
 36 |         if (disposing) {
 37 |             // dispose managed resource here;
 38 |         }
 39 |         //
 40 |         disposed = true;
 41 |     }
 42 | 
 43 |     public async Task CreateAsync(TodoItemModel model) {
 44 |         var entity = mapper.Map<TodoItem>(model);
 45 |         using var session = factory.OpenSession();
 46 |         var user = await session.LoadAsync<AppUser>(model.UserId);
 47 |         if (user == null) {
 48 |             throw new InvalidOperationException("user is null!");
 49 |         }
 50 |         entity.User = user;
 51 |         await session.SaveAsync(entity);
 52 |         await session.FlushAsync();
 53 |         mapper.Map(entity, model);
 54 |     }
 55 | 
 56 |     public async Task DeleteAsync(long id) {
 57 |         using var session = factory.OpenSession();
 58 |         var entity = await session.LoadAsync<TodoItem>(id);
 59 |         if (entity != null) {
 60 |             await session.DeleteAsync(entity);
 61 |         }
 62 |     }
 63 | 
 64 |     public async Task<TodoItemModel?> GetByIdAsync(long id) {
 65 |         using var session = factory.OpenSession();
 66 |         var entity = await session.LoadAsync<TodoItem>(id);
 67 |         if (entity == null) {
 68 |             return null;
 69 |         }
 70 |         var model = mapper.Map<TodoItemModel>(entity);
 71 |         return model;
 72 |     }
 73 | 
 74 |     public async Task<PagedResultModel<TodoItemModel>> SearchAsync(TodoItemSearchModel model) {
 75 |         using var session = factory.OpenSession();
 76 |         var result = new PagedResultModel<TodoItemModel>();
 77 |         var query = session.Query<TodoItem>();
 78 |         // add custom query here;
 79 |         if (model.Completed.HasValue) {
 80 |             var val = model.Completed.Value;
 81 |             query = query.Where(x => x.Completed == val);
 82 |         }
 83 |         if (!string.IsNullOrEmpty(model.UserId)) {
 84 |             query = query.Where(x => x.User!.Id == model.UserId);
 85 |         }
 86 |         //
 87 |         result.Total = await query.LongCountAsync();
 88 |         result.Data = await query.ProjectTo<TodoItemModel>(mapper.ConfigurationProvider)
 89 |             .Skip(model.Skip)
 90 |             .Take(model.Take)
 91 |             .ToListAsync();
 92 |         result.Skip = model.Skip;
 93 |         result.Take = model.Take;
 94 |         return result;
 95 |     }
 96 | 
 97 |     public async Task UpdateAsync(long id, TodoItemModel model) {
 98 |         using var session = factory.OpenSession();
 99 |         var entity = await session.LoadAsync<TodoItem>(id);
100 |         if (entity == null) {
101 |             throw new InvalidOperationException(
102 |                 $"TodoItem {id} does not exists!"
103 |             );
104 |         }
105 |         mapper.Map(model, entity);
106 |         await session.UpdateAsync(entity);
107 |         await session.FlushAsync();
108 |     }
109 | 
110 | }
111 | 


--------------------------------------------------------------------------------
/test/UnitTest/Identity/ConfigTest.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate;
  2 | using NHibernate.Cfg;
  3 | using NHibernate.AspNetCore.Identity;
  4 | using NHibernate.Extensions.NetCore;
  5 | using NHibernate.Tool.hbm2ddl;
  6 | using WebTest.Entities;
  7 | 
  8 | namespace UnitTest.Identity;
  9 | 
 10 | [TestFixture]
 11 | public class ConfigTest : BaseTest, IDisposable {
 12 | 
 13 |     private ISessionFactory? sessionFactory;
 14 |     private Configuration? cfg;
 15 | 
 16 |     [OneTimeSetUp]
 17 |     public void OneTimeSetUp() {
 18 |         var builder = new LoggingBuilder();
 19 |         var loggerFactory = builder.BuildLoggerFactory();
 20 |         loggerFactory.UseAsHibernateLoggerFactory();
 21 |         cfg = ConfigNHibernate();
 22 |         cfg.AddIdentityMappings();
 23 |         AddAttributesMapping(cfg);
 24 |         sessionFactory = cfg.BuildSessionFactory();
 25 |     }
 26 | 
 27 |     public void Dispose() {
 28 |         sessionFactory?.Dispose();
 29 |     }
 30 | 
 31 |     private ISessionFactory GetSessionFactory() {
 32 |         if (sessionFactory == null) {
 33 |             throw new Exception("sessionFactory is null!");
 34 |         }
 35 |         return sessionFactory;
 36 |     }
 37 | 
 38 |     [Test]
 39 |     public void _00_CanDoExport() {
 40 |         var export = new SchemaExport(cfg);
 41 |         export.Execute(true, false, false);
 42 |     }
 43 | 
 44 |     [Test]
 45 |     public void _01_CanQueryUsers() {
 46 |         using var session = GetSessionFactory().OpenSession();
 47 |         var query = session.Query<IdentityUser>();
 48 |         var count = query.ToList().Count;
 49 |         That(count, Is.GreaterThanOrEqualTo(0));
 50 |     }
 51 | 
 52 |     [Test]
 53 |     public void _02_CanQueryRoles() {
 54 |         using var session = GetSessionFactory().OpenSession();
 55 |         var query = session.Query<IdentityRole>();
 56 |         var count = query.ToList().Count;
 57 |         That(count, Is.GreaterThanOrEqualTo(0));
 58 |     }
 59 | 
 60 |     [Test]
 61 |     public void _03_CanQueryRoleClaims() {
 62 |         using var session = GetSessionFactory().OpenSession();
 63 |         var query = session.Query<IdentityRoleClaim>();
 64 |         var count = query.ToList().Count;
 65 |         That(count, Is.GreaterThanOrEqualTo(0));
 66 |     }
 67 | 
 68 |     [Test]
 69 |     public void _04_CanQueryUserClaims() {
 70 |         using var session = GetSessionFactory().OpenSession();
 71 |         var query = session.Query<IdentityUserClaim>();
 72 |         var count = query.ToList().Count;
 73 |         That(count, Is.GreaterThanOrEqualTo(0));
 74 |     }
 75 | 
 76 |     [Test]
 77 |     public void _05_CanQueryUserLogins() {
 78 |         using var session = GetSessionFactory().OpenSession();
 79 |         var query = session.Query<IdentityUserLogin>();
 80 |         var count = query.ToList().Count;
 81 |         That(count, Is.GreaterThanOrEqualTo(0));
 82 |     }
 83 | 
 84 |     [Test]
 85 |     public void _06_CanQueryUserTokens() {
 86 |         using var session = GetSessionFactory().OpenSession();
 87 |         var query = session.Query<IdentityUserToken>();
 88 |         var count = query.ToList().Count;
 89 |         That(count, Is.GreaterThanOrEqualTo(0));
 90 |     }
 91 | 
 92 |     [Test]
 93 |     public void _07_CanQueryUserRoles() {
 94 |         using var session = GetSessionFactory().OpenSession();
 95 |         var query = session.Query<IdentityUserRole>();
 96 |         var count = query.ToList().Count;
 97 |         That(count, Is.GreaterThanOrEqualTo(0));
 98 |     }
 99 | 
100 |     [Test]
101 |     public void _08_CanGetFullName() {
102 |         var type = typeof(IdentityRole);
103 |         That(type, Is.Not.Null);
104 |     }
105 | 
106 |     [Test]
107 |     public void _09_CanQueryUserWithCity() {
108 |         using var session = GetSessionFactory().OpenSession();
109 |         var user = session.Query<AppUser>()
110 |             .First();
111 |         That(user, Is.Not.Null);
112 |         That(user?.City?.Name, Is.Not.Null);
113 |     }
114 | 
115 | }
116 | 


--------------------------------------------------------------------------------
/test/WebTest/Controllers/TodoController.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.AspNetCore.Identity;
  2 | using Microsoft.AspNetCore.Mvc;
  3 | using WebTest.Entities;
  4 | using WebTest.Models;
  5 | using WebTest.Repositories;
  6 | 
  7 | namespace WebTest.Controllers;
  8 | 
  9 | [Route("api/[controller]")]
 10 | public class TodoController : Controller {
 11 | 
 12 |     private ITodoItemRepository repo;
 13 |     private UserManager<AppUser> userMgr;
 14 |     private ILogger<TodoController> logger;
 15 | 
 16 |     public TodoController(
 17 |         ITodoItemRepository repo,
 18 |         UserManager<AppUser> userMgr,
 19 |         ILogger<TodoController> logger
 20 |     ) {
 21 |         this.repo = repo ?? throw new ArgumentNullException(nameof(repo));
 22 |         this.userMgr = userMgr ?? throw new ArgumentNullException(nameof(userMgr));
 23 |         this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 24 |     }
 25 | 
 26 |     protected override void Dispose(
 27 |         bool disposing
 28 |     ) {
 29 |         if (disposing) {
 30 |             // dispose managed resource here.
 31 |         }
 32 |         base.Dispose(disposing);
 33 |     }
 34 | 
 35 |     [HttpGet("")]
 36 |     [ProducesResponseType(200)]
 37 |     public async Task<ActionResult<PagedResultModel<TodoItemModel>>> Search(
 38 |         TodoItemSearchModel model
 39 |     ) {
 40 |         try {
 41 |             var result = await repo.SearchAsync(model);
 42 |             return result;
 43 |         }
 44 |         catch (Exception ex) {
 45 |             logger!.LogError(ex, "Can not search todo items.");
 46 |             return StatusCode(500);
 47 |         }
 48 |     }
 49 | 
 50 |     [HttpGet("{id:long}")]
 51 |     [ProducesResponseType(200)]
 52 |     [ProducesResponseType(404)]
 53 |     public async Task<ActionResult<TodoItemModel>> GetById(long id) {
 54 |         try {
 55 |             var model = await repo.GetByIdAsync(id);
 56 |             if (model == null) {
 57 |                 return NotFound();
 58 |             }
 59 |             return model;
 60 |         }
 61 |         catch (Exception ex) {
 62 |             logger?.LogError(ex, "Can not read todo items.");
 63 |             return StatusCode(500);
 64 |         }
 65 |     }
 66 | 
 67 |     [HttpPost("")]
 68 |     public async Task<ActionResult<TodoItemModel>> Save(
 69 |         [FromBody]TodoItemModel model
 70 |     ) {
 71 |         try {
 72 |             var identity = User.Identity;
 73 |             if (identity == null) {
 74 |                 return Unauthorized();
 75 |             }
 76 |             var username = identity.Name;
 77 |             if (string.IsNullOrEmpty(username)) {
 78 |                 return Unauthorized();
 79 |             }
 80 |             var user = await userMgr.FindByNameAsync(username);
 81 |             model.UserId = user?.Id ?? string.Empty;
 82 |             model.UserName = user?.UserName ?? string.Empty;
 83 |             await repo.CreateAsync(model);
 84 |             return model;
 85 |         }
 86 |         catch (Exception ex) {
 87 |             logger.LogError(ex, "Can not save todo items.");
 88 |             return StatusCode(500);
 89 |         }
 90 |     }
 91 | 
 92 |     [HttpPut("{id:long}")]
 93 |     [ProducesResponseType(200)]
 94 |     public async Task<ActionResult<TodoItemModel>> Update(
 95 |         [FromRoute]long id,
 96 |         [FromBody]TodoItemModel model
 97 |     ) {
 98 |         try {
 99 |             await repo.UpdateAsync(id, model);
100 |             return model;
101 |         }
102 |         catch (Exception ex) {
103 |             logger.LogError(ex, "Can not update todo items.");
104 |             return StatusCode(500);
105 |         }
106 |     }
107 | 
108 |     [HttpDelete("{id:long}")]
109 |     [ProducesResponseType(204)]
110 |     public async Task<IActionResult> Delete(long id) {
111 |         try {
112 |             await repo.DeleteAsync(id);
113 |             return NoContent();
114 |         }
115 |         catch (Exception ex) {
116 |             logger.LogError(ex, "Can not delete todo items.");
117 |             return StatusCode(500);
118 |         }
119 |     }
120 | 
121 | }
122 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # NHibernate.AspNetCore.Identity
  2 | 
  3 | ASP.NET Core Identity Provider implemented with NHibernate
  4 | 
  5 | ![ASP.NET Core Identity with nhibernate](https://raw.github.com/nhibernate/NHibernate.AspNetCore.Identity/master/database/identity-nh.svg)
  6 | 
  7 | ![Database diagram](https://raw.github.com/nhibernate/NHibernate.AspNetCore.Identity/master/database/db_schema.png)
  8 | 
  9 | Nuget package:
 10 | 
 11 | - [NHibernate.AspNetCore.Identity](https://www.nuget.org/packages/NHibernate.AspNetCore.Identity/)
 12 | 
 13 | ## About Version
 14 | 
 15 | - 9.0.x is compatible with .Net 9.0.x;
 16 | - 8.0.x is compatible with .Net 8.0.x;
 17 | - 7.0.x is compatible with .Net 7.0.x;
 18 | - 6.0.x is compatible with .Net 6.0.x;
 19 | - 5.0.x is compatible with .Net 5.0.x;
 20 | - 3.1.x is compatible with .Net Core 3.1.x;
 21 | - 3.0.x is compatible with .Net Core 3.0.x;
 22 | 
 23 | ## Usage
 24 | 
 25 | ### 1. Create a Asp.Net Core Mvc Project with identity support
 26 | 
 27 | ```sh
 28 | dotnet new mvc --auth Individual
 29 | ```
 30 | 
 31 | ### 2. Add reference to `NHibernate.AspNetCore.Identity` and `NHibernate.NetCore`
 32 | 
 33 | ```sh
 34 | dotnet add package NHibernate.AspNetCore.Identity
 35 | dotnet add package NHibernate.NetCore
 36 | ```
 37 | 
 38 | > `NHibernate` will be installed automatically.
 39 | 
 40 | ### 3. Setup database
 41 | 
 42 | - Use the sql scripts in `database` folder to create aspnet identity related tables, only support postgresql, mssql and mysql now;
 43 | 
 44 |   > If you want other database support, please let me know, any issue, pull request is welcome!
 45 | 
 46 | - Config NHibernate to use your database;
 47 | 
 48 | ### 4. Change `Startup.cs` to use database and nhibernate
 49 | 
 50 | ```cs
 51 | public class Startup {
 52 | 
 53 |     public void ConfigureServices(
 54 |         IServiceCollection services
 55 |     ) {
 56 |         // Remove EFCore stores.
 57 |         // services.AddDbContext<ApplicationDbContext>(
 58 |         // options =>
 59 |         //     options.UseSqlite(Configuration.GetConnectionString("DefaultConnection")));
 60 |         // services.AddDefaultIdentity<IdentityUser>()
 61 |         //     .AddEntityFrameworkStores<ApplicationDbContext>();
 62 | 
 63 |         // Add Hibernate stores
 64 |         var cfg = new Configuration();
 65 |         var file = Path.Combine(
 66 |             AppDomain.CurrentDomain.BaseDirectory,
 67 |             "hibernate.config"
 68 |         );
 69 |         cfg.Configure(file);
 70 |         // Add identity mapping based on dialect config (dialet must contains
 71 |         // PostgreSQL, MySQL, MsSql or Sqlite)
 72 |         cfg.AddIdentityMappings();
 73 |         // using default xml mapping.
 74 |         cfg.AddAssembly(typeof(Startup).Assembly);
 75 |         // using `NHibernate.Mapping.ByCode`, please comment the line above,
 76 |         // and uncomment line flowing lines;
 77 |         // var modelMapper = new NHibernate.Mapping.ByCode.ModelMapper();
 78 |         // modelMapper.AddMapping<WebTest.Entities.AppRoleMapping>();
 79 |         // modelMapper.AddMapping<WebTest.Entities.AppUserMapping>();
 80 |         // modelMapper.AddMapping<WebTest.Entities.TodoItemMapping>();
 81 |         // var mappings = modelMapper.CompileMappingForAllExplicitlyAddedEntities();
 82 |         // cfg.AddMapping(mappings);
 83 | 
 84 |         services.AddHibernate(cfg);
 85 |         services.AddDefaultIdentity<WebTest.Entities.ApplicationUser>()
 86 |             .AddRoles<WebTest.Entities.ApplicationRole>()
 87 |             .AddHibernateStores();
 88 | 
 89 |     }
 90 | }
 91 | ```
 92 | 
 93 | > Note: When using with SqlServer, you need add `System.Data.SqlClient` package to your project.
 94 | 
 95 | For more detailed samples, please look at the [WebTest](https://github.com/nhibernate/NHibernate.AspNetCore.Identity/tree/master/test/WebTest) project.
 96 | 
 97 | ## Credits
 98 | 
 99 | Special thanks to the following individuals, organisations and projects whose work is so important to the success of NHibernate (in no particular order):
100 | 
101 | - [NUnit](https://nunit.org/) - unit testing;
102 | - [JetBrains](https://www.jetbrains.com/?from=NHibernate.AspNetCore.Identity) - open source license;
103 | 


--------------------------------------------------------------------------------
/test/WebTest/Startup.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.AspNetCore.Mvc;
  2 | using NHibernate.Extensions.NetCore;
  3 | using NHibernate.AspNetCore.Identity;
  4 | using NHibernate.Cfg;
  5 | using WebTest.Repositories;
  6 | 
  7 | namespace WebTest;
  8 | 
  9 | public class Startup {
 10 | 
 11 |     public Startup(IConfiguration configuration) {
 12 |         Configuration = configuration;
 13 |     }
 14 | 
 15 |     public IConfiguration Configuration { get; }
 16 | 
 17 |     // This method gets called by the runtime. Use this method to add services to the container.
 18 |     public void ConfigureServices(
 19 |         IServiceCollection services
 20 |     ) {
 21 |         var cfg = new Configuration();
 22 |         var file = Path.Combine(
 23 |             AppDomain.CurrentDomain.BaseDirectory,
 24 |             "hibernate.config"
 25 |         );
 26 |         cfg.Configure(file);
 27 |         // Add identity mapping based on dialect config (dialet must contains
 28 |         // PostgreSQL, MySQL or MsSql)
 29 |         cfg.AddIdentityMappings();
 30 |         // using default xml mapping.
 31 |         cfg.AddAssembly(typeof(Startup).Assembly);
 32 |         // using `NHibernate.Mapping.ByCode`, please comment the line above,
 33 |         // and uncomment line flowing lines;
 34 |         // var modelMapper = new NHibernate.Mapping.ByCode.ModelMapper();
 35 |         // modelMapper.AddMapping<WebTest.Entities.AppRoleMapping>();
 36 |         // modelMapper.AddMapping<WebTest.Entities.AppUserMapping>();
 37 |         // modelMapper.AddMapping<WebTest.Entities.TodoItemMapping>();
 38 |         // var mappings = modelMapper.CompileMappingForAllExplicitlyAddedEntities();
 39 |         // cfg.AddMapping(mappings);
 40 |         // using `NHibernate.Mapping.Attributes`
 41 |         // NHibernate.Mapping.Attributes.HbmSerializer.Default.Validate = true;
 42 |         // var stream = NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(
 43 |         //     typeof(Startup).Assembly
 44 |         // );
 45 |         // cfg.AddInputStream(stream);
 46 | 
 47 |         services.AddHibernate(cfg);
 48 |         services.AddDefaultIdentity<WebTest.Entities.AppUser>()
 49 |             .AddRoles<WebTest.Entities.AppRole>()
 50 |             .AddHibernateStores();
 51 | 
 52 |         // services.AddRouting(opts => {
 53 |         //     opts.LowercaseUrls = true;
 54 |         // });
 55 | 
 56 |         services.AddControllersWithViews();
 57 | 
 58 |         services.Configure<ApiBehaviorOptions>(options => {
 59 |             options.SuppressConsumesConstraintForFormFileParameters = true;
 60 |             options.SuppressInferBindingSourcesForParameters = true;
 61 |             options.SuppressModelStateInvalidFilter = true;
 62 |         });
 63 | 
 64 |         services.AddSingleton<AutoMapper.IMapper>(serviceProvider => {
 65 |             var mapperConfig = new AutoMapper.MapperConfiguration(
 66 |                 configure => {
 67 |                     configure.AddMaps(typeof(WebTest.MappingProfile).Assembly);
 68 |                 },
 69 |                 serviceProvider.GetService<ILoggerFactory>()
 70 |             );
 71 |             var mapper = mapperConfig.CreateMapper();
 72 |             return mapper;
 73 |         });
 74 | 
 75 |         services.AddScoped<ITodoItemRepository, TodoItemRepository>();
 76 |     }
 77 | 
 78 |     // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
 79 |     public void Configure(
 80 |         WebApplication app,
 81 |         IWebHostEnvironment env,
 82 |         Microsoft.Extensions.Logging.ILoggerFactory loggerFactory
 83 |     ) {
 84 |         loggerFactory.UseAsHibernateLoggerFactory();
 85 |         if (env.IsDevelopment()) {
 86 |             app.UseDeveloperExceptionPage();
 87 |         }
 88 |         else {
 89 |             app.UseExceptionHandler("/Home/Error");
 90 |         }
 91 | 
 92 |         app.MapStaticAssets();
 93 | 
 94 |         app.UseRouting();
 95 | 
 96 |         app.UseAuthentication();
 97 |         app.UseAuthorization();
 98 | 
 99 |         app.MapControllerRoute(
100 |             name: "default",
101 |             pattern: "{controller=Home}/{action=Index}/{id?}"
102 |         ).WithStaticAssets();
103 |         app.MapRazorPages()
104 |             .WithStaticAssets();
105 |     }
106 | 
107 | }
108 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.min.css:
--------------------------------------------------------------------------------
1 | /*!
2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
3 |  * Copyright 2011-2021 The Bootstrap Authors
4 |  * Copyright 2011-2021 Twitter, Inc.
5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
7 |  */*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-body-font-family);font-size:var(--bs-body-font-size);font-weight:var(--bs-body-font-weight);line-height:var(--bs-body-line-height);color:var(--bs-body-color);text-align:var(--bs-body-text-align);background-color:var(--bs-body-bg);-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){h1{font-size:2.5rem}}h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){h2{font-size:2rem}}h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){h3{font-size:1.75rem}}h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){h4{font-size:1.5rem}}h5{font-size:1.25rem}h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-left:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:.875em}mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:left;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}
8 | /*# sourceMappingURL=bootstrap-reboot.min.css.map */


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.rtl.min.css:
--------------------------------------------------------------------------------
1 | /*!
2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
3 |  * Copyright 2011-2021 The Bootstrap Authors
4 |  * Copyright 2011-2021 Twitter, Inc.
5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
7 |  */*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-body-font-family);font-size:var(--bs-body-font-size);font-weight:var(--bs-body-font-weight);line-height:var(--bs-body-line-height);color:var(--bs-body-color);text-align:var(--bs-body-text-align);background-color:var(--bs-body-bg);-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){h1{font-size:2.5rem}}h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){h2{font-size:2rem}}h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){h3{font-size:1.75rem}}h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){h4{font-size:1.5rem}}h5{font-size:1.25rem}h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-right:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-right:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:.875em}mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:right}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:right;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:right}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}[type=email],[type=number],[type=tel],[type=url]{direction:ltr}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}
8 | /*# sourceMappingURL=bootstrap-reboot.rtl.min.css.map */


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityUserToken.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate.Mapping.ByCode.Conformist;
  2 | 
  3 | namespace NHibernate.AspNetCore.Identity.Mappings;
  4 | 
  5 | public class IdentityUserTokenMappingPostgreSql : ClassMapping<IdentityUserToken> {
  6 | 
  7 |     public IdentityUserTokenMappingPostgreSql() {
  8 |         Schema("public");
  9 |         Table("aspnet_user_tokens");
 10 |         ComposedId(id => {
 11 |             id.Property(e => e.UserId, prop => {
 12 |                 prop.Column("user_id");
 13 |                 prop.Type(NHibernateUtil.String);
 14 |                 prop.Length(32);
 15 |             });
 16 |             id.Property(e => e.LoginProvider, prop => {
 17 |                 prop.Column("login_provider");
 18 |                 prop.Type(NHibernateUtil.String);
 19 |                 prop.Length(32);
 20 |             });
 21 |             id.Property(e => e.Name, prop => {
 22 |                 prop.Column("name");
 23 |                 prop.Type(NHibernateUtil.String);
 24 |                 prop.Length(32);
 25 |             });
 26 |         });
 27 |         Property(e => e.Value, prop => {
 28 |             prop.Column("value");
 29 |             prop.Type(NHibernateUtil.String);
 30 |             prop.Length(256);
 31 |             prop.NotNullable(true);
 32 |         });
 33 |     }
 34 | 
 35 | }
 36 | 
 37 | public class IdentityUserTokenMappingMsSql : ClassMapping<IdentityUserToken> {
 38 | 
 39 |     public IdentityUserTokenMappingMsSql() {
 40 |         Schema("dbo");
 41 |         Table("AspNetUserTokens");
 42 |         ComposedId(id => {
 43 |             id.Property(e => e.UserId, prop => {
 44 |                 prop.Column("UserId");
 45 |                 prop.Type(NHibernateUtil.String);
 46 |                 prop.Length(32);
 47 |             });
 48 |             id.Property(e => e.LoginProvider, prop => {
 49 |                 prop.Column("LoginProvider");
 50 |                 prop.Type(NHibernateUtil.String);
 51 |                 prop.Length(32);
 52 |             });
 53 |             id.Property(e => e.Name, prop => {
 54 |                 prop.Column("Name");
 55 |                 prop.Type(NHibernateUtil.String);
 56 |                 prop.Length(32);
 57 |             });
 58 |         });
 59 |         Property(e => e.Value, prop => {
 60 |             prop.Column("Value");
 61 |             prop.Type(NHibernateUtil.String);
 62 |             prop.Length(256);
 63 |             prop.NotNullable(true);
 64 |         });
 65 |     }
 66 | 
 67 | }
 68 | 
 69 | public class IdentityUserTokenMappingMySql : ClassMapping<IdentityUserToken> {
 70 | 
 71 |     public IdentityUserTokenMappingMySql() {
 72 |         Table("aspnet_user_tokens");
 73 |         ComposedId(id => {
 74 |             id.Property(e => e.UserId, prop => {
 75 |                 prop.Column("user_id");
 76 |                 prop.Type(NHibernateUtil.String);
 77 |                 prop.Length(32);
 78 |             });
 79 |             id.Property(e => e.LoginProvider, prop => {
 80 |                 prop.Column("login_provider");
 81 |                 prop.Type(NHibernateUtil.String);
 82 |                 prop.Length(32);
 83 |             });
 84 |             id.Property(e => e.Name, prop => {
 85 |                 prop.Column("name");
 86 |                 prop.Type(NHibernateUtil.String);
 87 |                 prop.Length(32);
 88 |             });
 89 |         });
 90 |         Property(e => e.Value, prop => {
 91 |             prop.Column("value");
 92 |             prop.Type(NHibernateUtil.String);
 93 |             prop.Length(256);
 94 |             prop.NotNullable(true);
 95 |         });
 96 |     }
 97 | 
 98 | }
 99 | 
100 | public class IdentityUserTokenMappingSqlite : ClassMapping<IdentityUserToken> {
101 | 
102 |     public IdentityUserTokenMappingSqlite() {
103 |         Table("aspnet_user_tokens");
104 |         ComposedId(id => {
105 |             id.Property(e => e.UserId, prop => {
106 |                 prop.Column("user_id");
107 |                 prop.Type(NHibernateUtil.String);
108 |                 prop.Length(32);
109 |             });
110 |             id.Property(e => e.LoginProvider, prop => {
111 |                 prop.Column("login_provider");
112 |                 prop.Type(NHibernateUtil.String);
113 |                 prop.Length(32);
114 |             });
115 |             id.Property(e => e.Name, prop => {
116 |                 prop.Column("name");
117 |                 prop.Type(NHibernateUtil.String);
118 |                 prop.Length(32);
119 |             });
120 |         });
121 |         Property(e => e.Value, prop => {
122 |             prop.Column("value");
123 |             prop.Type(NHibernateUtil.String);
124 |             prop.Length(256);
125 |             prop.NotNullable(true);
126 |         });
127 |     }
128 | 
129 | }
130 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityUserClaim.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate.Mapping.ByCode;
  2 | using NHibernate.Mapping.ByCode.Conformist;
  3 | 
  4 | namespace NHibernate.AspNetCore.Identity.Mappings;
  5 | 
  6 | public class IdentityUserClaimMappingPostgreSql : ClassMapping<IdentityUserClaim> {
  7 | 
  8 |     public IdentityUserClaimMappingPostgreSql() {
  9 |         Schema("public");
 10 |         Table("aspnet_user_claims");
 11 |         Id(e => e.Id, id => {
 12 |             id.Column("id");
 13 |             id.Type(NHibernateUtil.Int32);
 14 |             id.Generator(Generators.Sequence, g => {
 15 |                 g.Params(new { sequence = "snow_flake_id_seq" });
 16 |             });
 17 |         });
 18 |         Property(e => e.ClaimType, prop => {
 19 |             prop.Column("claim_type");
 20 |             prop.Type(NHibernateUtil.String);
 21 |             prop.Length(1024);
 22 |             prop.NotNullable(true);
 23 |         });
 24 |         Property(e => e.ClaimValue, prop => {
 25 |             prop.Column("claim_value");
 26 |             prop.Type(NHibernateUtil.String);
 27 |             prop.Length(1024);
 28 |             prop.NotNullable(true);
 29 |         });
 30 |         Property(e => e.UserId, prop => {
 31 |             prop.Column("user_id");
 32 |             prop.Type(NHibernateUtil.String);
 33 |             prop.Length(32);
 34 |             prop.NotNullable(true);
 35 |         });
 36 |     }
 37 | 
 38 | }
 39 | 
 40 | public class IdentityUserClaimMappingMsSql : ClassMapping<IdentityUserClaim> {
 41 | 
 42 |     public IdentityUserClaimMappingMsSql() {
 43 |         Schema("dbo");
 44 |         Table("AspNetUserClaims");
 45 |         Id(e => e.Id, id => {
 46 |             id.Column("id");
 47 |             id.Type(NHibernateUtil.Int32);
 48 |             id.Generator(Generators.Identity);
 49 |         });
 50 |         Property(e => e.ClaimType, prop => {
 51 |             prop.Column("ClaimType");
 52 |             prop.Type(NHibernateUtil.String);
 53 |             prop.Length(1024);
 54 |             prop.NotNullable(true);
 55 |         });
 56 |         Property(e => e.ClaimValue, prop => {
 57 |             prop.Column("ClaimValue");
 58 |             prop.Type(NHibernateUtil.String);
 59 |             prop.Length(1024);
 60 |             prop.NotNullable(true);
 61 |         });
 62 |         Property(e => e.UserId, prop => {
 63 |             prop.Column("UserId");
 64 |             prop.Type(NHibernateUtil.String);
 65 |             prop.Length(32);
 66 |             prop.NotNullable(true);
 67 |         });
 68 |     }
 69 | 
 70 | }
 71 | 
 72 | public class IdentityUserClaimMappingMySql : ClassMapping<IdentityUserClaim> {
 73 | 
 74 |     public IdentityUserClaimMappingMySql() {
 75 |         Table("aspnet_user_claims");
 76 |         Id(e => e.Id, id => {
 77 |             id.Column("id");
 78 |             id.Type(NHibernateUtil.Int32);
 79 |             id.Generator(Generators.Identity);
 80 |         });
 81 |         Property(e => e.ClaimType, prop => {
 82 |             prop.Column("claim_type");
 83 |             prop.Type(NHibernateUtil.String);
 84 |             prop.Length(1024);
 85 |             prop.NotNullable(true);
 86 |         });
 87 |         Property(e => e.ClaimValue, prop => {
 88 |             prop.Column("claim_value");
 89 |             prop.Type(NHibernateUtil.String);
 90 |             prop.Length(1024);
 91 |             prop.NotNullable(true);
 92 |         });
 93 |         Property(e => e.UserId, prop => {
 94 |             prop.Column("user_id");
 95 |             prop.Type(NHibernateUtil.String);
 96 |             prop.Length(32);
 97 |             prop.NotNullable(true);
 98 |         });
 99 |     }
100 | 
101 | }
102 | 
103 | public class IdentityUserClaimMappingSqlite : ClassMapping<IdentityUserClaim> {
104 | 
105 |     public IdentityUserClaimMappingSqlite() {
106 |         Table("aspnet_user_claims");
107 |         Id(e => e.Id, id => {
108 |             id.Column("id");
109 |             id.Type(NHibernateUtil.Int32);
110 |             id.Generator(Generators.Identity);
111 |         });
112 |         Property(e => e.ClaimType, prop => {
113 |             prop.Column("claim_type");
114 |             prop.Type(NHibernateUtil.String);
115 |             prop.Length(1024);
116 |             prop.NotNullable(true);
117 |         });
118 |         Property(e => e.ClaimValue, prop => {
119 |             prop.Column("claim_value");
120 |             prop.Type(NHibernateUtil.String);
121 |             prop.Length(1024);
122 |             prop.NotNullable(true);
123 |         });
124 |         Property(e => e.UserId, prop => {
125 |             prop.Column("user_id");
126 |             prop.Type(NHibernateUtil.String);
127 |             prop.Length(32);
128 |             prop.NotNullable(true);
129 |         });
130 |     }
131 | 
132 | }
133 | 


--------------------------------------------------------------------------------
/database/mysql/00_aspnet_core_identity.sql:
--------------------------------------------------------------------------------
  1 | create database net_core_app character set utf8 collate utf8_general_ci;
  2 | 
  3 | use nhibernate;
  4 | 
  5 | create table aspnet_roles (
  6 |   id varchar(32) not null comment 'id of user',
  7 |   name varchar(64) null comment 'name of user',
  8 |   normalized_name varchar(64) null comment 'normalized name of user',
  9 |   concurrency_stamp varchar(36) null comment 'concurrency stamp',
 10 |   constraint pk_aspnet_roles primary key (id)
 11 | )
 12 | comment 'aspnet core ideitity roles';
 13 | 
 14 | create table aspnet_role_claims (
 15 |   id int auto_increment comment 'role claim id',
 16 |   claim_type varchar(1024) not null comment 'claim type',
 17 |   claim_value varchar(1024) not null comment 'claim value',
 18 |   role_id varchar(32) not null comment 'role id',
 19 |   constraint pk_aspnet_role_claims primary key (id),
 20 |   constraint fk_aspnet_role_claims_roles
 21 |     foreign key (role_id) references aspnet_roles (id)
 22 |     on update cascade
 23 |     on delete cascade
 24 | )
 25 | comment 'aspnet core identity role claims';
 26 | 
 27 | create table aspnet_users (
 28 |   id varchar(32) not null comment 'user id',
 29 |   user_name varchar(64) not null comment 'user name',
 30 |   normalized_user_name varchar(64) not null comment 'normalized user name',
 31 |   email varchar(256) not null comment 'email',
 32 |   normalized_email varchar(256) null comment 'normalized email',
 33 |   email_confirmed tinyint(1) default 0 not null comment 'email confirmed',
 34 |   password_hash varchar(256) null comment 'password hash',
 35 |   security_stamp varchar(64) null comment 'security stamp',
 36 |   concurrency_stamp varchar(36) null comment 'concurrency stamp',
 37 |   phone_number varchar(128) null comment 'phone number',
 38 |   phone_number_confirmed tinyint(1) default 0 not null comment 'phone number confirmed',
 39 |   two_factor_enabled tinyint(1) default 0 not null comment 'two factor enabled',
 40 |   lockout_end_unix_time_seconds bigint null comment 'lockout end unix time in seconds',
 41 |   lockout_enabled tinyint(1) default 0 not null comment 'lockout enabled',
 42 |   access_failed_count int null comment 'access failed count',
 43 |   constraint pk_aspnet_users primary key (id),
 44 |   constraint ui_aspnet_users_email unique (email),
 45 |   constraint ui_aspnet_users_normalized_user_name unique (normalized_user_name),
 46 |   constraint ui_aspnet_users_user_name unique (user_name)
 47 | )
 48 | comment 'aspnet identity users';
 49 | 
 50 | create table aspnet_user_claims (
 51 |   id int auto_increment comment 'user claim id',
 52 |   claim_type varchar(1024) not null comment 'claim type',
 53 |   claim_value varchar(1024) not null comment 'claim value',
 54 |   user_id varchar(32) not null comment 'user id',
 55 |   constraint pk_aspnet_user_claims primary key(id),
 56 |   constraint fk_aspnet_user_claims_users
 57 |     foreign key (user_id) references aspnet_users (id)
 58 |     on update cascade
 59 |     on delete cascade
 60 | )
 61 | comment 'aspnet core identity user claims';
 62 | 
 63 | create table aspnet_user_logins (
 64 |   login_provider varchar(32) not null comment 'login provider',
 65 |   provider_key varchar(256) not null comment 'login provider key',
 66 |   provider_display_name varchar(256) not null comment 'login provider display name',
 67 |   user_id varchar(32) not null comment 'user id',
 68 |   constraint pk_aspnet_user_logins primary key (login_provider, provider_key),
 69 |   constraint fk_aspnet_user_logins_user
 70 |     foreign key (user_id) references aspnet_users (id)
 71 |     on update cascade
 72 |     on delete cascade
 73 | )
 74 | comment 'aspnet user logins';
 75 | 
 76 | create table aspnet_user_roles (
 77 |   user_id varchar(32) not null comment 'user id',
 78 |   role_id varchar(32) not null comment 'role id',
 79 |   constraint pk_aspnet_user_roles primary key (user_id, role_id),
 80 |   constraint fk_aspnet_user_roles_roles
 81 |     foreign key (role_id) references aspnet_roles (id)
 82 |     on update cascade
 83 |     on delete cascade,
 84 |   constraint fk_aspnet_user_roles_users
 85 |     foreign key (user_id) references aspnet_users (id)
 86 |     on update cascade
 87 |     on delete cascade
 88 | )
 89 | comment 'aspnet user roles relation table.';
 90 | 
 91 | create table aspnet_user_tokens(
 92 |   user_id varchar(32) not null comment 'user id',
 93 |   login_provider varchar(32) not null comment 'login provider for this token',
 94 |   name varchar(32) not null comment 'token name',
 95 |   value varchar(256) not null comment 'token value',
 96 |   constraint pk_aspnet_user_tokens primary key (user_id, login_provider, name),
 97 |   constraint fk_aspnet_user_tokens_users
 98 |     foreign key (user_id) references aspnet_users (id)
 99 |     on update cascade
100 |     on delete cascade
101 | )
102 | comment 'aspnet user tokens';
103 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityRoleClaim.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate.Mapping.ByCode;
  2 | using NHibernate.Mapping.ByCode.Conformist;
  3 | 
  4 | namespace NHibernate.AspNetCore.Identity.Mappings;
  5 | 
  6 | public class IdentityRoleClaimMappingPostgreSql : ClassMapping<IdentityRoleClaim> {
  7 | 
  8 |     public IdentityRoleClaimMappingPostgreSql() {
  9 |         Schema("public");
 10 |         Table("aspnet_role_claims");
 11 |         Id(e => e.Id, id => {
 12 |             id.Column("id");
 13 |             id.Type(NHibernateUtil.Int32);
 14 |             id.Length(32);
 15 |             id.Generator(Generators.Sequence, g => {
 16 |                 g.Params(new { sequence = "snow_flake_id_seq" });
 17 |             });
 18 |         });
 19 |         Property(e => e.ClaimType, prop => {
 20 |             prop.Column("claim_type");
 21 |             prop.Type(NHibernateUtil.String);
 22 |             prop.Length(1024);
 23 |             prop.NotNullable(true);
 24 |         });
 25 |         Property(e => e.ClaimValue, prop => {
 26 |             prop.Column("claim_value");
 27 |             prop.Type(NHibernateUtil.String);
 28 |             prop.Length(1024);
 29 |             prop.NotNullable(true);
 30 |         });
 31 |         Property(e => e.RoleId, prop => {
 32 |             prop.Column("role_id");
 33 |             prop.Type(NHibernateUtil.String);
 34 |             prop.Length(32);
 35 |             prop.NotNullable(true);
 36 |         });
 37 |     }
 38 | 
 39 | }
 40 | 
 41 | public class IdentityRoleClaimMappingMsSql : ClassMapping<IdentityRoleClaim> {
 42 | 
 43 |     public IdentityRoleClaimMappingMsSql() {
 44 |         Schema("dbo");
 45 |         Table("AspNetRoleClaims");
 46 |         Id(e => e.Id, id => {
 47 |             id.Column("Id");
 48 |             id.Type(NHibernateUtil.Int32);
 49 |             id.Generator(Generators.Identity);
 50 |         });
 51 |         Property(e => e.ClaimType, prop => {
 52 |             prop.Column("ClaimType");
 53 |             prop.Type(NHibernateUtil.String);
 54 |             prop.Length(1024);
 55 |             prop.NotNullable(true);
 56 |         });
 57 |         Property(e => e.ClaimValue, prop => {
 58 |             prop.Column("ClaimValue");
 59 |             prop.Type(NHibernateUtil.String);
 60 |             prop.Length(1024);
 61 |             prop.NotNullable(true);
 62 |         });
 63 |         Property(e => e.RoleId, prop => {
 64 |             prop.Column("RoleId");
 65 |             prop.Type(NHibernateUtil.String);
 66 |             prop.Length(32);
 67 |             prop.NotNullable(true);
 68 |         });
 69 |     }
 70 | 
 71 | }
 72 | 
 73 | public class IdentityRoleClaimMappingMySql : ClassMapping<IdentityRoleClaim> {
 74 | 
 75 |     public IdentityRoleClaimMappingMySql() {
 76 |         Table("aspnet_role_claims");
 77 |         Id(e => e.Id, id => {
 78 |             id.Column("id");
 79 |             id.Type(NHibernateUtil.Int32);
 80 |             id.Generator(Generators.Identity);
 81 |         });
 82 |         Property(e => e.ClaimType, prop => {
 83 |             prop.Column("claim_type");
 84 |             prop.Type(NHibernateUtil.String);
 85 |             prop.Length(1024);
 86 |             prop.NotNullable(true);
 87 |         });
 88 |         Property(e => e.ClaimValue, prop => {
 89 |             prop.Column("claim_value");
 90 |             prop.Type(NHibernateUtil.String);
 91 |             prop.Length(1024);
 92 |             prop.NotNullable(true);
 93 |         });
 94 |         Property(e => e.RoleId, prop => {
 95 |             prop.Column("role_id");
 96 |             prop.Type(NHibernateUtil.String);
 97 |             prop.Length(32);
 98 |             prop.NotNullable(true);
 99 |         });
100 |     }
101 | 
102 | }
103 | 
104 | public class IdentityRoleClaimMappingSqlite : ClassMapping<IdentityRoleClaim> {
105 | 
106 |     public IdentityRoleClaimMappingSqlite() {
107 |         Table("aspnet_role_claims");
108 |         Id(e => e.Id, id => {
109 |             id.Column("id");
110 |             id.Type(NHibernateUtil.Int32);
111 |             id.Generator(Generators.Identity);
112 |         });
113 |         Property(e => e.ClaimType, prop => {
114 |             prop.Column("claim_type");
115 |             prop.Type(NHibernateUtil.String);
116 |             prop.Length(1024);
117 |             prop.NotNullable(true);
118 |         });
119 |         Property(e => e.ClaimValue, prop => {
120 |             prop.Column("claim_value");
121 |             prop.Type(NHibernateUtil.String);
122 |             prop.Length(1024);
123 |             prop.NotNullable(true);
124 |         });
125 |         Property(e => e.RoleId, prop => {
126 |             prop.Column("role_id");
127 |             prop.Type(NHibernateUtil.String);
128 |             prop.Length(32);
129 |             prop.NotNullable(true);
130 |         });
131 |     }
132 | 
133 | }
134 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityUserLogin.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate.Mapping.ByCode.Conformist;
  2 | 
  3 | namespace NHibernate.AspNetCore.Identity.Mappings;
  4 | 
  5 | public class IdentityUserLoginMappingPostgreSql : ClassMapping<IdentityUserLogin> {
  6 | 
  7 |     public IdentityUserLoginMappingPostgreSql() {
  8 |         Schema("public");
  9 |         Table("aspnet_user_logins");
 10 |         ComposedId(id => {
 11 |             id.Property(e => e.LoginProvider, prop => {
 12 |                 prop.Column("login_provider");
 13 |                 prop.Type(NHibernateUtil.String);
 14 |                 prop.Length(32);
 15 |             });
 16 |             id.Property(e => e.ProviderKey, prop => {
 17 |                 prop.Column("provider_key");
 18 |                 prop.Type(NHibernateUtil.String);
 19 |                 prop.Length(32);
 20 |             });
 21 |         });
 22 |         Property(e => e.ProviderDisplayName, prop => {
 23 |             prop.Column("provider_display_name");
 24 |             prop.Type(NHibernateUtil.String);
 25 |             prop.Length(32);
 26 |             prop.NotNullable(true);
 27 |         });
 28 |         Property(e => e.UserId, prop => {
 29 |             prop.Column("user_id");
 30 |             prop.Type(NHibernateUtil.String);
 31 |             prop.Length(32);
 32 |             prop.NotNullable(true);
 33 |         });
 34 |     }
 35 | 
 36 | }
 37 | 
 38 | public class IdentityUserLoginMappingMsSql : ClassMapping<IdentityUserLogin> {
 39 | 
 40 |     public IdentityUserLoginMappingMsSql() {
 41 |         Schema("dbo");
 42 |         Table("AspNetUserLogins");
 43 |         ComposedId(id => {
 44 |             id.Property(e => e.LoginProvider, prop => {
 45 |                 prop.Column("LoginProvider");
 46 |                 prop.Type(NHibernateUtil.String);
 47 |                 prop.Length(32);
 48 |             });
 49 |             id.Property(e => e.ProviderKey, prop => {
 50 |                 prop.Column("ProviderKey");
 51 |                 prop.Type(NHibernateUtil.String);
 52 |                 prop.Length(32);
 53 |             });
 54 |         });
 55 |         Property(e => e.ProviderDisplayName, prop => {
 56 |             prop.Column("ProviderDisplayName");
 57 |             prop.Type(NHibernateUtil.String);
 58 |             prop.Length(32);
 59 |             prop.NotNullable(true);
 60 |         });
 61 |         Property(e => e.UserId, prop => {
 62 |             prop.Column("UserId");
 63 |             prop.Type(NHibernateUtil.String);
 64 |             prop.Length(32);
 65 |             prop.NotNullable(true);
 66 |         });
 67 |     }
 68 | 
 69 | }
 70 | 
 71 | public class IdentityUserLoginMappingMySql : ClassMapping<IdentityUserLogin> {
 72 | 
 73 |     public IdentityUserLoginMappingMySql() {
 74 |         Table("aspnet_user_logins");
 75 |         ComposedId(id => {
 76 |             id.Property(e => e.LoginProvider, prop => {
 77 |                 prop.Column("login_provider");
 78 |                 prop.Type(NHibernateUtil.String);
 79 |                 prop.Length(32);
 80 |             });
 81 |             id.Property(e => e.ProviderKey, prop => {
 82 |                 prop.Column("provider_key");
 83 |                 prop.Type(NHibernateUtil.String);
 84 |                 prop.Length(32);
 85 |             });
 86 |         });
 87 |         Property(e => e.ProviderDisplayName, prop => {
 88 |             prop.Column("provider_display_name");
 89 |             prop.Type(NHibernateUtil.String);
 90 |             prop.Length(32);
 91 |             prop.NotNullable(true);
 92 |         });
 93 |         Property(e => e.UserId, prop => {
 94 |             prop.Column("user_id");
 95 |             prop.Type(NHibernateUtil.String);
 96 |             prop.Length(32);
 97 |             prop.NotNullable(true);
 98 |         });
 99 |     }
100 | 
101 | }
102 | 
103 | public class IdentityUserLoginMappingSqlite : ClassMapping<IdentityUserLogin> {
104 | 
105 |     public IdentityUserLoginMappingSqlite() {
106 |         Table("aspnet_user_logins");
107 |         ComposedId(id => {
108 |             id.Property(e => e.LoginProvider, prop => {
109 |                 prop.Column("login_provider");
110 |                 prop.Type(NHibernateUtil.String);
111 |                 prop.Length(32);
112 |             });
113 |             id.Property(e => e.ProviderKey, prop => {
114 |                 prop.Column("provider_key");
115 |                 prop.Type(NHibernateUtil.String);
116 |                 prop.Length(32);
117 |             });
118 |         });
119 |         Property(e => e.ProviderDisplayName, prop => {
120 |             prop.Column("provider_display_name");
121 |             prop.Type(NHibernateUtil.String);
122 |             prop.Length(32);
123 |             prop.NotNullable(true);
124 |         });
125 |         Property(e => e.UserId, prop => {
126 |             prop.Column("user_id");
127 |             prop.Type(NHibernateUtil.String);
128 |             prop.Length(32);
129 |             prop.NotNullable(true);
130 |         });
131 |     }
132 | 
133 | }
134 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/Mappings/IdentityRole.cs:
--------------------------------------------------------------------------------
  1 | using NHibernate.Mapping.ByCode;
  2 | using NHibernate.Mapping.ByCode.Conformist;
  3 | 
  4 | namespace NHibernate.AspNetCore.Identity.Mappings;
  5 | 
  6 | public class IdentityRoleMappingPostgreSql : ClassMapping<IdentityRole> {
  7 | 
  8 |     public IdentityRoleMappingPostgreSql() {
  9 |         Schema("public");
 10 |         Table("aspnet_roles");
 11 |         Id(e => e.Id, id => {
 12 |             id.Column("id");
 13 |             id.Type(NHibernateUtil.String);
 14 |             id.Length(32);
 15 |             id.Generator(Generators.TriggerIdentity);
 16 |         });
 17 |         Property(e => e.Name, prop => {
 18 |             prop.Column("name");
 19 |             prop.Type(NHibernateUtil.String);
 20 |             prop.Length(64);
 21 |             prop.NotNullable(true);
 22 |             prop.Unique(true);
 23 |         });
 24 |         Property(e => e.NormalizedName, prop => {
 25 |             prop.Column("normalized_name");
 26 |             prop.Type(NHibernateUtil.String);
 27 |             prop.Length(64);
 28 |             prop.NotNullable(true);
 29 |             prop.Unique(true);
 30 |         });
 31 |         Property(e => e.ConcurrencyStamp, prop => {
 32 |             prop.Column("concurrency_stamp");
 33 |             prop.Type(NHibernateUtil.String);
 34 |             prop.Length(36);
 35 |             prop.NotNullable(false);
 36 |         });
 37 |     }
 38 | 
 39 | }
 40 | 
 41 | public class IdentityRoleMappingMsSql : ClassMapping<IdentityRole> {
 42 | 
 43 |     public IdentityRoleMappingMsSql() {
 44 |         Schema("dbo");
 45 |         Table("AspNetRoles");
 46 |         Id(e => e.Id, id => {
 47 |             id.Column("Id");
 48 |             id.Type(NHibernateUtil.String);
 49 |             id.Length(32);
 50 |             id.Generator(Generators.UUIDHex("N"));
 51 |         });
 52 |         Property(e => e.Name, prop => {
 53 |             prop.Column("Name");
 54 |             prop.Type(NHibernateUtil.String);
 55 |             prop.Length(64);
 56 |             prop.NotNullable(true);
 57 |             prop.Unique(true);
 58 |         });
 59 |         Property(e => e.NormalizedName, prop => {
 60 |             prop.Column("NormalizedName");
 61 |             prop.Type(NHibernateUtil.String);
 62 |             prop.Length(64);
 63 |             prop.NotNullable(true);
 64 |             prop.Unique(true);
 65 |         });
 66 |         Property(e => e.ConcurrencyStamp, prop => {
 67 |             prop.Column("ConcurrencyStamp");
 68 |             prop.Type(NHibernateUtil.String);
 69 |             prop.Length(36);
 70 |             prop.NotNullable(false);
 71 |         });
 72 |     }
 73 | 
 74 | }
 75 | 
 76 | public class IdentityRoleMappingMySql : ClassMapping<IdentityRole> {
 77 | 
 78 |     public IdentityRoleMappingMySql() {
 79 |         Table("aspnet_roles");
 80 |         Id(e => e.Id, id => {
 81 |             id.Column("id");
 82 |             id.Type(NHibernateUtil.String);
 83 |             id.Length(32);
 84 |             id.Generator(Generators.UUIDHex("N"));
 85 |         });
 86 |         Property(e => e.Name, prop => {
 87 |             prop.Column("name");
 88 |             prop.Type(NHibernateUtil.String);
 89 |             prop.Length(64);
 90 |             prop.NotNullable(true);
 91 |             prop.Unique(true);
 92 |         });
 93 |         Property(e => e.NormalizedName, prop => {
 94 |             prop.Column("normalized_name");
 95 |             prop.Type(NHibernateUtil.String);
 96 |             prop.Length(64);
 97 |             prop.NotNullable(true);
 98 |             prop.Unique(true);
 99 |         });
100 |         Property(e => e.ConcurrencyStamp, prop => {
101 |             prop.Column("concurrency_stamp");
102 |             prop.Type(NHibernateUtil.String);
103 |             prop.Length(36);
104 |             prop.NotNullable(false);
105 |         });
106 |     }
107 | 
108 | }
109 | 
110 | public class IdentityRoleMappingSqlite : ClassMapping<IdentityRole> {
111 | 
112 |     public IdentityRoleMappingSqlite() {
113 |         Table("aspnet_roles");
114 |         Id(e => e.Id, id => {
115 |             id.Column("id");
116 |             id.Type(NHibernateUtil.String);
117 |             id.Length(32);
118 |             id.Generator(Generators.UUIDHex("N"));
119 |         });
120 |         Property(e => e.Name, prop => {
121 |             prop.Column("name");
122 |             prop.Type(NHibernateUtil.String);
123 |             prop.Length(64);
124 |             prop.NotNullable(true);
125 |             prop.Unique(true);
126 |         });
127 |         Property(e => e.NormalizedName, prop => {
128 |             prop.Column("normalized_name");
129 |             prop.Type(NHibernateUtil.String);
130 |             prop.Length(64);
131 |             prop.NotNullable(true);
132 |             prop.Unique(true);
133 |         });
134 |         Property(e => e.ConcurrencyStamp, prop => {
135 |             prop.Column("concurrency_stamp");
136 |             prop.Type(NHibernateUtil.String);
137 |             prop.Length(36);
138 |             prop.NotNullable(false);
139 |         });
140 |     }
141 | 
142 | }
143 | 


--------------------------------------------------------------------------------
/test/UnitTest/Identity/UserStoreTest.cs:
--------------------------------------------------------------------------------
  1 | using System.Security.Claims;
  2 | using Microsoft.AspNetCore.Identity;
  3 | using NHibernate.AspNetCore.Identity;
  4 | using NHibernate.Extensions.NetCore;
  5 | using NHibernate;
  6 | using NHibernate.Linq;
  7 | using NHIdentityUser = NHibernate.AspNetCore.Identity.IdentityUser;
  8 | using NHIdentityRole = NHibernate.AspNetCore.Identity.IdentityRole;
  9 | 
 10 | namespace UnitTest.Identity;
 11 | 
 12 | [TestFixture]
 13 | public class UserStoreTest : BaseTest, IDisposable {
 14 | 
 15 |     private readonly UserStore<NHIdentityUser, NHIdentityRole> store;
 16 |     private readonly ISessionFactory sessionFactory;
 17 | 
 18 |     public UserStoreTest() {
 19 |         var builder = new LoggingBuilder();
 20 |         var loggerFactory = builder.BuildLoggerFactory();
 21 |         loggerFactory.UseAsHibernateLoggerFactory();
 22 |         var cfg = ConfigNHibernate();
 23 |         cfg.AddIdentityMappings();
 24 |         AddXmlMapping(cfg);
 25 |         sessionFactory = cfg.BuildSessionFactory();
 26 |         store = new UserStore<NHIdentityUser, NHIdentityRole>(
 27 |             sessionFactory.OpenSession(),
 28 |             new IdentityErrorDescriber()
 29 |         );
 30 |     }
 31 | 
 32 |     public void Dispose() {
 33 |         store.Dispose();
 34 |         sessionFactory.Dispose();
 35 |     }
 36 | 
 37 |     [Test]
 38 |     public async Task _01_CanQueryAllUsers() {
 39 |         var users = await store.Users.ToListAsync();
 40 |         That(users, Is.Not.Null);
 41 |         That(users.Count, Is.GreaterThan(0));
 42 |     }
 43 | 
 44 |     [Test]
 45 |     public async Task _02_CanDoCurd() {
 46 |         var user = new NHIdentityUser {
 47 |             UserName = "Beginor",
 48 |             NormalizedUserName = "BEGINOR",
 49 |             Email = "beginor@qq.com",
 50 |             PhoneNumber = "02000000000",
 51 |             PhoneNumberConfirmed = true,
 52 |             LockoutEnabled = false,
 53 |             LockoutEnd = null,
 54 |             AccessFailedCount = 0,
 55 |             NormalizedEmail = "BEGINOR@QQ.COM",
 56 |             PasswordHash = null,
 57 |             SecurityStamp = null
 58 |         };
 59 |         var result = await store.CreateAsync(user);
 60 |         That(result.Succeeded);
 61 |         var id = user.Id;
 62 |         That(id, Is.Not.Empty);
 63 |         That(user.ConcurrencyStamp, Is.Not.Empty);
 64 | 
 65 |         user.LockoutEnabled = true;
 66 |         user.LockoutEnd = DateTimeOffset.UtcNow.AddMinutes(20);
 67 |         result = await store.UpdateAsync(user);
 68 |         That(result.Succeeded);
 69 | 
 70 |         var lockouts = await store.Users
 71 |             .Where(u => u.LockoutEnabled)
 72 |             .CountAsync();
 73 |         That(lockouts > 0);
 74 | 
 75 |         user = await store.FindByEmailAsync(user.NormalizedEmail);
 76 |         That(user, Is.Not.Null);
 77 |         That(user!.Id == id);
 78 | 
 79 |         user = await store.FindByNameAsync(user.NormalizedUserName!);
 80 |         That(user, Is.Not.Null);
 81 |         That(user!.Id == id);
 82 | 
 83 |         user = await store.FindByIdAsync(id);
 84 |         That(user!.Id == id);
 85 | 
 86 |         var claim = new Claim("Test", Guid.NewGuid().ToString("N"));
 87 |         await store.AddClaimsAsync(user, new [] { claim });
 88 |         var claims = await store.GetClaimsAsync(user);
 89 |         That(claims.Count > 0);
 90 | 
 91 |         var users = await store.GetUsersForClaimAsync(claim);
 92 |         That(users, Is.Not.Empty);
 93 | 
 94 |         await store.RemoveClaimsAsync(user, claims);
 95 | 
 96 |         var loginInfo = new Microsoft.AspNetCore.Identity.UserLoginInfo(
 97 |             "test",
 98 |             Guid.NewGuid().ToString("N"),
 99 |             "Test"
100 |         );
101 |         await store.AddLoginAsync(user, loginInfo);
102 |         await store.SetTokenAsync(
103 |             user,
104 |             loginInfo.LoginProvider,
105 |             loginInfo.ProviderDisplayName!,
106 |             loginInfo.ProviderKey,
107 |             CancellationToken.None
108 |         );
109 | 
110 |         await store.RemoveTokenAsync(
111 |             user,
112 |             loginInfo.LoginProvider,
113 |             loginInfo.ProviderDisplayName!,
114 |             CancellationToken.None
115 |         );
116 | 
117 |         await store.RemoveLoginAsync(
118 |             user,
119 |             loginInfo.LoginProvider,
120 |             loginInfo.ProviderKey
121 |         );
122 | 
123 |         result = await store.DeleteAsync(user);
124 |         That(result.Succeeded);
125 |     }
126 | 
127 |     [Test]
128 |     public async Task _03_CanGetRolesForUser() {
129 |         using var session = sessionFactory.OpenSession();
130 |         var user = new NHIdentityUser { Id = "1579928865223010012" };
131 |         // IsNotNull(user);
132 |         // var userId = user.Id;
133 |         // var query = from userRole in session.Query<IdentityUserRole>()
134 |         //     join role in session.Query<NHIdentityRole>() on userRole.RoleId equals role.Id
135 |         //     where userRole.UserId == userId
136 |         //     select role.Name;
137 |         // var roles = await query.ToListAsync(CancellationToken.None);
138 |         var roles = await store.GetRolesAsync(user);
139 |         Console.WriteLine(roles.Count);
140 |     }
141 | }
142 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * @license
3 |  * Unobtrusive validation support library for jQuery and jQuery Validate
4 |  * Copyright (c) .NET Foundation. All rights reserved.
5 |  * Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
6 |  * @version v4.0.0
7 |  */
8 | !function(a){"function"==typeof define&&define.amd?define("jquery.validate.unobtrusive",["jquery-validation"],a):"object"==typeof module&&module.exports?module.exports=a(require("jquery-validation")):jQuery.validator.unobtrusive=a(jQuery)}(function(s){var a,o=s.validator,d="unobtrusiveValidation";function l(a,e,n){a.rules[e]=n,a.message&&(a.messages[e]=a.message)}function u(a){return a.replace(/([!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~])/g,"\\$1")}function n(a){return a.substr(0,a.lastIndexOf(".")+1)}function m(a,e){return a=0===a.indexOf("*.")?a.replace("*.",e):a}function f(a){var e=s(this),n="__jquery_unobtrusive_validation_form_reset";if(!e.data(n)){e.data(n,!0);try{e.data("validator").resetForm()}finally{e.removeData(n)}e.find(".validation-summary-errors").addClass("validation-summary-valid").removeClass("validation-summary-errors"),e.find(".field-validation-error").addClass("field-validation-valid").removeClass("field-validation-error").removeData("unobtrusiveContainer").find(">*").removeData("unobtrusiveContainer")}}function p(n){function a(a,e){(a=r[a])&&s.isFunction(a)&&a.apply(n,e)}var e=s(n),t=e.data(d),i=s.proxy(f,n),r=o.unobtrusive.options||{};return t||(t={options:{errorClass:r.errorClass||"input-validation-error",errorElement:r.errorElement||"span",errorPlacement:function(){!function(a,e){var e=s(this).find("[data-valmsg-for='"+u(e[0].name)+"']"),n=(n=e.attr("data-valmsg-replace"))?!1!==s.parseJSON(n):null;e.removeClass("field-validation-valid").addClass("field-validation-error"),a.data("unobtrusiveContainer",e),n?(e.empty(),a.removeClass("input-validation-error").appendTo(e)):a.hide()}.apply(n,arguments),a("errorPlacement",arguments)},invalidHandler:function(){!function(a,e){var n=s(this).find("[data-valmsg-summary=true]"),t=n.find("ul");t&&t.length&&e.errorList.length&&(t.empty(),n.addClass("validation-summary-errors").removeClass("validation-summary-valid"),s.each(e.errorList,function(){s("<li />").html(this.message).appendTo(t)}))}.apply(n,arguments),a("invalidHandler",arguments)},messages:{},rules:{},success:function(){!function(a){var e,n=a.data("unobtrusiveContainer");n&&(e=(e=n.attr("data-valmsg-replace"))?s.parseJSON(e):null,n.addClass("field-validation-valid").removeClass("field-validation-error"),a.removeData("unobtrusiveContainer"),e&&n.empty())}.apply(n,arguments),a("success",arguments)}},attachValidation:function(){e.off("reset."+d,i).on("reset."+d,i).validate(this.options)},validate:function(){return e.validate(),e.valid()}},e.data(d,t)),t}return o.unobtrusive={adapters:[],parseElement:function(t,a){var e,i,r,o=s(t),d=o.parents("form")[0];d&&((e=p(d)).options.rules[t.name]=i={},e.options.messages[t.name]=r={},s.each(this.adapters,function(){var a="data-val-"+this.name,e=o.attr(a),n={};void 0!==e&&(a+="-",s.each(this.params,function(){n[this]=o.attr(a+this)}),this.adapt({element:t,form:d,message:e,params:n,rules:i,messages:r}))}),s.extend(i,{__dummy__:!0}),a||e.attachValidation())},parse:function(a){var a=s(a),e=a.parents().addBack().filter("form").add(a.find("form")).has("[data-val=true]");a.find("[data-val=true]").each(function(){o.unobtrusive.parseElement(this,!0)}),e.each(function(){var a=p(this);a&&a.attachValidation()})}},(a=o.unobtrusive.adapters).add=function(a,e,n){return n||(n=e,e=[]),this.push({name:a,params:e,adapt:n}),this},a.addBool=function(e,n){return this.add(e,function(a){l(a,n||e,!0)})},a.addMinMax=function(a,t,i,r,e,n){return this.add(a,[e||"min",n||"max"],function(a){var e=a.params.min,n=a.params.max;e&&n?l(a,r,[e,n]):e?l(a,t,e):n&&l(a,i,n)})},a.addSingleVal=function(e,n,t){return this.add(e,[n||"val"],function(a){l(a,t||e,a.params[n])})},o.addMethod("__dummy__",function(a,e,n){return!0}),o.addMethod("regex",function(a,e,n){return!!this.optional(e)||(e=new RegExp(n).exec(a))&&0===e.index&&e[0].length===a.length}),o.addMethod("nonalphamin",function(a,e,n){var t;return t=n?(t=a.match(/\W/g))&&t.length>=n:t}),o.methods.extension?(a.addSingleVal("accept","mimtype"),a.addSingleVal("extension","extension")):a.addSingleVal("extension","extension","accept"),a.addSingleVal("regex","pattern"),a.addBool("creditcard").addBool("date").addBool("digits").addBool("email").addBool("number").addBool("url"),a.addMinMax("length","minlength","maxlength","rangelength").addMinMax("range","min","max","range"),a.addMinMax("minlength","minlength").addMinMax("maxlength","minlength","maxlength"),a.add("equalto",["other"],function(a){var e=n(a.element.name),e=m(a.params.other,e);l(a,"equalTo",s(a.form).find(":input").filter("[name='"+u(e)+"']")[0])}),a.add("required",function(a){"INPUT"===a.element.tagName.toUpperCase()&&"CHECKBOX"===a.element.type.toUpperCase()||l(a,"required",!0)}),a.add("remote",["url","type","additionalfields"],function(t){var i={url:t.params.url,type:t.params.type||"GET",data:{}},r=n(t.element.name);s.each((t.params.additionalfields||t.element.name).replace(/^\s+|\s+$/g,"").split(/\s*,\s*/g),function(a,e){var n=m(e,r);i.data[n]=function(){var a=s(t.form).find(":input").filter("[name='"+u(n)+"']");return a.is(":checkbox")?a.filter(":checked").val()||a.filter(":hidden").val()||"":a.is(":radio")?a.filter(":checked").val()||"":a.val()}}),l(t,"remote",i)}),a.add("password",["min","nonalphamin","regex"],function(a){a.params.min&&l(a,"minlength",a.params.min),a.params.nonalphamin&&l(a,"nonalphamin",a.params.nonalphamin),a.params.regex&&l(a,"regex",a.params.regex)}),a.add("fileextensions",["extensions"],function(a){l(a,"extension",a.params.extensions)}),s(function(){o.unobtrusive.parse(document)}),o.unobtrusive});


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
  1 | # http://editorconfig.org
  2 | root = true
  3 | # All files
  4 | [*]
  5 | end_of_line = lf
  6 | insert_final_newline = true
  7 | charset = utf-8
  8 | indent_style = space
  9 | indent_size = 4
 10 | trim_trailing_whitespace = true
 11 | # html/scss/css files
 12 | [*.{html,scss,css,json,xml,csproj,config,props}]
 13 | indent_size = 2
 14 | # markdown files
 15 | [*.md]
 16 | trim_trailing_whitespace = false
 17 | indent_size = 2
 18 | 
 19 | # Dotnet code style settings:
 20 | [*.{cs,vb}]
 21 | # Sort using and Import directives with System.* appearing first
 22 | dotnet_sort_system_directives_first = true
 23 | # Avoid "this." and "Me." if not necessary
 24 | dotnet_style_qualification_for_field = false:suggestion
 25 | dotnet_style_qualification_for_property = false:suggestion
 26 | dotnet_style_qualification_for_method = false:suggestion
 27 | dotnet_style_qualification_for_event = false:suggestion
 28 | 
 29 | # Use language keywords instead of framework type names for type references
 30 | dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
 31 | dotnet_style_predefined_type_for_member_access = true:suggestion
 32 | 
 33 | # Suggest more modern language features when available
 34 | dotnet_style_object_initializer = true:suggestion
 35 | dotnet_style_collection_initializer = true:suggestion
 36 | dotnet_style_coalesce_expression = true:suggestion
 37 | dotnet_style_null_propagation = true:suggestion
 38 | dotnet_style_explicit_tuple_names = true:suggestion
 39 | 
 40 | # Non-private static fields are PascalCase
 41 | dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion
 42 | dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
 43 | dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style
 44 | 
 45 | dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field
 46 | dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected internal, private protected
 47 | dotnet_naming_symbols.non_private_static_fields.required_modifiers = static
 48 | 
 49 | dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case
 50 | 
 51 | # Constants are PascalCase
 52 | dotnet_naming_rule.constants_should_be_pascal_case.severity = suggestion
 53 | dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants
 54 | dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style
 55 | 
 56 | dotnet_naming_symbols.constants.applicable_kinds = field, local
 57 | dotnet_naming_symbols.constants.required_modifiers = const
 58 | 
 59 | dotnet_naming_style.constant_style.capitalization = pascal_case
 60 | 
 61 | # Static fields are camelCase and start with s_
 62 | dotnet_naming_rule.static_fields_should_be_camel_case.severity = suggestion
 63 | dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields
 64 | dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style
 65 | 
 66 | dotnet_naming_symbols.static_fields.applicable_kinds = field
 67 | dotnet_naming_symbols.static_fields.required_modifiers = static
 68 | 
 69 | dotnet_naming_style.static_field_style.capitalization = camel_case
 70 | 
 71 | # Instance fields are camelCase and start with _
 72 | dotnet_naming_rule.instance_fields_should_be_camel_case.severity = suggestion
 73 | dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields
 74 | dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style
 75 | 
 76 | dotnet_naming_symbols.instance_fields.applicable_kinds = field
 77 | 
 78 | dotnet_naming_style.instance_field_style.capitalization = camel_case
 79 | 
 80 | # Locals and parameters are camelCase
 81 | dotnet_naming_rule.locals_should_be_camel_case.severity = suggestion
 82 | dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
 83 | dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
 84 | 
 85 | dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
 86 | 
 87 | dotnet_naming_style.camel_case_style.capitalization = camel_case
 88 | 
 89 | # Local functions are PascalCase
 90 | dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
 91 | dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
 92 | dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style
 93 | 
 94 | dotnet_naming_symbols.local_functions.applicable_kinds = local_function
 95 | 
 96 | dotnet_naming_style.local_function_style.capitalization = pascal_case
 97 | 
 98 | # By default, name items with PascalCase
 99 | dotnet_naming_rule.members_should_be_pascal_case.severity = suggestion
100 | dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members
101 | dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style
102 | 
103 | dotnet_naming_symbols.all_members.applicable_kinds = *
104 | 
105 | dotnet_naming_style.pascal_case_style.capitalization = pascal_case
106 | 
107 | # CSharp code style settings:
108 | [*.cs]
109 | # Indentation preferences
110 | csharp_indent_block_contents = true
111 | csharp_indent_braces = false
112 | csharp_indent_case_contents = true
113 | csharp_indent_switch_labels = true
114 | csharp_indent_labels = flush_left
115 | 
116 | # Prefer "var" everywhere
117 | csharp_style_var_for_built_in_types = true:suggestion
118 | csharp_style_var_when_type_is_apparent = true:suggestion
119 | csharp_style_var_elsewhere = true:suggestion
120 | 
121 | # Prefer method-like constructs to have a block body
122 | csharp_style_expression_bodied_methods = false:none
123 | csharp_style_expression_bodied_constructors = false:none
124 | csharp_style_expression_bodied_operators = false:none
125 | 
126 | # Prefer property-like constructs to have an expression-body
127 | csharp_style_expression_bodied_properties = true:none
128 | csharp_style_expression_bodied_indexers = true:none
129 | csharp_style_expression_bodied_accessors = true:none
130 | 
131 | # Suggest more modern language features when available
132 | csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
133 | csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
134 | csharp_style_inlined_variable_declaration = true:suggestion
135 | csharp_style_throw_expression = true:suggestion
136 | csharp_style_conditional_delegate_call = true:suggestion
137 | 
138 | # Newline settings
139 | csharp_new_line_before_open_brace = none
140 | csharp_new_line_before_else = true
141 | csharp_new_line_before_catch = true
142 | csharp_new_line_before_finally = true
143 | csharp_new_line_before_members_in_object_initializers = true
144 | csharp_new_line_before_members_in_anonymous_types = true
145 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/RoleStore.cs:
--------------------------------------------------------------------------------
  1 | using System.Security.Claims;
  2 | using Microsoft.AspNetCore.Identity;
  3 | using NHibernate.Linq;
  4 | 
  5 | namespace NHibernate.AspNetCore.Identity;
  6 | 
  7 | public class RoleStore<TRole>(
  8 |     ISession session,
  9 |     IdentityErrorDescriber describer
 10 | ) : RoleStoreBase<TRole, string, IdentityUserRole, IdentityRoleClaim>(describer)
 11 |     where TRole : IdentityRole {
 12 | 
 13 |     public override async Task<IdentityResult> CreateAsync(
 14 |         TRole role,
 15 |         CancellationToken cancellationToken = default
 16 |     ) {
 17 |         cancellationToken.ThrowIfCancellationRequested();
 18 |         ThrowIfDisposed();
 19 |         if (role == null) {
 20 |             throw new ArgumentNullException(nameof(role));
 21 |         }
 22 |         await session.SaveAsync(role, cancellationToken);
 23 |         await FlushChangesAsync(cancellationToken);
 24 |         return IdentityResult.Success;
 25 |     }
 26 | 
 27 |     public override async Task<IdentityResult> UpdateAsync(
 28 |         TRole role,
 29 |         CancellationToken cancellationToken = default
 30 |     ) {
 31 |         cancellationToken.ThrowIfCancellationRequested();
 32 |         ThrowIfDisposed();
 33 |         if (role == null) {
 34 |             throw new ArgumentNullException(nameof(role));
 35 |         }
 36 |         var exists = await Roles.AnyAsync(
 37 |             r => r.Id == role.Id,
 38 |             cancellationToken
 39 |         );
 40 |         if (!exists) {
 41 |             return IdentityResult.Failed(
 42 |                 new IdentityError {
 43 |                     Code = "RoleNotExist",
 44 |                     Description = $"Role with {role.Id} does not exists."
 45 |                 }
 46 |             );
 47 |         }
 48 |         role.ConcurrencyStamp = Guid.NewGuid().ToString("N");
 49 |         await session.MergeAsync(role, cancellationToken);
 50 |         await FlushChangesAsync(cancellationToken);
 51 |         return IdentityResult.Success;
 52 |     }
 53 | 
 54 |     public override async Task<IdentityResult> DeleteAsync(
 55 |         TRole role,
 56 |         CancellationToken cancellationToken = default
 57 |     ) {
 58 |         cancellationToken.ThrowIfCancellationRequested();
 59 |         ThrowIfDisposed();
 60 |         if (role == null) {
 61 |             throw new ArgumentNullException(nameof(role));
 62 |         }
 63 |         await session.DeleteAsync(role, cancellationToken);
 64 |         await FlushChangesAsync(cancellationToken);
 65 |         return IdentityResult.Success;
 66 |     }
 67 | 
 68 |     public override Task<string> GetRoleIdAsync(
 69 |         TRole role,
 70 |         CancellationToken cancellationToken = default
 71 |     ) {
 72 |         cancellationToken.ThrowIfCancellationRequested();
 73 |         ThrowIfDisposed();
 74 |         if (role == null) {
 75 |             throw new ArgumentNullException(nameof(role));
 76 |         }
 77 |         return Task.FromResult(role.Id);
 78 |     }
 79 | 
 80 |     public override Task<string?> GetRoleNameAsync(
 81 |         TRole role,
 82 |         CancellationToken cancellationToken = default
 83 |     ) {
 84 |         cancellationToken.ThrowIfCancellationRequested();
 85 |         ThrowIfDisposed();
 86 |         if (role == null) {
 87 |             throw new ArgumentNullException(nameof(role));
 88 |         }
 89 |         return Task.FromResult(role.Name);
 90 |     }
 91 | 
 92 |     public override async Task<TRole?> FindByIdAsync(
 93 |         string roleId,
 94 |         CancellationToken cancellationToken = default
 95 |     ) {
 96 |         cancellationToken.ThrowIfCancellationRequested();
 97 |         ThrowIfDisposed();
 98 |         var id = roleId;
 99 |         var role = await session.GetAsync<TRole>(id, cancellationToken);
100 |         return role;
101 |     }
102 | 
103 |     public override async Task<TRole?> FindByNameAsync(
104 |         string normalizedRoleName,
105 |         CancellationToken cancellationToken = default
106 |     ) {
107 |         cancellationToken.ThrowIfCancellationRequested();
108 |         ThrowIfDisposed();
109 |         var role = await Roles
110 |             .FirstOrDefaultAsync(
111 |                 r => r.NormalizedName == normalizedRoleName,
112 |                 cancellationToken
113 |             );
114 |         return role;
115 |     }
116 | 
117 |     public override IQueryable<TRole> Roles => session.Query<TRole>();
118 | 
119 |     private IQueryable<IdentityRoleClaim> RoleClaims => session.Query<IdentityRoleClaim>();
120 | 
121 |     public override async Task<IList<Claim>> GetClaimsAsync(
122 |         TRole role,
123 |         CancellationToken cancellationToken = default
124 |     ) {
125 |         cancellationToken.ThrowIfCancellationRequested();
126 |         ThrowIfDisposed();
127 |         if (role == null) {
128 |             throw new ArgumentNullException(nameof(role));
129 |         }
130 | 
131 |         var claims = await RoleClaims
132 |             .Where(rc => rc.RoleId == role.Id)
133 |             .Select(c => new Claim(c.ClaimType!, c.ClaimValue!))
134 |             .ToListAsync(cancellationToken);
135 |         return claims;
136 |     }
137 | 
138 |     public override async Task AddClaimAsync(
139 |         TRole role,
140 |         Claim claim,
141 |         CancellationToken cancellationToken = default
142 |     ) {
143 |         cancellationToken.ThrowIfCancellationRequested();
144 |         ThrowIfDisposed();
145 |         if (role == null) {
146 |             throw new ArgumentNullException(nameof(role));
147 |         }
148 |         if (claim == null) {
149 |             throw new ArgumentNullException(nameof(claim));
150 |         }
151 |         var roleClaim = CreateRoleClaim(role, claim);
152 |         await session.SaveAsync(roleClaim, cancellationToken);
153 |         await FlushChangesAsync(cancellationToken);
154 |     }
155 | 
156 |     public override async Task RemoveClaimAsync(
157 |         TRole role,
158 |         Claim claim,
159 |         CancellationToken cancellationToken = default
160 |     ) {
161 |         cancellationToken.ThrowIfCancellationRequested();
162 |         ThrowIfDisposed();
163 |         if (role == null) {
164 |             throw new ArgumentNullException(nameof(role));
165 |         }
166 |         if (claim == null) {
167 |             throw new ArgumentNullException(nameof(claim));
168 |         }
169 |         var claims = await RoleClaims.Where(
170 |                 rc => rc.RoleId == role.Id
171 |                     && rc.ClaimValue == claim.Value &&
172 |                     rc.ClaimType == claim.Type
173 |             )
174 |             .ToListAsync(cancellationToken);
175 |         foreach (var c in claims) {
176 |             await session.DeleteAsync(c, cancellationToken);
177 |         }
178 |         await FlushChangesAsync(cancellationToken);
179 |     }
180 | 
181 |     private async Task FlushChangesAsync(
182 |         CancellationToken cancellationToken = default
183 |     ) {
184 |         await session.FlushAsync(cancellationToken);
185 |         session.Clear();
186 |     }
187 | 
188 | }
189 | 


--------------------------------------------------------------------------------
/database/up.md:
--------------------------------------------------------------------------------
  1 | ```c#
  2 | protected override void Up(MigrationBuilder migrationBuilder)
  3 | {
  4 |     migrationBuilder.CreateTable(
  5 |         name: "AspNetRoles",
  6 |         columns: table => new
  7 |         {
  8 |             Id = table.Column<string>(nullable: false),
  9 |             Name = table.Column<string>(maxLength: 256, nullable: true),
 10 |             NormalizedName = table.Column<string>(maxLength: 256, nullable: true),
 11 |             ConcurrencyStamp = table.Column<string>(nullable: true)
 12 |         },
 13 |         constraints: table =>
 14 |         {
 15 |             table.PrimaryKey("PK_AspNetRoles", x => x.Id);
 16 |         });
 17 | 
 18 |     migrationBuilder.CreateTable(
 19 |         name: "AspNetUsers",
 20 |         columns: table => new
 21 |         {
 22 |             Id = table.Column<string>(nullable: false),
 23 |             UserName = table.Column<string>(maxLength: 256, nullable: true),
 24 |             NormalizedUserName = table.Column<string>(maxLength: 256, nullable: true),
 25 |             Email = table.Column<string>(maxLength: 256, nullable: true),
 26 |             NormalizedEmail = table.Column<string>(maxLength: 256, nullable: true),
 27 |             EmailConfirmed = table.Column<bool>(nullable: false),
 28 |             PasswordHash = table.Column<string>(nullable: true),
 29 |             SecurityStamp = table.Column<string>(nullable: true),
 30 |             ConcurrencyStamp = table.Column<string>(nullable: true),
 31 |             PhoneNumber = table.Column<string>(nullable: true),
 32 |             PhoneNumberConfirmed = table.Column<bool>(nullable: false),
 33 |             TwoFactorEnabled = table.Column<bool>(nullable: false),
 34 |             LockoutEnd = table.Column<DateTimeOffset>(nullable: true),
 35 |             LockoutEnabled = table.Column<bool>(nullable: false),
 36 |             AccessFailedCount = table.Column<int>(nullable: false)
 37 |         },
 38 |         constraints: table =>
 39 |         {
 40 |             table.PrimaryKey("PK_AspNetUsers", x => x.Id);
 41 |         });
 42 | 
 43 |     migrationBuilder.CreateTable(
 44 |         name: "AspNetRoleClaims",
 45 |         columns: table => new
 46 |         {
 47 |             Id = table.Column<int>(nullable: false)
 48 |                 .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
 49 |             RoleId = table.Column<string>(nullable: false),
 50 |             ClaimType = table.Column<string>(nullable: true),
 51 |             ClaimValue = table.Column<string>(nullable: true)
 52 |         },
 53 |         constraints: table =>
 54 |         {
 55 |             table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
 56 |             table.ForeignKey(
 57 |                 name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
 58 |                 column: x => x.RoleId,
 59 |                 principalTable: "AspNetRoles",
 60 |                 principalColumn: "Id",
 61 |                 onDelete: ReferentialAction.Cascade);
 62 |         });
 63 | 
 64 |     migrationBuilder.CreateTable(
 65 |         name: "AspNetUserClaims",
 66 |         columns: table => new
 67 |         {
 68 |             Id = table.Column<int>(nullable: false)
 69 |                 .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
 70 |             UserId = table.Column<string>(nullable: false),
 71 |             ClaimType = table.Column<string>(nullable: true),
 72 |             ClaimValue = table.Column<string>(nullable: true)
 73 |         },
 74 |         constraints: table =>
 75 |         {
 76 |             table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
 77 |             table.ForeignKey(
 78 |                 name: "FK_AspNetUserClaims_AspNetUsers_UserId",
 79 |                 column: x => x.UserId,
 80 |                 principalTable: "AspNetUsers",
 81 |                 principalColumn: "Id",
 82 |                 onDelete: ReferentialAction.Cascade);
 83 |         });
 84 | 
 85 |     migrationBuilder.CreateTable(
 86 |         name: "AspNetUserLogins",
 87 |         columns: table => new
 88 |         {
 89 |             LoginProvider = table.Column<string>(maxLength: 128, nullable: false),
 90 |             ProviderKey = table.Column<string>(maxLength: 128, nullable: false),
 91 |             ProviderDisplayName = table.Column<string>(nullable: true),
 92 |             UserId = table.Column<string>(nullable: false)
 93 |         },
 94 |         constraints: table =>
 95 |         {
 96 |             table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
 97 |             table.ForeignKey(
 98 |                 name: "FK_AspNetUserLogins_AspNetUsers_UserId",
 99 |                 column: x => x.UserId,
100 |                 principalTable: "AspNetUsers",
101 |                 principalColumn: "Id",
102 |                 onDelete: ReferentialAction.Cascade);
103 |         });
104 | 
105 |     migrationBuilder.CreateTable(
106 |         name: "AspNetUserRoles",
107 |         columns: table => new
108 |         {
109 |             UserId = table.Column<string>(nullable: false),
110 |             RoleId = table.Column<string>(nullable: false)
111 |         },
112 |         constraints: table =>
113 |         {
114 |             table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
115 |             table.ForeignKey(
116 |                 name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
117 |                 column: x => x.RoleId,
118 |                 principalTable: "AspNetRoles",
119 |                 principalColumn: "Id",
120 |                 onDelete: ReferentialAction.Cascade);
121 |             table.ForeignKey(
122 |                 name: "FK_AspNetUserRoles_AspNetUsers_UserId",
123 |                 column: x => x.UserId,
124 |                 principalTable: "AspNetUsers",
125 |                 principalColumn: "Id",
126 |                 onDelete: ReferentialAction.Cascade);
127 |         });
128 | 
129 |     migrationBuilder.CreateTable(
130 |         name: "AspNetUserTokens",
131 |         columns: table => new
132 |         {
133 |             UserId = table.Column<string>(nullable: false),
134 |             LoginProvider = table.Column<string>(maxLength: 128, nullable: false),
135 |             Name = table.Column<string>(maxLength: 128, nullable: false),
136 |             Value = table.Column<string>(nullable: true)
137 |         },
138 |         constraints: table =>
139 |         {
140 |             table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
141 |             table.ForeignKey(
142 |                 name: "FK_AspNetUserTokens_AspNetUsers_UserId",
143 |                 column: x => x.UserId,
144 |                 principalTable: "AspNetUsers",
145 |                 principalColumn: "Id",
146 |                 onDelete: ReferentialAction.Cascade);
147 |         });
148 | 
149 |     migrationBuilder.CreateIndex(
150 |         name: "IX_AspNetRoleClaims_RoleId",
151 |         table: "AspNetRoleClaims",
152 |         column: "RoleId");
153 | 
154 |     migrationBuilder.CreateIndex(
155 |         name: "RoleNameIndex",
156 |         table: "AspNetRoles",
157 |         column: "NormalizedName",
158 |         unique: true,
159 |         filter: "[NormalizedName] IS NOT NULL");
160 | 
161 |     migrationBuilder.CreateIndex(
162 |         name: "IX_AspNetUserClaims_UserId",
163 |         table: "AspNetUserClaims",
164 |         column: "UserId");
165 | 
166 |     migrationBuilder.CreateIndex(
167 |         name: "IX_AspNetUserLogins_UserId",
168 |         table: "AspNetUserLogins",
169 |         column: "UserId");
170 | 
171 |     migrationBuilder.CreateIndex(
172 |         name: "IX_AspNetUserRoles_RoleId",
173 |         table: "AspNetUserRoles",
174 |         column: "RoleId");
175 | 
176 |     migrationBuilder.CreateIndex(
177 |         name: "EmailIndex",
178 |         table: "AspNetUsers",
179 |         column: "NormalizedEmail");
180 | 
181 |     migrationBuilder.CreateIndex(
182 |         name: "UserNameIndex",
183 |         table: "AspNetUsers",
184 |         column: "NormalizedUserName",
185 |         unique: true,
186 |         filter: "[NormalizedUserName] IS NOT NULL");
187 | }
188 | ```
189 | 


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.rtl.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
  3 |  * Copyright 2011-2021 The Bootstrap Authors
  4 |  * Copyright 2011-2021 Twitter, Inc.
  5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
  7 |  */
  8 | *,
  9 | *::before,
 10 | *::after {
 11 |   box-sizing: border-box;
 12 | }
 13 | 
 14 | @media (prefers-reduced-motion: no-preference) {
 15 |   :root {
 16 |     scroll-behavior: smooth;
 17 |   }
 18 | }
 19 | 
 20 | body {
 21 |   margin: 0;
 22 |   font-family: var(--bs-body-font-family);
 23 |   font-size: var(--bs-body-font-size);
 24 |   font-weight: var(--bs-body-font-weight);
 25 |   line-height: var(--bs-body-line-height);
 26 |   color: var(--bs-body-color);
 27 |   text-align: var(--bs-body-text-align);
 28 |   background-color: var(--bs-body-bg);
 29 |   -webkit-text-size-adjust: 100%;
 30 |   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
 31 | }
 32 | 
 33 | hr {
 34 |   margin: 1rem 0;
 35 |   color: inherit;
 36 |   background-color: currentColor;
 37 |   border: 0;
 38 |   opacity: 0.25;
 39 | }
 40 | 
 41 | hr:not([size]) {
 42 |   height: 1px;
 43 | }
 44 | 
 45 | h6, h5, h4, h3, h2, h1 {
 46 |   margin-top: 0;
 47 |   margin-bottom: 0.5rem;
 48 |   font-weight: 500;
 49 |   line-height: 1.2;
 50 | }
 51 | 
 52 | h1 {
 53 |   font-size: calc(1.375rem + 1.5vw);
 54 | }
 55 | @media (min-width: 1200px) {
 56 |   h1 {
 57 |     font-size: 2.5rem;
 58 |   }
 59 | }
 60 | 
 61 | h2 {
 62 |   font-size: calc(1.325rem + 0.9vw);
 63 | }
 64 | @media (min-width: 1200px) {
 65 |   h2 {
 66 |     font-size: 2rem;
 67 |   }
 68 | }
 69 | 
 70 | h3 {
 71 |   font-size: calc(1.3rem + 0.6vw);
 72 | }
 73 | @media (min-width: 1200px) {
 74 |   h3 {
 75 |     font-size: 1.75rem;
 76 |   }
 77 | }
 78 | 
 79 | h4 {
 80 |   font-size: calc(1.275rem + 0.3vw);
 81 | }
 82 | @media (min-width: 1200px) {
 83 |   h4 {
 84 |     font-size: 1.5rem;
 85 |   }
 86 | }
 87 | 
 88 | h5 {
 89 |   font-size: 1.25rem;
 90 | }
 91 | 
 92 | h6 {
 93 |   font-size: 1rem;
 94 | }
 95 | 
 96 | p {
 97 |   margin-top: 0;
 98 |   margin-bottom: 1rem;
 99 | }
100 | 
101 | abbr[title],
102 | abbr[data-bs-original-title] {
103 |   -webkit-text-decoration: underline dotted;
104 |   text-decoration: underline dotted;
105 |   cursor: help;
106 |   -webkit-text-decoration-skip-ink: none;
107 |   text-decoration-skip-ink: none;
108 | }
109 | 
110 | address {
111 |   margin-bottom: 1rem;
112 |   font-style: normal;
113 |   line-height: inherit;
114 | }
115 | 
116 | ol,
117 | ul {
118 |   padding-right: 2rem;
119 | }
120 | 
121 | ol,
122 | ul,
123 | dl {
124 |   margin-top: 0;
125 |   margin-bottom: 1rem;
126 | }
127 | 
128 | ol ol,
129 | ul ul,
130 | ol ul,
131 | ul ol {
132 |   margin-bottom: 0;
133 | }
134 | 
135 | dt {
136 |   font-weight: 700;
137 | }
138 | 
139 | dd {
140 |   margin-bottom: 0.5rem;
141 |   margin-right: 0;
142 | }
143 | 
144 | blockquote {
145 |   margin: 0 0 1rem;
146 | }
147 | 
148 | b,
149 | strong {
150 |   font-weight: bolder;
151 | }
152 | 
153 | small {
154 |   font-size: 0.875em;
155 | }
156 | 
157 | mark {
158 |   padding: 0.2em;
159 |   background-color: #fcf8e3;
160 | }
161 | 
162 | sub,
163 | sup {
164 |   position: relative;
165 |   font-size: 0.75em;
166 |   line-height: 0;
167 |   vertical-align: baseline;
168 | }
169 | 
170 | sub {
171 |   bottom: -0.25em;
172 | }
173 | 
174 | sup {
175 |   top: -0.5em;
176 | }
177 | 
178 | a {
179 |   color: #0d6efd;
180 |   text-decoration: underline;
181 | }
182 | a:hover {
183 |   color: #0a58ca;
184 | }
185 | 
186 | a:not([href]):not([class]), a:not([href]):not([class]):hover {
187 |   color: inherit;
188 |   text-decoration: none;
189 | }
190 | 
191 | pre,
192 | code,
193 | kbd,
194 | samp {
195 |   font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
196 |   font-size: 1em;
197 |   direction: ltr ;
198 |   unicode-bidi: bidi-override;
199 | }
200 | 
201 | pre {
202 |   display: block;
203 |   margin-top: 0;
204 |   margin-bottom: 1rem;
205 |   overflow: auto;
206 |   font-size: 0.875em;
207 | }
208 | pre code {
209 |   font-size: inherit;
210 |   color: inherit;
211 |   word-break: normal;
212 | }
213 | 
214 | code {
215 |   font-size: 0.875em;
216 |   color: #d63384;
217 |   word-wrap: break-word;
218 | }
219 | a > code {
220 |   color: inherit;
221 | }
222 | 
223 | kbd {
224 |   padding: 0.2rem 0.4rem;
225 |   font-size: 0.875em;
226 |   color: #fff;
227 |   background-color: #212529;
228 |   border-radius: 0.2rem;
229 | }
230 | kbd kbd {
231 |   padding: 0;
232 |   font-size: 1em;
233 |   font-weight: 700;
234 | }
235 | 
236 | figure {
237 |   margin: 0 0 1rem;
238 | }
239 | 
240 | img,
241 | svg {
242 |   vertical-align: middle;
243 | }
244 | 
245 | table {
246 |   caption-side: bottom;
247 |   border-collapse: collapse;
248 | }
249 | 
250 | caption {
251 |   padding-top: 0.5rem;
252 |   padding-bottom: 0.5rem;
253 |   color: #6c757d;
254 |   text-align: right;
255 | }
256 | 
257 | th {
258 |   text-align: inherit;
259 |   text-align: -webkit-match-parent;
260 | }
261 | 
262 | thead,
263 | tbody,
264 | tfoot,
265 | tr,
266 | td,
267 | th {
268 |   border-color: inherit;
269 |   border-style: solid;
270 |   border-width: 0;
271 | }
272 | 
273 | label {
274 |   display: inline-block;
275 | }
276 | 
277 | button {
278 |   border-radius: 0;
279 | }
280 | 
281 | button:focus:not(:focus-visible) {
282 |   outline: 0;
283 | }
284 | 
285 | input,
286 | button,
287 | select,
288 | optgroup,
289 | textarea {
290 |   margin: 0;
291 |   font-family: inherit;
292 |   font-size: inherit;
293 |   line-height: inherit;
294 | }
295 | 
296 | button,
297 | select {
298 |   text-transform: none;
299 | }
300 | 
301 | [role=button] {
302 |   cursor: pointer;
303 | }
304 | 
305 | select {
306 |   word-wrap: normal;
307 | }
308 | select:disabled {
309 |   opacity: 1;
310 | }
311 | 
312 | [list]::-webkit-calendar-picker-indicator {
313 |   display: none;
314 | }
315 | 
316 | button,
317 | [type=button],
318 | [type=reset],
319 | [type=submit] {
320 |   -webkit-appearance: button;
321 | }
322 | button:not(:disabled),
323 | [type=button]:not(:disabled),
324 | [type=reset]:not(:disabled),
325 | [type=submit]:not(:disabled) {
326 |   cursor: pointer;
327 | }
328 | 
329 | ::-moz-focus-inner {
330 |   padding: 0;
331 |   border-style: none;
332 | }
333 | 
334 | textarea {
335 |   resize: vertical;
336 | }
337 | 
338 | fieldset {
339 |   min-width: 0;
340 |   padding: 0;
341 |   margin: 0;
342 |   border: 0;
343 | }
344 | 
345 | legend {
346 |   float: right;
347 |   width: 100%;
348 |   padding: 0;
349 |   margin-bottom: 0.5rem;
350 |   font-size: calc(1.275rem + 0.3vw);
351 |   line-height: inherit;
352 | }
353 | @media (min-width: 1200px) {
354 |   legend {
355 |     font-size: 1.5rem;
356 |   }
357 | }
358 | legend + * {
359 |   clear: right;
360 | }
361 | 
362 | ::-webkit-datetime-edit-fields-wrapper,
363 | ::-webkit-datetime-edit-text,
364 | ::-webkit-datetime-edit-minute,
365 | ::-webkit-datetime-edit-hour-field,
366 | ::-webkit-datetime-edit-day-field,
367 | ::-webkit-datetime-edit-month-field,
368 | ::-webkit-datetime-edit-year-field {
369 |   padding: 0;
370 | }
371 | 
372 | ::-webkit-inner-spin-button {
373 |   height: auto;
374 | }
375 | 
376 | [type=search] {
377 |   outline-offset: -2px;
378 |   -webkit-appearance: textfield;
379 | }
380 | 
381 | [type="tel"],
382 | [type="url"],
383 | [type="email"],
384 | [type="number"] {
385 |   direction: ltr;
386 | }
387 | ::-webkit-search-decoration {
388 |   -webkit-appearance: none;
389 | }
390 | 
391 | ::-webkit-color-swatch-wrapper {
392 |   padding: 0;
393 | }
394 | 
395 | ::file-selector-button {
396 |   font: inherit;
397 | }
398 | 
399 | ::-webkit-file-upload-button {
400 |   font: inherit;
401 |   -webkit-appearance: button;
402 | }
403 | 
404 | output {
405 |   display: inline-block;
406 | }
407 | 
408 | iframe {
409 |   border: 0;
410 | }
411 | 
412 | summary {
413 |   display: list-item;
414 |   cursor: pointer;
415 | }
416 | 
417 | progress {
418 |   vertical-align: baseline;
419 | }
420 | 
421 | [hidden] {
422 |   display: none !important;
423 | }
424 | /*# sourceMappingURL=bootstrap-reboot.rtl.css.map */


--------------------------------------------------------------------------------
/test/WebTest/wwwroot/lib/bootstrap/dist/css/bootstrap-reboot.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Bootstrap Reboot v5.1.0 (https://getbootstrap.com/)
  3 |  * Copyright 2011-2021 The Bootstrap Authors
  4 |  * Copyright 2011-2021 Twitter, Inc.
  5 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  6 |  * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
  7 |  */
  8 | *,
  9 | *::before,
 10 | *::after {
 11 |   box-sizing: border-box;
 12 | }
 13 | 
 14 | @media (prefers-reduced-motion: no-preference) {
 15 |   :root {
 16 |     scroll-behavior: smooth;
 17 |   }
 18 | }
 19 | 
 20 | body {
 21 |   margin: 0;
 22 |   font-family: var(--bs-body-font-family);
 23 |   font-size: var(--bs-body-font-size);
 24 |   font-weight: var(--bs-body-font-weight);
 25 |   line-height: var(--bs-body-line-height);
 26 |   color: var(--bs-body-color);
 27 |   text-align: var(--bs-body-text-align);
 28 |   background-color: var(--bs-body-bg);
 29 |   -webkit-text-size-adjust: 100%;
 30 |   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
 31 | }
 32 | 
 33 | hr {
 34 |   margin: 1rem 0;
 35 |   color: inherit;
 36 |   background-color: currentColor;
 37 |   border: 0;
 38 |   opacity: 0.25;
 39 | }
 40 | 
 41 | hr:not([size]) {
 42 |   height: 1px;
 43 | }
 44 | 
 45 | h6, h5, h4, h3, h2, h1 {
 46 |   margin-top: 0;
 47 |   margin-bottom: 0.5rem;
 48 |   font-weight: 500;
 49 |   line-height: 1.2;
 50 | }
 51 | 
 52 | h1 {
 53 |   font-size: calc(1.375rem + 1.5vw);
 54 | }
 55 | @media (min-width: 1200px) {
 56 |   h1 {
 57 |     font-size: 2.5rem;
 58 |   }
 59 | }
 60 | 
 61 | h2 {
 62 |   font-size: calc(1.325rem + 0.9vw);
 63 | }
 64 | @media (min-width: 1200px) {
 65 |   h2 {
 66 |     font-size: 2rem;
 67 |   }
 68 | }
 69 | 
 70 | h3 {
 71 |   font-size: calc(1.3rem + 0.6vw);
 72 | }
 73 | @media (min-width: 1200px) {
 74 |   h3 {
 75 |     font-size: 1.75rem;
 76 |   }
 77 | }
 78 | 
 79 | h4 {
 80 |   font-size: calc(1.275rem + 0.3vw);
 81 | }
 82 | @media (min-width: 1200px) {
 83 |   h4 {
 84 |     font-size: 1.5rem;
 85 |   }
 86 | }
 87 | 
 88 | h5 {
 89 |   font-size: 1.25rem;
 90 | }
 91 | 
 92 | h6 {
 93 |   font-size: 1rem;
 94 | }
 95 | 
 96 | p {
 97 |   margin-top: 0;
 98 |   margin-bottom: 1rem;
 99 | }
100 | 
101 | abbr[title],
102 | abbr[data-bs-original-title] {
103 |   -webkit-text-decoration: underline dotted;
104 |   text-decoration: underline dotted;
105 |   cursor: help;
106 |   -webkit-text-decoration-skip-ink: none;
107 |   text-decoration-skip-ink: none;
108 | }
109 | 
110 | address {
111 |   margin-bottom: 1rem;
112 |   font-style: normal;
113 |   line-height: inherit;
114 | }
115 | 
116 | ol,
117 | ul {
118 |   padding-left: 2rem;
119 | }
120 | 
121 | ol,
122 | ul,
123 | dl {
124 |   margin-top: 0;
125 |   margin-bottom: 1rem;
126 | }
127 | 
128 | ol ol,
129 | ul ul,
130 | ol ul,
131 | ul ol {
132 |   margin-bottom: 0;
133 | }
134 | 
135 | dt {
136 |   font-weight: 700;
137 | }
138 | 
139 | dd {
140 |   margin-bottom: 0.5rem;
141 |   margin-left: 0;
142 | }
143 | 
144 | blockquote {
145 |   margin: 0 0 1rem;
146 | }
147 | 
148 | b,
149 | strong {
150 |   font-weight: bolder;
151 | }
152 | 
153 | small {
154 |   font-size: 0.875em;
155 | }
156 | 
157 | mark {
158 |   padding: 0.2em;
159 |   background-color: #fcf8e3;
160 | }
161 | 
162 | sub,
163 | sup {
164 |   position: relative;
165 |   font-size: 0.75em;
166 |   line-height: 0;
167 |   vertical-align: baseline;
168 | }
169 | 
170 | sub {
171 |   bottom: -0.25em;
172 | }
173 | 
174 | sup {
175 |   top: -0.5em;
176 | }
177 | 
178 | a {
179 |   color: #0d6efd;
180 |   text-decoration: underline;
181 | }
182 | a:hover {
183 |   color: #0a58ca;
184 | }
185 | 
186 | a:not([href]):not([class]), a:not([href]):not([class]):hover {
187 |   color: inherit;
188 |   text-decoration: none;
189 | }
190 | 
191 | pre,
192 | code,
193 | kbd,
194 | samp {
195 |   font-family: SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
196 |   font-size: 1em;
197 |   direction: ltr /* rtl:ignore */;
198 |   unicode-bidi: bidi-override;
199 | }
200 | 
201 | pre {
202 |   display: block;
203 |   margin-top: 0;
204 |   margin-bottom: 1rem;
205 |   overflow: auto;
206 |   font-size: 0.875em;
207 | }
208 | pre code {
209 |   font-size: inherit;
210 |   color: inherit;
211 |   word-break: normal;
212 | }
213 | 
214 | code {
215 |   font-size: 0.875em;
216 |   color: #d63384;
217 |   word-wrap: break-word;
218 | }
219 | a > code {
220 |   color: inherit;
221 | }
222 | 
223 | kbd {
224 |   padding: 0.2rem 0.4rem;
225 |   font-size: 0.875em;
226 |   color: #fff;
227 |   background-color: #212529;
228 |   border-radius: 0.2rem;
229 | }
230 | kbd kbd {
231 |   padding: 0;
232 |   font-size: 1em;
233 |   font-weight: 700;
234 | }
235 | 
236 | figure {
237 |   margin: 0 0 1rem;
238 | }
239 | 
240 | img,
241 | svg {
242 |   vertical-align: middle;
243 | }
244 | 
245 | table {
246 |   caption-side: bottom;
247 |   border-collapse: collapse;
248 | }
249 | 
250 | caption {
251 |   padding-top: 0.5rem;
252 |   padding-bottom: 0.5rem;
253 |   color: #6c757d;
254 |   text-align: left;
255 | }
256 | 
257 | th {
258 |   text-align: inherit;
259 |   text-align: -webkit-match-parent;
260 | }
261 | 
262 | thead,
263 | tbody,
264 | tfoot,
265 | tr,
266 | td,
267 | th {
268 |   border-color: inherit;
269 |   border-style: solid;
270 |   border-width: 0;
271 | }
272 | 
273 | label {
274 |   display: inline-block;
275 | }
276 | 
277 | button {
278 |   border-radius: 0;
279 | }
280 | 
281 | button:focus:not(:focus-visible) {
282 |   outline: 0;
283 | }
284 | 
285 | input,
286 | button,
287 | select,
288 | optgroup,
289 | textarea {
290 |   margin: 0;
291 |   font-family: inherit;
292 |   font-size: inherit;
293 |   line-height: inherit;
294 | }
295 | 
296 | button,
297 | select {
298 |   text-transform: none;
299 | }
300 | 
301 | [role=button] {
302 |   cursor: pointer;
303 | }
304 | 
305 | select {
306 |   word-wrap: normal;
307 | }
308 | select:disabled {
309 |   opacity: 1;
310 | }
311 | 
312 | [list]::-webkit-calendar-picker-indicator {
313 |   display: none;
314 | }
315 | 
316 | button,
317 | [type=button],
318 | [type=reset],
319 | [type=submit] {
320 |   -webkit-appearance: button;
321 | }
322 | button:not(:disabled),
323 | [type=button]:not(:disabled),
324 | [type=reset]:not(:disabled),
325 | [type=submit]:not(:disabled) {
326 |   cursor: pointer;
327 | }
328 | 
329 | ::-moz-focus-inner {
330 |   padding: 0;
331 |   border-style: none;
332 | }
333 | 
334 | textarea {
335 |   resize: vertical;
336 | }
337 | 
338 | fieldset {
339 |   min-width: 0;
340 |   padding: 0;
341 |   margin: 0;
342 |   border: 0;
343 | }
344 | 
345 | legend {
346 |   float: left;
347 |   width: 100%;
348 |   padding: 0;
349 |   margin-bottom: 0.5rem;
350 |   font-size: calc(1.275rem + 0.3vw);
351 |   line-height: inherit;
352 | }
353 | @media (min-width: 1200px) {
354 |   legend {
355 |     font-size: 1.5rem;
356 |   }
357 | }
358 | legend + * {
359 |   clear: left;
360 | }
361 | 
362 | ::-webkit-datetime-edit-fields-wrapper,
363 | ::-webkit-datetime-edit-text,
364 | ::-webkit-datetime-edit-minute,
365 | ::-webkit-datetime-edit-hour-field,
366 | ::-webkit-datetime-edit-day-field,
367 | ::-webkit-datetime-edit-month-field,
368 | ::-webkit-datetime-edit-year-field {
369 |   padding: 0;
370 | }
371 | 
372 | ::-webkit-inner-spin-button {
373 |   height: auto;
374 | }
375 | 
376 | [type=search] {
377 |   outline-offset: -2px;
378 |   -webkit-appearance: textfield;
379 | }
380 | 
381 | /* rtl:raw:
382 | [type="tel"],
383 | [type="url"],
384 | [type="email"],
385 | [type="number"] {
386 |   direction: ltr;
387 | }
388 | */
389 | ::-webkit-search-decoration {
390 |   -webkit-appearance: none;
391 | }
392 | 
393 | ::-webkit-color-swatch-wrapper {
394 |   padding: 0;
395 | }
396 | 
397 | ::file-selector-button {
398 |   font: inherit;
399 | }
400 | 
401 | ::-webkit-file-upload-button {
402 |   font: inherit;
403 |   -webkit-appearance: button;
404 | }
405 | 
406 | output {
407 |   display: inline-block;
408 | }
409 | 
410 | iframe {
411 |   border: 0;
412 | }
413 | 
414 | summary {
415 |   display: list-item;
416 |   cursor: pointer;
417 | }
418 | 
419 | progress {
420 |   vertical-align: baseline;
421 | }
422 | 
423 | [hidden] {
424 |   display: none !important;
425 | }
426 | 
427 | /*# sourceMappingURL=bootstrap-reboot.css.map */


--------------------------------------------------------------------------------
/database/postgres/00_aspnet_core_identity.sql:
--------------------------------------------------------------------------------
  1 | -- sequence: public.snow_flake_id_seq
  2 | 
  3 | -- drop sequence public.snow_flake_id_seq;
  4 | 
  5 | create sequence public.snow_flake_id_seq;
  6 | 
  7 | alter sequence public.snow_flake_id_seq
  8 |     owner to postgres;
  9 | 
 10 | -- function: public.snow_flake_id()
 11 | 
 12 | -- drop function public.snow_flake_id();
 13 | 
 14 | create or replace function public.snow_flake_id()
 15 |     returns bigint
 16 |     language 'sql'
 17 |     cost 100
 18 |     volatile
 19 | as $body$
 20 | 
 21 | select (extract(epoch from current_timestamp) * 1000)::bigint * 1000000
 22 |   + 2 * 10000
 23 |   + nextval('public.snow_flake_id_seq') % 1000
 24 |   as snow_flake_id
 25 | 
 26 | $body$;
 27 | 
 28 | alter function public.snow_flake_id()
 29 |     owner to postgres;
 30 | 
 31 | comment on function public.snow_flake_id()
 32 |     is 'snow flake id ';
 33 | 
 34 | -- table: public.aspnet_roles
 35 | 
 36 | -- drop table public.aspnet_roles;
 37 | 
 38 | create table public.aspnet_roles
 39 | (
 40 |     id character varying(32) collate pg_catalog."default" not null default (snow_flake_id())::character varying,
 41 |     name character varying(64) collate pg_catalog."default" not null,
 42 |     normalized_name character varying(64) collate pg_catalog."default" not null,
 43 |     concurrency_stamp character varying(36) collate pg_catalog."default",
 44 |     constraint pk_aspnet_roles primary key (id),
 45 |     constraint u_aspnet_roles_name unique (name),
 46 |     constraint u_aspnet_roles_normalized_name unique (normalized_name)
 47 | )
 48 | with (
 49 |     oids = false
 50 | )
 51 | tablespace pg_default;
 52 | 
 53 | alter table public.aspnet_roles
 54 |     owner to postgres;
 55 | 
 56 | -- index: ix_aspnet_roles_name
 57 | 
 58 | -- drop index public.ix_aspnet_roles_name;
 59 | 
 60 | create index ix_aspnet_roles_name
 61 |     on public.aspnet_roles using btree
 62 |     (normalized_name collate pg_catalog."default")
 63 |     tablespace pg_default;
 64 | 
 65 | -- table: public.aspnet_role_claims
 66 | 
 67 | -- drop table public.aspnet_role_claims;
 68 | 
 69 | create table public.aspnet_role_claims
 70 | (
 71 |     id integer not null default nextval('snow_flake_id_seq'::regclass),
 72 |     role_id character varying(32) collate pg_catalog."default" not null,
 73 |     claim_type character varying(1024) collate pg_catalog."default" not null,
 74 |     claim_value character varying(1024) collate pg_catalog."default" not null,
 75 |     constraint pk_aspnet_role_claims primary key (id),
 76 |     constraint fk_aspnet_roles_id foreign key (role_id)
 77 |         references public.aspnet_roles (id) match simple
 78 |         on update cascade
 79 |         on delete cascade
 80 | )
 81 | with (
 82 |     oids = false
 83 | )
 84 | tablespace pg_default;
 85 | 
 86 | alter table public.aspnet_role_claims
 87 |     owner to postgres;
 88 | comment on table public.aspnet_role_claims
 89 |     is 'aspnet role claims table';
 90 | 
 91 | -- index: ix_aspnet_role_claims_role_id
 92 | 
 93 | -- drop index public.ix_aspnet_role_claims_role_id;
 94 | 
 95 | create index ix_aspnet_role_claims_role_id
 96 |     on public.aspnet_role_claims using btree
 97 |     (role_id collate pg_catalog."default")
 98 |     tablespace pg_default;
 99 | 
100 | -- table: public.aspnet_users
101 | 
102 | -- drop table public.aspnet_users;
103 | 
104 | create table public.aspnet_users
105 | (
106 |     id character varying(32) collate pg_catalog."default" not null default (snow_flake_id())::character varying,
107 |     user_name character varying(64) collate pg_catalog."default" not null,
108 |     normalized_user_name character varying(64) collate pg_catalog."default" not null,
109 |     email character varying(256) collate pg_catalog."default" not null,
110 |     normalized_email character varying(256) collate pg_catalog."default" not null,
111 |     email_confirmed boolean not null,
112 |     password_hash character varying(256) collate pg_catalog."default",
113 |     security_stamp character varying(256) collate pg_catalog."default",
114 |     concurrency_stamp character varying(36) collate pg_catalog."default",
115 |     phone_number character varying(32) collate pg_catalog."default",
116 |     phone_number_confirmed boolean not null,
117 |     two_factor_enabled boolean not null,
118 |     lockout_end_unix_time_seconds bigint,
119 |     lockout_enabled boolean not null,
120 |     access_failed_count integer not null,
121 |     constraint pk_aspnet_users primary key (id),
122 |     constraint u_aspnet_users_normalized_user_name unique (normalized_user_name),
123 |     constraint u_aspnet_users_username unique (user_name)
124 | )
125 | with (
126 |     oids = false
127 | )
128 | tablespace pg_default;
129 | 
130 | alter table public.aspnet_users
131 |     owner to postgres;
132 | comment on table public.aspnet_users
133 |     is 'aspnet users table.';
134 | 
135 | -- index: ix_aspnet_users_email
136 | 
137 | -- drop index public.ix_aspnet_users_email;
138 | 
139 | create index ix_aspnet_users_email
140 |     on public.aspnet_users using btree
141 |     (normalized_email collate pg_catalog."default")
142 |     tablespace pg_default;
143 | 
144 | -- index: ix_aspnet_users_user_name
145 | 
146 | -- drop index public.ix_aspnet_users_user_name;
147 | 
148 | create unique index ix_aspnet_users_user_name
149 |     on public.aspnet_users using btree
150 |     (normalized_user_name collate pg_catalog."default")
151 |     tablespace pg_default;
152 | 
153 | -- table: public.aspnet_user_claims
154 | 
155 | -- drop table public.aspnet_user_claims;
156 | 
157 | create table public.aspnet_user_claims
158 | (
159 |     id integer not null default nextval('snow_flake_id_seq'::regclass),
160 |     user_id character varying(32) collate pg_catalog."default" not null,
161 |     claim_type character varying(1024) collate pg_catalog."default" not null,
162 |     claim_value character varying(1024) collate pg_catalog."default" not null,
163 |     constraint pk_aspnet_user_claims primary key (id),
164 |     constraint fk_aspnet_users_id foreign key (user_id)
165 |         references public.aspnet_users (id) match simple
166 |         on update cascade
167 |         on delete cascade
168 | )
169 | with (
170 |     oids = false
171 | )
172 | tablespace pg_default;
173 | 
174 | alter table public.aspnet_user_claims
175 |     owner to postgres;
176 | comment on table public.aspnet_user_claims
177 |     is 'aspnet user claims table';
178 | 
179 | -- index: ix_aspnet_user_claims_user_id
180 | 
181 | -- drop index public.ix_aspnet_user_claims_user_id;
182 | 
183 | create index ix_aspnet_user_claims_user_id
184 |     on public.aspnet_user_claims using btree
185 |     (user_id collate pg_catalog."default")
186 |     tablespace pg_default;
187 | 
188 | -- table: public.aspnet_user_logins
189 | 
190 | -- drop table public.aspnet_user_logins;
191 | 
192 | create table public.aspnet_user_logins
193 | (
194 |     login_provider character varying(32) collate pg_catalog."default" not null,
195 |     provider_key character varying(1024) collate pg_catalog."default" not null,
196 |     provider_display_name character varying(32) collate pg_catalog."default" not null,
197 |     user_id character varying(32) collate pg_catalog."default" not null,
198 |     constraint pk_aspnet_user_logins primary key (login_provider, provider_key),
199 |     constraint fk_aspnet_user_logins_user_id foreign key (user_id)
200 |         references public.aspnet_users (id) match simple
201 |         on update cascade
202 |         on delete cascade
203 | )
204 | with (
205 |     oids = false
206 | )
207 | tablespace pg_default;
208 | 
209 | alter table public.aspnet_user_logins
210 |     owner to postgres;
211 | comment on table public.aspnet_user_logins
212 |     is 'aspnet user logins table.';
213 | 
214 | -- index: ix_aspnet_user_logins_user_id
215 | 
216 | -- drop index public.ix_aspnet_user_logins_user_id;
217 | 
218 | create index ix_aspnet_user_logins_user_id
219 |     on public.aspnet_user_logins using btree
220 |     (user_id collate pg_catalog."default")
221 |     tablespace pg_default;
222 | 
223 | -- table: public.aspnet_user_tokens
224 | 
225 | -- drop table public.aspnet_user_tokens;
226 | 
227 | create table public.aspnet_user_tokens
228 | (
229 |     user_id character varying(32) collate pg_catalog."default" not null,
230 |     login_provider character varying(32) collate pg_catalog."default" not null,
231 |     name character varying(32) collate pg_catalog."default" not null,
232 |     value character varying(256) collate pg_catalog."default",
233 |     constraint pk_aspnet_user_tokens primary key (user_id, login_provider, name),
234 |     constraint fk_aspnet_users_id foreign key (user_id)
235 |         references public.aspnet_users (id) match simple
236 |         on update cascade
237 |         on delete cascade
238 | )
239 | with (
240 |     oids = false
241 | )
242 | tablespace pg_default;
243 | 
244 | alter table public.aspnet_user_tokens
245 |     owner to postgres;
246 | comment on table public.aspnet_user_tokens
247 |     is 'aspnet user tokens table.';
248 | 
249 | -- index: ix_aspnet_user_tokens_user_id
250 | 
251 | -- drop index public.ix_aspnet_user_tokens_user_id;
252 | 
253 | create index ix_aspnet_user_tokens_user_id
254 |     on public.aspnet_user_tokens using btree
255 |     (user_id collate pg_catalog."default")
256 |     tablespace pg_default;
257 | 
258 | -- table: public.aspnet_user_roles
259 | 
260 | -- drop table public.aspnet_user_roles;
261 | 
262 | create table public.aspnet_user_roles
263 | (
264 |     user_id character varying(32) collate pg_catalog."default" not null,
265 |     role_id character varying(32) collate pg_catalog."default" not null,
266 |     constraint pk_aspnet_user_roles primary key (user_id, role_id),
267 |     constraint fk_aspnet_roles_id foreign key (role_id)
268 |         references public.aspnet_roles (id) match simple
269 |         on update cascade
270 |         on delete cascade,
271 |     constraint fk_aspnet_users_id foreign key (user_id)
272 |         references public.aspnet_users (id) match simple
273 |         on update cascade
274 |         on delete cascade
275 | )
276 | with (
277 |     oids = false
278 | )
279 | tablespace pg_default;
280 | 
281 | alter table public.aspnet_user_roles
282 |     owner to postgres;
283 | comment on table public.aspnet_user_roles
284 |     is 'aspnet user roles relation table.';
285 | 
286 | -- index: ix_aspnet_user_roles_role_id
287 | 
288 | -- drop index public.ix_aspnet_user_roles_role_id;
289 | 
290 | create index ix_aspnet_user_roles_role_id
291 |     on public.aspnet_user_roles using btree
292 |     (role_id collate pg_catalog."default")
293 |     tablespace pg_default;
294 | 
295 | -- index: ix_aspnet_user_roles_user_id
296 | 
297 | -- drop index public.ix_aspnet_user_roles_user_id;
298 | 
299 | create index ix_aspnet_user_roles_user_id
300 |     on public.aspnet_user_roles using btree
301 |     (user_id collate pg_catalog."default")
302 |     tablespace pg_default;
303 | 


--------------------------------------------------------------------------------
/src/NHibernate.AspNetCore.Identity/UserOnlyStore.cs:
--------------------------------------------------------------------------------
  1 | using System.Security.Claims;
  2 | using Microsoft.AspNetCore.Identity;
  3 | using NHibernate.Linq;
  4 | 
  5 | namespace NHibernate.AspNetCore.Identity;
  6 | 
  7 | public class UserOnlyStore<TUser>(
  8 |     ISession session,
  9 |     IdentityErrorDescriber describer
 10 | ) : UserStoreBase<TUser, string, IdentityUserClaim, IdentityUserLogin, IdentityUserToken>(describer),
 11 |     IProtectedUserStore<TUser>
 12 |     where TUser : IdentityUser {
 13 | 
 14 |     public override IQueryable<TUser> Users => session.Query<TUser>();
 15 | 
 16 |     private IQueryable<IdentityUserClaim> UserClaims => session.Query<IdentityUserClaim>();
 17 | 
 18 |     private IQueryable<IdentityUserLogin> UserLogins => session.Query<IdentityUserLogin>();
 19 | 
 20 |     private IQueryable<IdentityUserToken> UserTokens => session.Query<IdentityUserToken>();
 21 | 
 22 |     public override async Task<IdentityResult> CreateAsync(
 23 |         TUser user,
 24 |         CancellationToken cancellationToken = default
 25 |     ) {
 26 |         cancellationToken.ThrowIfCancellationRequested();
 27 |         ThrowIfDisposed();
 28 |         if (user == null) {
 29 |             throw new ArgumentNullException(nameof(user));
 30 |         }
 31 |         await session.SaveAsync(user, cancellationToken);
 32 |         await FlushChangesAsync(cancellationToken);
 33 |         return IdentityResult.Success;
 34 |     }
 35 | 
 36 |     public override async Task<IdentityResult> UpdateAsync(
 37 |         TUser user,
 38 |         CancellationToken cancellationToken = default
 39 |     ) {
 40 |         cancellationToken.ThrowIfCancellationRequested();
 41 |         ThrowIfDisposed();
 42 |         if (user == null) {
 43 |             throw new ArgumentNullException(nameof(user));
 44 |         }
 45 |         var exists = await Users.AnyAsync(
 46 |             u => u.Id.Equals(user.Id),
 47 |             cancellationToken
 48 |         );
 49 |         if (!exists) {
 50 |             return IdentityResult.Failed(
 51 |                 new IdentityError {
 52 |                     Code = "UserNotExist",
 53 |                     Description = $"User with id {user.Id} does not exists!"
 54 |                 }
 55 |             );
 56 |         }
 57 |         user.ConcurrencyStamp = Guid.NewGuid().ToString("N");
 58 |         await session.MergeAsync(user, cancellationToken);
 59 |         await FlushChangesAsync(cancellationToken);
 60 |         return IdentityResult.Success;
 61 |     }
 62 | 
 63 |     public override async Task<IdentityResult> DeleteAsync(
 64 |         TUser user,
 65 |         CancellationToken cancellationToken = default
 66 |     ) {
 67 |         cancellationToken.ThrowIfCancellationRequested();
 68 |         ThrowIfDisposed();
 69 |         if (user == null) {
 70 |             throw new ArgumentNullException(nameof(user));
 71 |         }
 72 |         await session.DeleteAsync(user, cancellationToken);
 73 |         await FlushChangesAsync(cancellationToken);
 74 |         return IdentityResult.Success;
 75 |     }
 76 | 
 77 |     public override async Task<TUser?> FindByIdAsync(
 78 |         string userId,
 79 |         CancellationToken cancellationToken = default
 80 |     ) {
 81 |         cancellationToken.ThrowIfCancellationRequested();
 82 |         ThrowIfDisposed();
 83 |         var id = ConvertIdFromString(userId);
 84 |         var user = await session.GetAsync<TUser>(id, cancellationToken);
 85 |         return user;
 86 |     }
 87 | 
 88 |     public override async Task<TUser?> FindByNameAsync(
 89 |         string normalizedUserName,
 90 |         CancellationToken cancellationToken = default
 91 |     ) {
 92 |         cancellationToken.ThrowIfCancellationRequested();
 93 |         ThrowIfDisposed();
 94 |         var user = await Users.FirstOrDefaultAsync(
 95 |             u => u.NormalizedUserName == normalizedUserName,
 96 |             cancellationToken
 97 |         );
 98 |         return user;
 99 |     }
100 | 
101 |     protected override async Task<TUser?> FindUserAsync(
102 |         string userId,
103 |         CancellationToken cancellationToken
104 |     ) {
105 |         cancellationToken.ThrowIfCancellationRequested();
106 |         ThrowIfDisposed();
107 |         var user = await Users.FirstOrDefaultAsync(
108 |             u => u.Id.Equals(userId),
109 |             cancellationToken
110 |         );
111 |         return user;
112 |     }
113 | 
114 |     protected override async Task<IdentityUserLogin?> FindUserLoginAsync(
115 |         string userId,
116 |         string loginProvider,
117 |         string providerKey,
118 |         CancellationToken cancellationToken
119 |     ) {
120 |         cancellationToken.ThrowIfCancellationRequested();
121 |         ThrowIfDisposed();
122 |         var userLogin = await UserLogins.FirstOrDefaultAsync(
123 |             ul => ul.UserId.Equals(userId) && ul.LoginProvider == loginProvider
124 |                 && ul.ProviderKey == providerKey,
125 |             cancellationToken
126 |         );
127 |         return userLogin;
128 |     }
129 | 
130 |     protected override async Task<IdentityUserLogin?> FindUserLoginAsync(
131 |         string loginProvider,
132 |         string providerKey,
133 |         CancellationToken cancellationToken
134 |     ) {
135 |         cancellationToken.ThrowIfCancellationRequested();
136 |         ThrowIfDisposed();
137 |         var userLogin = await UserLogins.FirstOrDefaultAsync(
138 |             ul => ul.LoginProvider == loginProvider
139 |                 && ul.ProviderKey == providerKey,
140 |             cancellationToken
141 |         );
142 |         return userLogin;
143 |     }
144 | 
145 |     public override async Task<IList<Claim>> GetClaimsAsync(
146 |         TUser user,
147 |         CancellationToken cancellationToken = default
148 |     ) {
149 |         cancellationToken.ThrowIfCancellationRequested();
150 |         ThrowIfDisposed();
151 |         if (user == null) {
152 |             throw new ArgumentNullException(nameof(user));
153 |         }
154 |         var claims = await UserClaims.Where(
155 |                 uc => uc.UserId.Equals(user.Id)
156 |             )
157 |             .Select(c => c.ToClaim())
158 |             .ToListAsync(cancellationToken);
159 |         return claims;
160 |     }
161 | 
162 |     public override async Task AddClaimsAsync(
163 |         TUser user,
164 |         IEnumerable<Claim> claims,
165 |         CancellationToken cancellationToken = default
166 |     ) {
167 |         cancellationToken.ThrowIfCancellationRequested();
168 |         ThrowIfDisposed();
169 |         if (user == null) {
170 |             throw new ArgumentNullException(nameof(user));
171 |         }
172 |         if (claims == null) {
173 |             throw new ArgumentNullException(nameof(claims));
174 |         }
175 |         foreach (var claim in claims) {
176 |             await session.SaveAsync(
177 |                 CreateUserClaim(user, claim),
178 |                 cancellationToken
179 |             );
180 |         }
181 |         await FlushChangesAsync(cancellationToken);
182 |     }
183 | 
184 |     public override async Task ReplaceClaimAsync(
185 |         TUser user,
186 |         Claim claim,
187 |         Claim newClaim,
188 |         CancellationToken cancellationToken = default
189 |     ) {
190 |         cancellationToken.ThrowIfCancellationRequested();
191 |         ThrowIfDisposed();
192 |         if (user == null) {
193 |             throw new ArgumentNullException(nameof(user));
194 |         }
195 |         if (claim == null) {
196 |             throw new ArgumentNullException(nameof(claim));
197 |         }
198 |         if (newClaim == null) {
199 |             throw new ArgumentNullException(nameof(newClaim));
200 |         }
201 |         var matchedClaims = await UserClaims.Where(
202 |                 uc => uc.UserId.Equals(user.Id) &&
203 |                     uc.ClaimValue == claim.Value
204 |                     && uc.ClaimType == claim.Type
205 |             )
206 |             .ToListAsync(cancellationToken);
207 |         foreach (var matchedClaim in matchedClaims) {
208 |             matchedClaim.ClaimType = newClaim.Type;
209 |             matchedClaim.ClaimValue = newClaim.Value;
210 |             await session.UpdateAsync(matchedClaim, cancellationToken);
211 |         }
212 |         await FlushChangesAsync(cancellationToken);
213 |     }
214 | 
215 |     public override async Task RemoveClaimsAsync(
216 |         TUser user,
217 |         IEnumerable<Claim> claims,
218 |         CancellationToken cancellationToken = default
219 |     ) {
220 |         cancellationToken.ThrowIfCancellationRequested();
221 |         ThrowIfDisposed();
222 |         if (user == null) {
223 |             throw new ArgumentNullException(nameof(user));
224 |         }
225 |         if (claims == null) {
226 |             throw new ArgumentNullException(nameof(claims));
227 |         }
228 |         foreach (var claim in claims) {
229 |             var matchedClaims = await UserClaims.Where(
230 |                     uc => uc.UserId.Equals(user.Id) &&
231 |                         uc.ClaimValue == claim.Value
232 |                         && uc.ClaimType == claim.Type
233 |                 )
234 |                 .ToListAsync(cancellationToken);
235 |             foreach (var matchedClaim in matchedClaims) {
236 |                 await session.DeleteAsync(matchedClaim, cancellationToken);
237 |             }
238 |         }
239 |         await FlushChangesAsync(cancellationToken);
240 |     }
241 | 
242 |     public override async Task<IList<TUser>> GetUsersForClaimAsync(
243 |         Claim claim,
244 |         CancellationToken cancellationToken = default
245 |     ) {
246 |         cancellationToken.ThrowIfCancellationRequested();
247 |         ThrowIfDisposed();
248 |         if (claim == null) {
249 |             throw new ArgumentNullException(nameof(claim));
250 |         }
251 |         var query = from userClaims in UserClaims
252 |             join user in Users on userClaims.UserId equals user.Id
253 |             where userClaims.ClaimValue == claim.Value
254 |                 && userClaims.ClaimType == claim.Type
255 |             select user;
256 |         return await query.ToListAsync(cancellationToken);
257 |     }
258 | 
259 |     protected override async Task<IdentityUserToken?> FindTokenAsync(
260 |         TUser user,
261 |         string loginProvider,
262 |         string name,
263 |         CancellationToken cancellationToken
264 |     ) {
265 |         cancellationToken.ThrowIfCancellationRequested();
266 |         ThrowIfDisposed();
267 |         if (user == null) {
268 |             throw new ArgumentNullException(nameof(user));
269 |         }
270 |         var token = await UserTokens.FirstOrDefaultAsync(
271 |             ut => ut.UserId.Equals(user.Id) &&
272 |                 ut.LoginProvider == loginProvider
273 |                 && ut.Name == name,
274 |             cancellationToken);
275 |         return token;
276 |     }
277 | 
278 |     protected override async Task AddUserTokenAsync(
279 |         IdentityUserToken token
280 |     ) {
281 |         ThrowIfDisposed();
282 |         if (token == null) {
283 |             throw new ArgumentNullException(nameof(token));
284 |         }
285 |         await session.SaveAsync(token);
286 |         await FlushChangesAsync();
287 |     }
288 | 
289 |     protected override async Task RemoveUserTokenAsync(
290 |         IdentityUserToken token
291 |     ) {
292 |         ThrowIfDisposed();
293 |         if (token == null) {
294 |             throw new ArgumentNullException(nameof(token));
295 |         }
296 |         await session.DeleteAsync(token);
297 |         await FlushChangesAsync();
298 |     }
299 | 
300 |     public override async Task AddLoginAsync(
301 |         TUser user,
302 |         UserLoginInfo login,
303 |         CancellationToken cancellationToken = default
304 |     ) {
305 |         cancellationToken.ThrowIfCancellationRequested();
306 |         ThrowIfDisposed();
307 |         if (user == null) {
308 |             throw new ArgumentNullException(nameof(user));
309 |         }
310 |         if (login == null) {
311 |             throw new ArgumentNullException(nameof(login));
312 |         }
313 |         await session.SaveAsync(
314 |             CreateUserLogin(user, login),
315 |             cancellationToken
316 |         );
317 |         await FlushChangesAsync(cancellationToken);
318 |     }
319 | 
320 |     public override async Task RemoveLoginAsync(
321 |         TUser user,
322 |         string loginProvider,
323 |         string providerKey,
324 |         CancellationToken cancellationToken = default
325 |     ) {
326 |         cancellationToken.ThrowIfCancellationRequested();
327 |         ThrowIfDisposed();
328 |         if (user == null) {
329 |             throw new ArgumentNullException(nameof(user));
330 |         }
331 |         var login = await FindUserLoginAsync(
332 |             user.Id,
333 |             loginProvider,
334 |             providerKey,
335 |             cancellationToken
336 |         );
337 |         if (login != null) {
338 |             await session.DeleteAsync(login, cancellationToken);
339 |         }
340 |     }
341 | 
342 |     public override async Task<IList<UserLoginInfo>> GetLoginsAsync(
343 |         TUser user,
344 |         CancellationToken cancellationToken = default
345 |     ) {
346 |         cancellationToken.ThrowIfCancellationRequested();
347 |         ThrowIfDisposed();
348 |         if (user == null) {
349 |             throw new ArgumentNullException(nameof(user));
350 |         }
351 |         var userId = user.Id;
352 |         var logins = await UserLogins.Where(l => l.UserId.Equals(userId))
353 |             .Select(
354 |                 l => new UserLoginInfo(
355 |                     l.LoginProvider,
356 |                     l.ProviderKey,
357 |                     l.ProviderDisplayName
358 |                 )
359 |             )
360 |             .ToListAsync(cancellationToken);
361 |         return logins;
362 |     }
363 | 
364 |     public override async Task<TUser?> FindByEmailAsync(
365 |         string normalizedEmail,
366 |         CancellationToken cancellationToken = default
367 |     ) {
368 |         cancellationToken.ThrowIfCancellationRequested();
369 |         ThrowIfDisposed();
370 |         return await Users.FirstOrDefaultAsync(
371 |             u => u.NormalizedEmail == normalizedEmail,
372 |             cancellationToken
373 |         );
374 |     }
375 | 
376 |     private async Task FlushChangesAsync(
377 |         CancellationToken cancellationToken = default
378 |     ) {
379 |         await session.FlushAsync(cancellationToken);
380 |         session.Clear();
381 |     }
382 | 
383 | }
384 | 


--------------------------------------------------------------------------------