DEV Community: Gabriel Barcelos | C#, AspNetCore, ReactJS

Notion + React + Blog: best libs and posts

Gabriel Barcelos | C#, AspNetCore, ReactJS — Thu, 22 Apr 2021 01:04:31 +0000

Here i´ll list libs and posts related to using Notion as a CMS for static generated blogs.

Libs

1. React-Notion-X

https://github.com/NotionX/react-notion-x

2. Notion Oficial API

https://developers.notion.com/

Posts

1. SpencerWoo´s Blog

https://github.com/spencerwooo/react-notion-blog
https://blog.spencerwoo.com/2021/02/nextjs-blog-notion

2. samuelkraft / notion-blog-nextjs

Next.js example blog powered by Notion Official Public API
https://github.com/samuelkraft/notion-blog-nextjs

3. transitive-bullshit/nextjs-notion-starter-kit

Deploy your own Notion-powered website in minutes with Next.js and Vercel.
https://github.com/transitive-bullshit/nextjs-notion-starter-kit

4. Daniel Wirtz

Daniel Wirtz personal website built with Chakra UI, NextJS and Airtable.
https://github.com/wirtzdan/website

Identity Server 4 and RavenDb 5: Resource store

Gabriel Barcelos | C#, AspNetCore, ReactJS — Fri, 20 Nov 2020 15:02:29 +0000

When deploying an identity server to production, it's recommended to port Identity Resources, Api Scopes and Clients to a database.

This was my strategy:

Identity configuration, is prepared at runtime, by a specific class named IdentityClientAndResourcesSeedData.
In host startup, I execute an method that initialises database with initial data.
Seed class deletes old data, and recreates. Doing so, if configuration changed in appSettings.json, changes will be applied into database.
Creating custom data store classes.
Modifying Identity Server registration: stores included.
Modifying RavenDB conventions, to deal with IdentityResources.OpenId, IdentityResources.Profile, IdentityResources.Email.

1. Identity configuration class:

public class IdentityClientAndResourcesSeedData
    {
        public static IEnumerable<IdentityResource> GetIdentityResources()
        {
            return new List<IdentityResource>
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile(),
                new IdentityResources.Email()
            };
        }

        public static IEnumerable<ApiResource> GetApiResources()
        {
            return new List<ApiResource>
            {
                new ApiResource("myApi", "API BACKEND")
                {
                    Scopes = new List<string>()
                    {
                        "myApi"
                    }
                }
            };
        }

        public static IEnumerable<ApiScope> GetApiScopes()
        {
            return new[]
            {
                new ApiScope(name: "myApi.access", displayName: "Acessar API")
            };
        }

        // clients want to access resources (aka scopes)
        public static IEnumerable<Client> GetMainClients(IConfiguration configuration)
        {
            var clientList = new List<Client>();

            /* Config MVC Client */
            var mvcClientConfig = new IdentityServerClientConfig();
            configuration.Bind("IdentityServerClients:MvcClient", mvcClientConfig);

            clientList.Add(
                // OpenID Connect hybrid flow client (MVC)
                new Client
                {
                    ClientId = mvcClientConfig,
                    ClientName = MVCClient",
                    AllowedGrantTypes = GrantTypes.Code,

                    ClientSecrets = {new Secret(mvcClientConfig.ClientSecret.Sha256())},

                    RedirectUris = {$"{mvcClientConfig.ClientUrl}/signin-oidc"},
                    PostLogoutRedirectUris =
                        {$"{mvcClientConfig.ClientUrl}/signout-callback-oidc"},
                    RequireConsent = false,
                    RequirePkce = false,

                    AllowedScopes =
                    {
                        IdentityServerConstants.StandardScopes.OpenId,
                        IdentityServerConstants.StandardScopes.Profile,
                        IdentityServerConstants.StandardScopes.Email,
                        "myApi.access",
                        "offline_access"
                    },
                    AllowOfflineAccess = true
                }
            );

// ... insert other necessary clients here

            return clientList;
        }
    }

2. Program.cs:

var hostBuilded = CreateWebHostBuilder(args)
                    .Build();

// Tip from: https://dotnetthoughts.net/seed-database-in-aspnet-core/
using (var scope = hostBuilded.Services.CreateScope())
{
   Log.Information("DATA SEED: will start!");
   DataSeeder.Initialize(scope.ServiceProvider).Wait();
   Log.Information("DATA SEED: ended.");
}

hostBuilded.Run();

3. Seed:

