public async Task <ReconciledResult> GetReconciled(ReconciliationGetReconciledArguments args, CancellationToken cancellation)
        {
            await Initialize(cancellation);

            // Authorized access (Criteria are not supported here)
            var permissions = await UserPermissions(PermissionActions.Read, cancellation);

            if (!permissions.Any())
            {
                throw new ForbiddenException();
            }

            ReconciledOutput output = await _behavior.Repository.Reconciliation__Load_Reconciled(
                accountId : args.AccountId,
                agentId : args.AgentId,
                fromDate : args.FromDate,
                toDate : args.ToDate,
                fromAmount : args.FromAmount,
                toAmount : args.ToAmount,
                externalReferenceContains : args.ExternalReferenceContains,
                top : args.Top,
                skip : args.Skip,
                cancellation);

            return(MapFromOutput(output));
        }
        public async Task <ReconciledResult> SaveAndGetReconciled(ReconciliationSavePayload payload, ReconciliationGetReconciledArguments args)
        {
            await Initialize();

            // Start transaction
            using var trx = TransactionFactory.ReadCommitted();

            // Preprocess and Validate
            await PermissionsPreprocessAndValidate(args.AccountId, args.AgentId, payload);

            // Save
            ReconciledOutput output = await _behavior.Repository.Reconciliations__SaveAndLoad_Reconciled(
                accountId : args.AccountId,
                agentId : args.AgentId,
                externalEntriesForSave : payload.ExternalEntries,
                reconciliations : payload.Reconciliations,
                deletedExternalEntryIds : payload.DeletedExternalEntryIds,
                deletedReconciliationIds : payload.DeletedReconciliationIds,
                fromDate : args.FromDate,
                toDate : args.ToDate,
                fromAmount : args.FromAmount,
                toAmount : args.ToAmount,
                externalReferenceContains : args.ExternalReferenceContains,
                top : args.Top,
                skip : args.Skip,
                userId : UserId);

            trx.Complete();

            return(MapFromOutput(output));
        }
 private static ReconciledResult MapFromOutput(ReconciledOutput output)
 {
     return(new ReconciledResult
            (
                reconciledCount: output.ReconciledCount,
                reconciliations: output.Reconciliations
            ));
 }