Henara.Grpc.Client.DakotaSlim

Slim Dakota gRPC client for a native host that already owns a Keycloak session (written for the SmartVO Windows client). It adapts the host's existing access token onto the Dakota clients — it has no interactive login and no token refresh of its own. The host's session manager stays the single token authority.

Do not also call AddNativeKeycloakAuth (from Henara.Grpc.Client.Common). That starts a second refresh-token rotation against the same Keycloak session and the two invalidate each other (invalid_grant). AddSlimNativeDakotaClient enforces this — it throws at registration if any ICallTokenProvider or native Keycloak provider is already registered.

Endpoints

Two environment variables, read and validated at registration (throws if missing):

http:// targets are served as plaintext h2c (call credentials are still attached); use https:// in production.

Registration

services.AddSlimNativeDakotaClient((sp, ct) => /* return a valid raw access token, no "Bearer " prefix */);

The callback is invoked per RPC; return the host session's current (auto-refreshed) access token. The IServiceProvider argument lets the callback resolve the host's own session service — in SmartVO:

services.AddSlimNativeDakotaClient((sp, ct) =>
    sp.GetRequiredService<ISessionManager>().GetValidAccessTokenAsync(ct));

This registers two clients — IDakotaGatewayClient (pipeline) and IDakotaReporterClient (reporting). Inject them wherever you need them.

Pipeline — IDakotaGatewayClient

Submits Dakota processing jobs and queries retry state.

IAsyncEnumerable<DakotaDispatchResult> DispatchDakotaProcess(
    List<DakotaPairRequest> pairs, CancellationToken ct = default);

Task<Result<bool, Failure>> IsPipelineStepRetryDispatched(Guid tickerId);

DispatchDakotaProcess streams one ESOL/AUF file pair per DakotaPairRequest and yields one result per pair. The intake gate authorises each pair by the sender (praxis) IK carried in the file; a rejected pair returns IsDispatched == false with a Message.

var pairs = new List<DakotaPairRequest>
{
    new(
        FilePair:           new FileRequestInfoDto(esolBytes, aufBytes, "file.con"),
        CustomerId:         20131386,
        Channel:            ChannelTypeEnum.Production,
        IsEsolPreprocessed: false,
        OverwriteRecipient: null)
};

await foreach (var r in gateway.DispatchDakotaProcess(pairs, ct))
    Console.WriteLine(r.IsDispatched
        ? $"dispatched {r.FileName} -> {r.PipelineId}"
        : $"rejected {r.FileName}: {r.Message}");

IsPipelineStepRetryDispatched returns true if a retry is already queued for a step ticker; otherwise a Failure.

Reporting — IDakotaReporterClient

Reads process statuses and files. The server scopes all results to the signed-in user's customer id(s); Henara admins see everything.

IAsyncEnumerable<DakotaProcessInfoDto> GetDakotaStati(DakotaFilter? filter = null);

Task<(IReadOnlyList<DakotaFileRowDto> Rows, long Total)> GetFilesPaged(int page, int pageSize, string search);

IAsyncEnumerable<SingleIlFileInfoDto> DownloadFiles(List<(int oid, DownloadFileTypeEnum type)> filesToDownload);

• GetDakotaStati — streams process-status aggregates. The DakotaFilter (all members optional) narrows by customer id, receiver IK, time range, pipeline step, status, or file name; null returns everything the caller may see.
• GetFilesPaged — server-paged, searchable file list; search matches file name / receiver IK (empty matches all). Returns the page rows and the total count.
• DownloadFiles — streams raw file contents for the given object ids. Dakota file types are DownloadFileTypeEnum.DakotaEsol and DakotaAuf.

var filter = new DakotaFilter { CustomerId = new MatchesIntFilterDto(20131386) };
await foreach (var p in reporter.GetDakotaStati(filter))
    Console.WriteLine($"{p.CreatedAt:o} {p.ReceiverIk} {p.FileName}");

var (rows, total) = await reporter.GetFilesPaged(page: 0, pageSize: 100, search: "");

var ids = rows.Select(r => (r.DataOid, DownloadFileTypeEnum.DakotaEsol)).ToList();
await foreach (var f in reporter.DownloadFiles(ids))
    await File.WriteAllBytesAsync(f.FileName, f.FileData, ct);

DTO reference

Identity