public static class DataSeeder
    {
        public static async Task Initialize(IServiceProvider serviceProvider)
        {
            var configuration = serviceProvider.GetRequiredService<IConfiguration>();
            using var dbSession = serviceProvider.GetRequiredService<IAsyncDocumentSession>();

            // 1. Identity Resources
            var identityResourcesToSeed =
                IdentityClientAndResourcesSeedData.GetIdentityResources();

            foreach (var item in identityResourcesToSeed)
            {
                var preExistingItem = await dbSession.Query<IdentityResource>()
                    .Where(wh => wh.Name == item.Name)
                    .FirstOrDefaultAsync();

                if (preExistingItem != null)
                {
                    // deletes
                    dbSession.Delete(preExistingItem);
                }

                await dbSession.StoreAsync(item);
            }

            // 2. Api Resources
            var apiResourcesToSeed =
                IdentityClientAndResourcesSeedData.GetApiResources();

            foreach (var item in apiResourcesToSeed)
            {
                var preExistingItem = await dbSession.Query<ApiResource>()
                    .Where(wh => wh.Name == item.Name)
                    .FirstOrDefaultAsync();

                if (preExistingItem != null)
                {
                    // deletes
                    dbSession.Delete(preExistingItem);
                }

                await dbSession.StoreAsync(item);
            }

            // 3. Api Scopes
            var apiScopesToSeed =
                IdentityClientAndResourcesSeedData.GetApiScopes();

            foreach (var item in apiScopesToSeed)
            {
                var preExistingItem = await dbSession.Query<ApiScope>()
                    .Where(wh => wh.Name == item.Name)
                    .FirstOrDefaultAsync();

                if (preExistingItem != null)
                {
                    // deletes
                    dbSession.Delete(preExistingItem);
                }

                await dbSession.StoreAsync(item);
            }

            // 4. Identity Clients
            var mainClientsToSeed =
                IdentityClientAndResourcesSeedData.GetMainClients(configuration);

            foreach (var item in mainClientsToSeed)
            {
                var preExistingItem = await dbSession.Query<Client>()
                    .Where(wh => wh.ClientId == item.ClientId)
                    .FirstOrDefaultAsync();

                if (preExistingItem != null)
                {
                    // deletes
                    dbSession.Delete(preExistingItem);
                }

                await dbSession.StoreAsync(item);
            }

            await dbSession.SaveChangesAsync();
        }
    }

4. Creating ClientStore and Identity Store

These stores will be the layer between Identity Server and RavenDB database.

4.1 Client Store

public class ClientStore : IClientStore
    {
        private readonly IAsyncDocumentSession _dbSession;

        public ClientStore(
            IAsyncDocumentSession dbSession
            )
        {
            _dbSession = dbSession;
        }

        public async Task<Client> FindClientByIdAsync(string clientId)
        {
            var clientFound =
                await _dbSession.Query<Client>()
                    .Where(wh => wh.ClientId == clientId)
                    .FirstOrDefaultAsync();

            return clientFound;
        }
    }

4.2 Resource Store

public class ResourceStore : IResourceStore
    {
        private readonly IAsyncDocumentSession _dbSession;

        public ResourceStore(
            IAsyncDocumentSession dbSession
            )
        {
            _dbSession = dbSession;
        }

        public async Task<IEnumerable<IdentityResource>> FindIdentityResourcesByScopeNameAsync(
            IEnumerable<string> scopeNames)
        {
            if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

            var _identityResources =
                await _dbSession.Query<IdentityResource>().ToListAsync();

            var identity = from i in _identityResources
                where scopeNames.Contains(i.Name)
                select i;

            return identity;
        }

        public async Task<IEnumerable<ApiScope>> FindApiScopesByNameAsync(IEnumerable<string> scopeNames)
        {
            if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

            var _apiScopes =
                await _dbSession.Query<ApiScope>().ToListAsync();

            var query =
                from x in _apiScopes
                where scopeNames.Contains(x.Name)
                select x;

            return query;
        }

        public async Task<IEnumerable<ApiResource>> FindApiResourcesByScopeNameAsync(IEnumerable<string> scopeNames)
        {
            if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

            var allData =
                await _dbSession.Query<ApiResource>().ToListAsync();

            var query = from a in allData
                where a.Scopes.Any(x => scopeNames.Contains(x))
                select a;

            return query;
        }

        public async Task<IEnumerable<ApiResource>> FindApiResourcesByNameAsync(
            IEnumerable<string> apiResourceNames
            )
        {
            if (apiResourceNames == null) throw new ArgumentNullException(nameof(apiResourceNames));

            var allData =
                await _dbSession.Query<ApiResource>().ToListAsync();

            var query = from a in allData
                where apiResourceNames.Contains(a.Name)
                select a;

            return query;
        }

        public async Task<Resources> GetAllResourcesAsync()
        {
            var allApiResources =
                await _dbSession.Query<ApiResource>().ToListAsync();
            var allApiScopes =
                await _dbSession.Query<ApiScope>().ToListAsync();
            var allIdentityResources =
                await _dbSession.Query<IdentityResource>().ToListAsync();

            return new Resources(allIdentityResources, allApiResources, allApiScopes);
        }
    }

