B Reed's questions

Tenho um modelo que estou passando com sucesso TextTabs e CheckboxTabs; no entanto, meus NumberTabs não estão sendo exibidos. Estou lendo sobre Tabulações Numéricas vs. Tabulações Numéricas. Verifiquei novamente e parece que o modelo está configurado com Number. Consigo ver o valor antes de enviar para o DocuSign. Mas quando o envelope é aberto, ele não está lá.

Devo usar Numérico? Alguma outra ideia do que está faltando?

Atualização: Testei Numérico e funcionou. Nova pergunta: Como posso saber se era Numérico no modelo?

   Number n = new Number
   {
        TabLabel = kvp.Key,// name of DS field, e.g. amount
        Value = kvp.Value //e.g. 25.53
   };

   List<Number>? numTabs = [];
   numTabs.Add(n);

   tabs ??= new Tabs();
   tabs.NumberTabs = numTabs ;

   //continue to populate envelope/signer information in envelope definition

Esta é a definição do meu campo de modelo DocuSign, por exemplo, valor:

Desenvolvendo um aplicativo interno da organização para enviar envelopes/ter assinatura incorporada usando os SDKs C# do DocuSign. Seguindo os exemplos do Quickstart, consigo fazer essas ações. Como ele usa os ambientes de demonstração/teste do DocuSign, quando esse aplicativo for implantado, o código precisará fazer chamadas para o ambiente de produção do DocuSign.

Como os funcionários da organização usarão este aplicativo, não os clientes, o código usa Concessões de Código de Autorização, não Tokens JWT.

1. Então, com a obtenção do token de acesso, o código deve chamar SetOAuthBasePath de sua instância de DocuSignClient? O SDK diz "Use este método para definir o caminho base OAuth personalizado". Mas como o DocuSign saberá o contrário?

2. Eu assumo que a chamada de endpoint UserInfo para o BaseUri do usuário já terá o ambiente correto (já que eles foram autenticados), e o BaseUri estaria então 'apontando' para o ambiente apropriado. Verdade?

Vejo que o C# SDK tem constantes que podemos referenciar. Devo usá-las para definir quando estou no meu ambiente de produção:

public class DocuSignClient
{
    public const string Production_REST_BasePath = "https://www.docusign.net/restapi";

    public const string Demo_REST_BasePath = "https://demo.docusign.net/restapi";
...
}

public class OAuth
{
...
    public static string Demo_OAuth_BasePath = "account-d.docusign.com";

    public static string Production_OAuth_BasePath = "account.docusign.com";
}

Exemplo de código em vez de DocuSignClient docuSignClient = new DocuSignClient():

protected DocuSignClient GetDocuSignClient(bool isForAuth, bool useProd, string? userBaseUri = null)
{
    DocuSignClient rtn = new DocuSignClient();

    //DocuSignClient defaults to demo environment
    if (isForAuth && useProd)
    {
        rtn.SetOAuthBasePath(OAuth.Production_OAuth_BasePath);
    }
    
    if (!isForAuth && !string.IsNullOrEmpty(userBaseUri))
    {
        //we should have a User BaseUri, which will be based on the environment authenticated 
        rtn.SetBasePath(userBaseUri);
    }
    return rtn;
}

Ao criar uma nova solução interna (usando ASP.NET Core MVC), nossa política é autenticar usando nosso Active Directory (também conhecido como Entra) para nossos usuários. Este novo aplicativo então coleta dados que então geram um objeto DocuSign usando sua API/SDKs. Esta é a primeira vez que preciso chamar APIs via SDK, e estou um pouco confuso com a mecânica. Quero seguir as melhores práticas de segurança. O DocuSign recomenda que quando o usuário estiver presente use o Confidential Authorization Code Grant, e fornece exemplos. No entanto, não acho que os exemplos que modificam Program.cs (exemplos mostram usando Startup.cs de versões mais antigas do .NET) funcionem quando combinados com a autenticação Entra.

Resumindo, esta solução deve funcionar desta maneira:

1. Todos os usuários são autenticados via Entra ID (Azure AD). (Veja o destaque amarelo)
2. Após a autenticação, os usuários podem executar ações que podem exigir a chamada de APIs do DocuSign usando o Fluxo de Código de Autorização OAuth 2.0.

Minhas perguntas (após a atualização, ainda gostaria de entender as 2 primeiras perguntas) :

1. Acredito (mas não tenho 100% de certeza) que o Entra não usa autenticação de cookies. E não devemos mudar isso.

2. É possível ter múltiplas Autenticações em um único aplicativo como descrevi usando Program.cs AddAuthentication()? Qual é o propósito de EnableTokenAcquisitionToCallDownstreamApi(), é usar as credenciais do usuário para obter outros dados que essas credenciais permitem?

