Identity.Dapper - GitLite

KO | EN

gitlite — search

#hacktoberfest #go #android #machine-learning #rust #nodejs #java #awesome #kubernetes #vue #awesome-list #ios #openai #open-source

Identity.Dapper

(★ 268)

Identity package that uses Dapper instead EntityFramework for use with .NET Core

File Explorer

Download Latest Version (.zip)

- - .bowerrc
  - appsettings.json
  - bower.json
  - gulpfile.js
  - Identity.Dapper.Samples.Web.csproj
  - package.json
  - Program.cs
  - runtimeconfig.template.json
  - Startup.cs
  - web.config
- - Identity.Dapper.csproj
- - Identity.Dapper.MySQL.csproj
- - Identity.Dapper.PostgreSQL.csproj
- - Identity.Dapper.SqlServer.csproj
- - Identity.Dapper.Tests.csproj
- - connectionstringswithdefaultconnectionconfig.json
  - connectionstringswithoutdefaultconnectionconfig.json
  - dapperidentityconfig.json
  - emptyconfig.json
  - FakeAuthMessageSender.cs
  - Identity.Dapper.Tests.Integration.csproj
  - integrationtest.config.mysql.json
  - integrationtest.config.psql.json
  - integrationtest.config.sqlserver.json
  - PrioritizedFixtureAttribute.cs
  - ServiceCollectionTests.cs
.gitattributes
.gitignore
.travis.yml
Identity.Dapper.sln
IdentityTablesMySql.sql
IdentityTablesPostgreSql.sql
IdentityTablesSqlServer.sql
LICENSE
README.md
TODO.txt

# Installation Guide

1. Get the code

git clone https://github.com/grandchamp/Identity.Dapper

Downloads the entire project code from GitHub to your computer.

cd Identity.Dapper

Moves into the project folder you just downloaded.

2. .NET

Medium Recommended

Prerequisites

Git Needed to download the project code from GitHub.
.NET SDK The SDK required for the dotnet command.

dotnet user-secrets set DapperIdentity:ConnectionString "Connection string of your database"

Type this command into your terminal and run it.

dotnet user-secrets set DapperIdentity:Password "123"

Type this command into your terminal and run it.

dotnet user-secrets set DapperIdentity:Username "user"

Type this command into your terminal and run it.

dotnet user-secrets set DapperIdentityCryptography:Key "Base64 32 bytes key"

Type this command into your terminal and run it.

dotnet user-secrets set DapperIdentityCryptography:IV "Base64 16 bytes key"

Type this command into your terminal and run it.

✅ After dotnet run, check the message or address shown in the terminal.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Identity.Dapper

[![Build Status](https://travis-ci.org/grandchamp/Identity.Dapper.svg?branch=master)](https://travis-ci.org/grandchamp/Identity.Dapper)
[![NuGet](https://img.shields.io/nuget/v/Identity.Dapper.svg?style=flat)](https://www.nuget.org/packages/Identity.Dapper/)

Find the corresponding NuGet package for your DBMS (Eg: Identity.Dapper.SqlServer).

To configure the DBMS connection, you can add a **DapperIdentity** and a **DapperIdentityCryptography** section to your configuration file like this:
```JSON
"DapperIdentity": {
    "ConnectionString": "Connection string of your database",
    "Username": "user",
    "Password": "123"
},
"DapperIdentityCryptography": {
    "Key": "Base64 32 bytes key",
    "IV": "Base64 16 bytes key"
}
```

**Example:**  
Key: "E546C8DF278CD5931069B522E695D4F2" (32 Bytes)  
Base64 Encoded Key: "RTU0NkM4REYyNzhDRDU5MzEwNjlCNTIyRTY5NUQ0RjI="

IV: "SomeReallyCoolIV" (16 Bytes)  
Base64 Encoded IV: "U29tZVJlYWxseUNvb2xJVg=="

Alternatively, you can use **ConnectionStrings** default section:

```JSON
"ConnectionStrings": {
    "DefaultConnection": "Connection string of your database"
}
```

Or you can use the User Secrets commands:
```
dotnet user-secrets set DapperIdentity:ConnectionString "Connection string of your database"
dotnet user-secrets set DapperIdentity:Password "123"
dotnet user-secrets set DapperIdentity:Username "user"

dotnet user-secrets set DapperIdentityCryptography:Key "Base64 32 bytes key"
dotnet user-secrets set DapperIdentityCryptography:IV "Base64 16 bytes key"
```

The **DapperIdentity:Password** can be encrypted with AES256 using the KEY and IV provided.

On **Startup.cs** file, go to **ConfigureServices** and add the following lines:
```csharp
services.ConfigureDapperConnectionProvider<T>(Configuration.GetSection("DapperIdentity"))
        .ConfigureDapperIdentityCryptography(Configuration.GetSection("DapperIdentityCryptography"));

services.AddIdentity<DapperIdentityUser, DapperIdentityRole<int>>()
        .AddDapperIdentityFor<T>()
        .AddDefaultTokenProviders();
```

or

```csharp
services.ConfigureDapperConnectionProvider<T>(Configuration.GetSection("ConnectionStrings"))
```

Where ***T*** for the method ```ConfigureDapperConnectionProvider``` is ```DBMSNameConnectionProvider``` (eg: ```SqlServerConnectionProvider```) and ***T*** for the method ```AddDapperIdentityFor``` is ```DBMSNameConfiguration``` (eg: ```SqlServerConfiguration```).

If you want to use Transactions to all methods of Identity, you'll have to add `.ConfigureDapperIdentityOptions(new DapperIdentityOptions { UseTransactionalBehavior = true })` below `ConfigureDapperIdentityCryptography(Configuration.GetSection("DapperIdentityCryptography"));`

And inside your controller, you'll have to insert on constructor a `DapperUserStore<TUser, TKey, TUserRole, TRoleClaim, TUserClaim, TUserLogin, TRole>` variable, like this:

```csharp
private readonly DapperUserStore<CustomUser, int, DapperIdentityUserRole<int>, DapperIdentityRoleClaim<int>, DapperIdentityUserClaim<int>, DapperIdentityUserLogin<int>, CustomRole> _dapperStore;

...

public ManageController(IUserStore<CustomUser> dapperStore)
        {
            _dapperStore = dapperStore as DapperUserStore<CustomUser, int, DapperIdentityUserRole<int>, DapperIdentityRoleClaim<int>, DapperIdentityUserClaim<int>, DapperIdentityUserLogin<int>, CustomRole>;
        }
```

And after all operations, you'll have to call `DapperUserStore.SaveChanges()` method, otherwise your changes will be rollbacked.

Currently, only SQL Server, PostgreSQL and MySQL are supported. We plan support for Oracle when the company release the .NET Core version for their System.Data implementation.

## Using Guid as Entity key
Specify the <TKey>
```csharp
services.AddIdentity<DapperIdentityUser<Guid>, DapperIdentityRole<Guid>>()
        .AddDapperIdentityFor<T, Guid>();
```

## Changing the default schema (SqlServer)

Pass a custom class that inherits from ```SqlServerConfiguration``` (or other)

```csharp
public class CustomSqlServerConfiguration : SqlServerConfiguration
{
    public CustomSqlServerConfiguration()
    {
        base.SchemaName = "[customSchema]";
    }
}
```

And add it with
```csharp
services.AddDapperIdentityFor<CustomSqlServerConfiguration>()
```