5. Startup.cs > Registering Identity Server resource and client stores

var builder = services.AddIdentityServer()
// Add Client Store and Resource Store implementations
   .AddClientStore<ClientStore>()
   .AddResourceStore<ResourceStore>()
   // Disable InMemory additions if they were being used.
   // .AddInMemoryIdentityResources( IdentityDevelopmentConfig.GetIdentityResources())
   // .AddInMemoryApiResources(IdentityDevelopmentConfig.GetApiResources())
   // .AddInMemoryApiScopes(IdentityDevelopmentConfig.GetApiScopes())
   // .AddInMemoryClients(IdentityDevelopmentConfig.GetMainClients(configuration))
  .AddAspNetIdentity<AppUser>();

6. RavenDB registration > Override DocumentStore to correctly define a collection name to IdentityResources types:

options.BeforeInitializeDocStore += docStoreOverride =>
                    {

                        docStoreOverride.Conventions.FindCollectionName = type =>
                        {
                            var identityResourcesTypes = new Type[]
                            {
                                typeof(IdentityResources.OpenId),
                                typeof(IdentityResources.Profile),
                                typeof(IdentityResources.Email)
                            };

                            if (identityResourcesTypes.Contains(type))
                                return "IdentityResources";

                            return DocumentConventions.DefaultGetCollectionName(type);
                        };
                    };

These steps should work.
They cover the changes will need to do to make RavenDB the official data store for your identity server resources and clients.

💡 The Data Seed implementation used in this tutorial is very useful for another scenarios.

If you have any problems let me know in comments. :)

Edit: 11/27/2020 - Persisted grant store implemented