3. (Respondido com atualização - Encontrei outra maneira de fazer isso funcionar) Acredito que eu deveria tentar AddAuthentication()em Program.cs, em vez de criar solicitações HttpClient, escrever código em controladores para obter o token de acesso e, então, de alguma forma, persistir para chamar as outras APIs do DocuSign. Pensei que encontraria exemplos disso, mas vejo principalmente exemplos usando tokens JWT, para chamadas de API para API. Verdade? Resposta: Sim

Atualização: Por fim, removi o segundo AddAuthentication() do Program.cs:

// Add Entra authentication
builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"));
//pulled out all the other AddAuth, AddOauth... 

Eu uso meus controladores para chamar o Docusign SDK. Há um documento que, na parte inferior, tem a classe e os métodos que funcionaram: https://developers.docusign.com/platform/auth/confidential-authcode-get-token/

Usei 3 métodos DocuSignClient.cs na minha camada de controlador. (Veja o código da classe aqui https://github.com/docusign/docusign-esign-csharp-client/blob/master/sdk/src/DocuSign.eSign/Client/DocuSignClient.cs )

GetAuthorizationUri(), GenerateAccessToken(),GetUserInfo()

Funcionou. Talvez a DocuSign forneça exemplos e amostras usando estes, eu não encontrei nenhum, mas foi bem direto. Não estava no código QuickStart deles.

Original: Quando tento o código de exemplo (trechos abaixo), eu autentico com sucesso com o Entra, e quando navego para o controlador com autenticação DocuSign, sou solicitado a fornecer minhas credenciais DocuSign. Tudo bem. Com um ponto de interrupção no OnCreatingTicket, eu passo por essa parte da autenticação. No entanto, depois disso, recebo uma exceção abaixo. Todas as pesquisas sobre isso dizem que preciso habilitar cookies no meu esquema de autenticação padrão. O que eu não quero fazer.

Exceção:

The authentication handler registered for scheme 'OpenIdConnect' is 'OpenIdConnectHandler' which cannot be used for SignInAsync. The registered sign-in schemes are: Cookies.

Microsoft.AspNetCore.Authentication.AuthenticationService.SignInAsync(HttpContext context, string scheme, ClaimsPrincipal principal, AuthenticationProperties properties)
Microsoft.AspNetCore.Authentication.RemoteAuthenticationHandler<TOptions>.HandleRequestAsync()
Microsoft.AspNetCore.Authentication.AuthenticationMiddleware.Invoke(HttpContext context)
Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl.Invoke(HttpContext context)

        var builder = WebApplication.CreateBuilder(args);
        
        // Add Entra authentication
        builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
            .AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"));
        
        
        // Add DocuSign authentication
        builder.Services.AddAuthentication(options =>
                    {
                        options.DefaultSignOutScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                        options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                        options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                        options.DefaultChallengeScheme = "DocuSign";
                    })
                    .AddCookie()
                    .AddOAuth("DocuSign", options =>
                    {
                        options.ClientId = this.Configuration["DocuSign:ClientId"];
                        options.ClientSecret = this.Configuration["DocuSign:ClientSecret"];
                        options.CallbackPath = new PathString("/ds/callback");
                        options.AuthorizationEndpoint = this.Configuration["DocuSign:AuthorizationEndpoint"];
                        options.TokenEndpoint = this.Configuration["DocuSign:TokenEndpoint"];
                        options.UserInformationEndpoint = this.Configuration["DocuSign:UserInformationEndpoint"];
        
        options.Events = new OAuthEvents
        {
            OnCreatingTicket = async context =>
            {
                var request = new HttpRequestMessage(HttpMethod.Get, context.Options.UserInformationEndpoint);
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", context.AccessToken);
                var response = await context.Backchannel.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, context.HttpContext.RequestAborted);
                response.EnsureSuccessStatusCode();
                var user = JObject.Parse(await response.Content.ReadAsStringAsync());
                user.Add("access_token", context.AccessToken);
                user.Add("refresh_token", context.RefreshToken);
                user.Add("expires_in", DateTime.Now.Add(context.ExpiresIn.Value).ToString());
                using (JsonDocument payload = JsonDocument.Parse(user.ToString()))
                {
                    context.RunClaimActions(payload.RootElement);
                }
            }
    
    //lines 151 - 244 from https://github.com/docusign/code-examples-csharp/blob/master/launcher-csharp/Startup.cs
    
    // Add controllers and Razor pages with Auth
    builder.Services.AddControllersWithViews(options =>
        var policy = new AuthorizationPolicyBuilder()
            .RequireAuthenticateUser()
            .Build();
        options.Filters.Add(new AuthorizeFilter(policy));
    }).AddMicrosoftIdentityUI();

    —-----------------
    [Authorize(AuthenticationSchemes = "DocuSign")]
    public IActionResult Login(string authType = "CodeGrant", string returnUrl = "/")
    {
        if (authType == "CodeGrant") 
        {
            return Challenge(new AuthenticationProperties() { RedirectUri = returnUrl });
        }
    }

Aqui está a documentação do DocuSign que usei como orientação: https://developers.docusign.com/docs/esign-rest-api/sdks/csharp/auth/