var builder = services.AddIdentityServer(
config =>
   {
// ...
       .AddClientStore<ClientStore>()
       .AddResourceStore<ResourceStore>()
       .AddPersistedGrantStore<PersistedGrantStore>()
       .AddAspNetIdentity<AppUser>();
// ...

public class PersistedGrantStore : IPersistedGrantStore
{
    private readonly IAsyncDocumentSession _dbSession;

    public PersistedGrantStore(
        IAsyncDocumentSession dbSession
        )
    {
        _dbSession = dbSession;
    }
    public async Task StoreAsync(PersistedGrant grant)
    {
        await _dbSession.StoreAsync(grant);

        await _dbSession.SaveChangesAsync();
    }

    public Task<PersistedGrant> GetAsync(string key)
    {
        return _dbSession.Query<PersistedGrant>()
            .Where(wh => wh.Key == key)
            .FirstOrDefaultAsync();
    }

    public Task<IEnumerable<PersistedGrant>> GetAllAsync(PersistedGrantFilter filter)
    {
        var qry = _dbSession.Query<PersistedGrant>();

        if (filter.Type.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.Type == filter.Type);

        if (filter.ClientId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.ClientId == filter.ClientId);

        if (filter.SessionId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.SessionId == filter.SessionId);

        if (filter.SubjectId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.SubjectId == filter.SubjectId);

        return Task.FromResult(qry.AsEnumerable());
    }

    public async Task RemoveAsync(string key)
    {
        var objToDelete = 
            await this.GetAsync(key);
        _dbSession.Delete(objToDelete);

        await _dbSession.SaveChangesAsync();
    }

    public async Task RemoveAllAsync(PersistedGrantFilter filter)
    {
        var qry = _dbSession.Query<PersistedGrant>();

        if (filter.Type.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.Type == filter.Type);

        if (filter.ClientId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.ClientId == filter.ClientId);

        if (filter.SessionId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.SessionId == filter.SessionId);

        if (filter.SubjectId.IsNullOrEmpty() == false)
            qry = qry.Where(wh => wh.SubjectId == filter.SubjectId);

        var grantsToRemove = await qry.ToListAsync();

        foreach (var grant in grantsToRemove)
        {
            _dbSession.Delete(grant);    
        }

        await _dbSession.SaveChangesAsync();
    }
}

References:

https://github.com/IdentityServer/IdentityServer4/blob/18897890ce2cb020a71b836db030f3ed1ae57882/src/IdentityServer4/src/Stores/InMemory/InMemoryResourcesStore.cs
http://docs.identityserver.io/en/latest/topics/deployment.html
https://ravendb.net/docs/article-page/5.0/NodeJs/client-api/session/configuration/how-to-customize-collection-assignment-for-entities#session-how-to-customize-collection-assignment-for-entities
https://dotnetthoughts.net/seed-database-in-aspnet-core/

Criando expressões CRON com

Gabriel Barcelos | C#, AspNetCore, ReactJS — Sat, 31 Oct 2020 18:28:50 +0000

Em softwares comerciais, é comum a existência de algum runtime, que executa em background, tarefas de rotina na aplicação.
Essas tarefas, executam periodicamente. E para especificar a periodicidade, utilizamos expressões cron.

Sendo assim, a ferramenta CronTab Guru auxilia nesse trabalho.

Ao clicar em cada um dos espaços, você visualiza uma lista de possíveis valores daquele campo.

Outros recursos:

simulação de quando novas execuções vão ocorrer (baseado na data/hora da sua máquina e fuso horário)
geração randômica de expressões cron.

[Solution] MSBUILD Could not locate assembly

Gabriel Barcelos | C#, AspNetCore, ReactJS — Tue, 20 Oct 2020 17:43:47 +0000

MSBuild is a platform for building applications. This engine, which is also known as MSBuild, provides an XML schema for a project file that controls how the build platform processes and builds software.

Scenario:

I've a C# Windows Forms project .csproj that references some common dll´s.
These dll´s are coming from a folder outside project folder.
These dll´s are referenced at design time, from GAC (global assembly cache).

Problem:

When I´m building the project, inside a remote server, these dll´s should be searchable from another path.
Otherwise, I´ll receive the error below:

[warning]C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\Microsoft.Common.CurrentVersion.targets(2084,5): Warning MSB3245: Could not resolve this reference. Could not locate the assembly "DevExpress.Charts.v20.1.Core". Check to make sure the assembly exists on disk. If this reference is required by your code, you may get compilation errors.

Solution:

Open .csprojfile
Go to the final line, and before the tag, insert.

<Target Name="BeforeResolveReferences">
  <CreateProperty Value="$(MSBuildProjectDirectory)\two\levels\relativePath;$(AssemblySearchPaths)">
    <Output TaskParameter="Value" PropertyName="AssemblySearchPaths"/>
  </CreateProperty>
</Target>

Replace $(MSBuildProjectDirectory)\two\levels\relativePath; to your relative or absolute path.

References:

https://stackoverflow.com/questions/19309880/using-assemblysearchpaths-in-csproj-files/19456666
http://www.beefycode.com/post/resolving-binary-references-in-msbuild.aspx

Other references for deeper info:

https://docs.microsoft.com/en-us/visualstudio/msbuild/walkthrough-using-msbuild?view=vs-2019#targets-and-tasks
https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-2.0/9ad3f294(v=vs.80)?redirectedfrom=MSDN
https://docs.microsoft.com/en-us/visualstudio/msbuild/msbuild-reserved-and-well-known-properties?view=vs-2019

Redirecionando domínio do registro A para WWW

Gabriel Barcelos | C#, AspNetCore, ReactJS — Thu, 27 Aug 2020 13:54:45 +0000

Cenário

Quero hospedar um site estático na plataforma Azure Static WebSites, com custo baixo ou inexistente, e certificado SSL gratuito.
O site foi desenvolvido com NextJS + React.

Problema

O Azure não emite certificado SSL para "naked domains", ou seja, domínios sem o "www".

Sendo assim, sou obrigado a utilizar o domínio com "www", para não ter que comprar um certificado SSL.

Solução

A solução que encontrei foi redirecionar o site, do "naked domain", para o subdomínio "WWW".

Não é possível fazer esse redirecionamento nativamente no DNS. Ao menos não no DNS nativo do RegistroBr.

A solução que encontrei, foi utilizar um serviço gratuito de redirecionamento.

Alternativas:

Optei pela alternativa 1, dada a simplicidade de implementação. Basta apontar um registro A no meu DNS para o IP deles.

Register type: A
Description: @
Points to: 174.129.25.170

ATENÇÃO: essa não é uma recomendação. É somente um relato da minha experiência. Não posso garantir a idoneidade das alternativas apresentadas.

Exibindo erros de validação no servidor - Asp Core Web API + Axios + React Hook Form

Gabriel Barcelos | C#, AspNetCore, ReactJS — Tue, 25 Aug 2020 02:42:55 +0000

Cenário

A partir do ASP.NET CORE 2.1, erros de validação no servidor, são enviados para o client no formato Validation Problem Details, que segue uma estrutura semelhante a seguir:

{
   "type":"https://tools.ietf.org/html/rfc7231#section-6.5.1",
   "title":"One or more validation errors occurred.",
   "status":400,
   "traceId":"|52643794-491d9e1d05c828e6.",
   "errors":{
      "Cnpj":[
         "'Cnpj' must not be empty."
      ],
      "CompanyPublicName":[
         "'Company Public Name' must not be empty."
      ],
      "CompanyInternalName":[
         "'Company Internal Name' must not be empty."
      ]
   }
}

Perceba que na response, há a propriedade errors, contendo as propriedades com falhas de validação.

Estou utilizando Axios para requisições HTTP, e para checar, se o retorno da requisição é um feedback de validação, eu checo se há a presença do response header:

Content-Type: application/problem+json; charset=utf-8

Sendo assim, vejamos meu bloco try...catch responsável por invocar o Axios:

try {
    let response = await AxiosInstance.post(
        '/general/companies', {}, {}
    )
} catch (e) {

    const serverSideErrors = e.response.data.errors;

    // Faz iteração nas propriedades do objeto Errors, e usa o método 
    // *SetError* do ReactHookForm, para informar um erro.
    Object.entries(serverSideErrors).map(([key, value]) =>
        setError(key, {
            message: value,
            type: 'serverSide'
        })
    )

}

Axios interceptor:

Agora, antes de tratar o retorno da API, é preciso converter os nomes das propriedades para lowerCamelCase.
Eu faço isso usando um interceptor, ao criar uma instância do Axios.

// Add a response interceptor
instance.interceptors.response.use(function(response) {
    // Any status code that lie within the range of 2xx cause this function to trigger
    // Do something with response data
    return response;
}, function(error) {
    let newError = Object.assign({}, error);
    // Any status codes that falls outside the range of 2xx cause this function to trigger
    // Do something with response error
    if (newError.response.status === 400) {
        if (newError.response.headers['content-type'].includes('application/problem+json')) {
            /*
            Rename Problem Json response field names, to lower camel case
             */
            let serverData = newError.response.data;

            let errorsLowerCamelCase = Object.fromEntries(
                Object.entries(serverData.errors).map(([key, value]) =>
                    // Modify key here
                    [`${stringUtils.toLowerCamelCase(key)}`, value]
                )
            )

            newError.response.data.hasValidationErrors = true;
            newError.response.data.errors = errorsLowerCamelCase;
        }
    }
    return Promise.reject(newError);
});

Conclusão

Para renderizar os erros inline, estou usando bootstrap form-group, e o component ErrorMessage do próprio react-hook-form.

<ErrorMessage name="companyInternalName"
              errors={errors}
              render={({message}) =>
                <div className={'field-error text-danger'}>{message}</div>
              }

Configuro esse componente pra cada campo do formulário, e ao fazer submit do formulário, uma requisição HTTP é feita, o retorno é tratado, e o resultado é exibido abaixo:

Bônus: como exibir mensagens de validação globais? (que não estão associadas a nenhum campo específico)

A mensagem de resposta do servidor, para uma mensagem de validação global, deve ser conforme a seguir:

{
   "type":"https://tools.ietf.org/html/rfc7231#section-6.5.1",
   "title":"One or more validation errors occurred.",
   "status":400,
   "traceId":"|526437a6-491d9e1d05c828e6.",
   "errors":{
      "$":[
         "essa mensagem de validação aqui, não está associada a nenhum campo específico. 📍"
      ]
   }
}

Perceba que o identificador do campo, no objeto errors, é um símbolo $ .

Sendo assim, coloquei no topo da tela, um component < ErrorMessage /> , onde o atributo name="$" .
Isso me permite exibir no topo do formulário, erros globais de validação.

<ErrorMessage name="$"
errors={errors}
render={({message}) =>
  <>
    <FormGroup row>
      <Col md="4">
        <span>⚠️ Atenção:</span>
</Col>
<Col md="8">
  <div className={'field-error text-danger'}>{message}</div>
</Col>
</FormGroup>
</>
}
/>

Me avisa nos comentários se precisar de alguma ajuda.

Melhores bibliotecas p/ construir console apps com .NET CORE

Gabriel Barcelos | C#, AspNetCore, ReactJS — Sun, 09 Aug 2020 12:30:06 +0000

Updates:

10 de Outubro de 2020 - Typin adicionado.

Gui.cs

GUI.CS é uma biblioteca idealizada por Miguel de Icaza (#MONO, #GNOME, #XAMARIN, #MICROSOFT).
Acelera o desenvolvimento de console apps em .NET, .NET Core, e Mono, rodando em Windows, Mac, e Linux/Unix.

Controles visuais:

Button
CheckBox
ComboBox
Dialog
OpenDialog
SaveDialog
FrameView
Hex viewer/editor
Label
ListView
Menu
MessageBox
ProgressBar
Radio buttons
Time & Date Fields
TextField
Text Editor
ScrollView
ScrollBarView
StatusBar
Window

Github: https://github.com/migueldeicaza/gui.cs

Spectre Console

Facilita estilização de texto, e acesso a uma paleta de cores padronizada.

Typin

Declarative framework for interactive CLI applications.

Identity Server 4 - Invalid HTTP request for token endpoint

Gabriel Barcelos | C#, AspNetCore, ReactJS — Mon, 03 Aug 2020 17:54:39 +0000

Nesse post eu mostro a solução encontrada para um problema, que não está descrito na documentação do Identity Server 4 - Token Endpoint.

Problema:

Ao seguir a documentação e tentar obter um token válido no endpoint /connect/token recebo o seguinte retorno:

warn: IdentityServer4.Endpoints.TokenEndpoint[0]
      Invalid HTTP request for token endpoint

Para testar a obtenção de um token válido, utilizei o Postman, com uma request do tipo POST conforme a seguir:

Veja que o retorno foi um erro:

{
    "error": "invalid_request"
}

No servidor, esse é o client que foi inicializado no Identity Server 4:

// resource owner password grant client
clientList.Add(

new Client {
  ClientId = "ro.client",
  AllowedGrantTypes = GrantTypes.ResourceOwnerPasswordAndClientCredentials,

  ClientSecrets = {
    new Secret("t%n6CFC$h4XckGRna%=c2xrECt9M8v)NbF>)}x*9sF6ka3prLj.ozo3HELTGYPm9".Sha256())
  },
  AllowedScopes = {
    "openid",
    "apiErp.access",
    "apiControlPanel.access"
  },
  AllowOfflineAccess = true
}

);

O estranho é que antes de atualizar o Identity Server 4 para a versão mais recente, estava funcionando perfeitamente essa request.

Solução:

Troquei o content-type da request de: form-data para: x-www-form-urlencoded.

Feito isso o resultado:

{
    "access_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjA4QkEyN0M0MUU4MTJBQUZGMjcyN0ExMEM5RTVCRERFIiwidHlwIjoiYXQrand0In0.eyJuYmYiOjE1OTY0NzY5MzYsImV4cCI6MTU5NjQ4MDUzNiwiaXNzIjoiaHR0cHM6Ly9sb2NhbGhvc3Q6NTAwMCIsImF1ZCI6ImFwaUVycCIsImNsaWVudF9pZCI6InJvLmNsaWVudCIsInN1YiI6IkFwcFVzZXJzL2dhYnJpZWxyYi5uZXRAZ21haWwuY29tIiwiYXV0aF90aW1lIjoxNTk2NDc2OTM2LCJpZHAiOiJsb2NhbCIsImp0aSI6IjZGNzRBNUYxRURBQzM3NDAzQTMwMTA0NUZDMzgyRjcwIiwiaWF0IjoxNTk2NDc2OTM2LCJzY29wZSI6WyJhcGlFcnAuYWNjZXNzIl0sImFtciI6WyJwd2QiXX0.dms9yFDZk7mTxovGsVxtHVokJBOieAbygovMdlLsoOqY_MsZ-kLxs-OHovrel_sHuBnaZhZG4FnwhV429-otQ-7jDCWGYKMIzscoLjx3DgQKQGFTXZJ-StU3qqYJYsYyGrtaUfQE7D3QXjBL6WCfdeuf2or8b1HABXIR4-GRhvhSvQwZpiApdTi30iKpbDHB_aLJyqmOo_IjiO1A78tdgq60ydbyyPsPrqfwh5yghDs8ZlE77JBKOzyWxqDRhFey_0wBVx37rbnV4UMyJ_rnVyM7Vn4tm5_0Un34uzCoS_jyehxv28bEOH_K1BR60rEmFArexKNolTC9OGCPjDTslQ",
    "expires_in": 3600,
    "token_type": "Bearer",
    "scope": "apiErp.access"
}

Foi então que resolvi checar a documentação de referência do OpenId, e encontrei na especificação o seguinte modelo de request:

POST /token HTTP/1.1
  Host: server.example.com
👉Content-Type: application/x-www-form-urlencoded 
  Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW

  grant_type=authorization_code&code=SplxlOBeZQQYbYS6WxSbIA
    &redirect_uri=https%3A%2F%2Fclient.example.org%2Fcb

Vou tentar editar a documentação oficial do Identity Server 4, incluindo essa informação sobre o content type.

Espero que tenha te ajudado.
Valeu.

Guia: Blog Engines para .NET

Gabriel Barcelos | C#, AspNetCore, ReactJS — Thu, 30 Jul 2020 15:55:21 +0000

Nesse post, que será constantemente atualizado, vou enumerar engines de blog que eu encontrar na internet.

Quando já temos um site construído em ASP.NET, optar por uma engine de blogs nativa, ao invés de um Wordpress da vida, nos permite reutilizar a mesma estrutura de autenticação, mesmo banco de dados, mesmo pipeline de build e por aí vai.

Qual o papel de um blog engine?

Autenticação de usuários com níveis diferentes: editor, revisor, administrador etc
Permitir redação de posts
Lidar com a renderização
Incorporar preocupações com SEO

Lista de Engines

Não estão em ordem de melhor pra pior. Está em ordem de inserção somente.

1. DASBlog

Mesma engine utilizada no Blog do Scott Hanselman, que foi atualizada para .net CORE em 2019:

Scott Hanselman

@shanselman

@techierathore @JKirstaetter @thinkaboutnitin @Bikeshsrivastav @abhishekkant @Udara_Alwis @nishanil @mayur_tendulkar In fact it’s now dasBlogCore with all new code from @poppastring. Check it out it’s awesome!

18:22 PM - 16 Feb 2019

Me chamou atenção a forma como eles usam Razor Pages para definição de templates. Muito bem integrado com a plataforma ASP.NET.

DASBlog - Link para download

2. PineBlog

Features:

Markdown post editor
File management
Light-weight using Razor Pages
SEO optimized
Open Graph protocol
Clean Architecture (youtube: Clean Architecture with ASP.NET Core)
Entity Framework Core, SQL database
Azure Blob Storage, for file storage ..only a blogging engine, nothing else..

PineBlog - Link para download

Injeção de Dependência: escaneando e registrando

Gabriel Barcelos | C#, AspNetCore, ReactJS — Wed, 15 Jul 2020 20:55:58 +0000

1. Cenário:

Pra entender o objetivo do post, preciso te apresentar meu cenário:

Esse código foi usado em um software que implementa a arquitetura em fatias slice architecture
Quando eu busco uma informação no meu banco de dados, e vou retornar pra "View", preciso transformar os dados, para um "DTO".
Ao invés de usar AutoMapper nessa transformação, implementei o design pattern Adapter manualmente, seguindo esse artigo.

Implementando o design pattern Adapter:

public class ProductAdapter : IScopedService
    {
        private readonly IAsyncDocumentSession _dbSession;

        public ProductAdapter(
            IAsyncDocumentSession dbSession)
        {
            _dbSession = dbSession;
        }

// Entra um objeto Command, sai um product
        public Product AdaptToProduct(ProductCreateEdit.Command source)
        {
            var destination = new Product();
            destination.Id = source.Id;
            destination.Description = source.Description;


            return destination;
        }

// Entra um product, sai um Command
        public ProductCreateEdit.Command AdaptToCommand(Product source)
        {
            var destination = new ProductCreateEdit.Command();
            destination.Id = source.Id;
            destination.Description = source.Description;

            return destination;
        }
    }

Não se apegue aos nomes das classes, entenda somente que são 2 métodos, que recebem um objeto, copiam as propriedades, e retornam outro.

2. Problema:

Como estou usando ASP.NET CORE 3.0 no desenvolvimento, preferi usar o sistema de injeção de dependências nativo.

Ao longo do projeto, vão ser criadas muitas classes "Adaptadoras", e registrá-las manualmente, uma a uma, é um trabalho que quero evitar.

3. Solução:

3.1 Criei uma interface de marcação. Uma interface que tem o único propósito de deixar uma marca nas classes adaptadoras.

public interface IInterface
    {
        // helper interface
    }

public interface IScopedService : IInterface
    {
        // empty interface to ease injection
    }

Toda classe adaptadora que eu crio, a faço implementar a interface IScopedService.
Daí usando o método de extensão abaixo, eu escaneio todas as classes que implementem IScopedService, e as registro, com o ciclo de vida Scoped, no container de injeção de dependências.

public static class ServiceCollectionExtensions
    {
        /// <summary>
        /// Register all types that implements T interface
        /// Reference:
        /// https://medium.com/agilix/asp-net-core-inject-all-instances-of-a-service-interface-64b37b43fdc8
        /// </summary>
        /// <param name="services">Service collection</param>
        /// <param name="assemblies">Assemblies that will be scanned</param>
        /// <param name="lifetime">lifetime scope</param>
        /// <typeparam name="T">Interface type</typeparam>
        public static void RegisterAllTypesThatImplements<I>(this IServiceCollection services, Assembly[] assemblies,
            ServiceLifetime lifetime = ServiceLifetime.Transient) where I : IInterface
        {
            var typesFromAssemblies = assemblies.SelectMany(a => a.DefinedTypes.Where(x => x.GetInterfaces().Contains(typeof(I))));
            foreach (var type in typesFromAssemblies)
                services.Add(new ServiceDescriptor(type, type, lifetime));
        }
    }

// Agora na classe Startup.cs
public void ConfigureServices(IServiceCollection services)
{
   // registra todos os scoped services
   services.RegisterAllTypesThatImplements<IScopedService>();
}

Conclusão:

Esse tipo de implementação não costuma aparecer nos cursos de programação.
Se você ignorar o fato de que estou usando esse registro em massa pra uma classe de mapeamento, verá que dá pra usar essa técnica pra registro em massa de classes que não implementam interfaces!

Se você encontrou esse post no momento certo, ele vai te economizar um tempo em manutenção / digitação de código.

Código único com NanoID.net

Gabriel Barcelos | C#, AspNetCore, ReactJS — Mon, 15 Jun 2020 15:27:25 +0000

Nas suas aplicações, quantas vezes você já precisou de um código único? Seja para identificar um cadastro, um produto no pedido, etc?

O GUID é confiável, mas tem um tamanho exagerado, não? Podemos concordar que ele é ininteligível e difícil de decorar?

Pois bem, encontrei uma alternativa que gostaria de compartilhar: [HASH-ID[(https://hashids.org/).

Uma biblioteca openSource que tem implementações em diversas linguagens e plataformas: JavaScript, Ruby, Python, Java, Scala, PHP, Perl, Perl 6, Swift, Clojure, Objective-C, C, C++11, D, F#, Go, Erlang, Lua, Haskell, OCaml, Elixir, Rust, Smalltalk, ColdFusion, Kotlin, Nim, VBA, Haxe, Crystal, Elm, ActionScript, Bash, R, TSQL, PostgreSQL, PLpgSQL, Dart, Io and for .NET

É muito fácil de usar. Veja um exemplo de código em CSharp:

public string GerarCodigoDaVenda(){
  return Nanoid.Nanoid.Generate( 
     alphabet: "1234567890abcdefghijklmnopqrstuwvxyz", 
     size: 10
   );                
}

No trecho de código acima, eu delimitei a variedade de caracteres que o NanoID vai utilizar, além de especificar o tamanho em 10 caracteres.

Variações do NanoID:

Normal

// Na modalidade padrão, o método usa símbolos amigáveis com URLS (A-Za-z0-9_~), e retorna um ID com 21 caracteres (chances de colisão similares ao formato UUID v4).

var idNormal = Nanoid.Generate();
//resultado: "Uakgb_J5m9g~0JDMbcJqLJ"

// Símbolos -,.() não são codificados em URL´s.

// Se você quiser reduzir o tamanho do ID, passe o tamanho como argumento:
var idReduzido = Nanoid.Generate(size:10) 

//resultado "IRFa~VaY2b"

Customizado

// ⚠️ A variação de caracteres deve conter 256 símbolos ou menos. De outra forma não será seguro.
var id = Nanoid.Generate('1234567890abcdef', 10) //=> "4f90d13a42"