/// <summary>
/// Initializes a new instance of the <see cref="CitizenDocumentsClient"/> class.
/// </summary>
/// <param name="httpClient">The HTTP client to use. The caller is expected to manage this resource and it will not be disposed.</param>
/// <param name="tokenProviderFactory">The Logic access token provider factory.</param>
/// <param name="options">The required configuration options.</param>
public CitizenDocumentsClient(
HttpClient httpClient,
LogicTokenProviderFactory tokenProviderFactory,
CitizenDocumentsOptions options)
{
this._httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
this._options = options ?? throw new ArgumentNullException(nameof(options));
this._tokenProviderFactory =
tokenProviderFactory ?? throw new ArgumentNullException(nameof(tokenProviderFactory));
#pragma warning disable CS0618 // Type or member is obsolete
if (string.IsNullOrEmpty(this._tokenProviderFactory.DefaultAuthorizationScope))
{
this._tokenProviderFactory.DefaultAuthorizationScope =
"https://logicidentityprod.onmicrosoft.com/bb159109-0ccd-4b08-8d0d-80370cedda84/.default";
}
#pragma warning restore CS0618 // Type or member is obsolete
}
private static async Task Run(AppSettings configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
var options = new LogicTokenProviderOptions
{
ClientId = configuration.ClientId,
ClientSecret = configuration.ClientSecret,
Tenant = configuration.Tenant,
};
if (!string.IsNullOrEmpty(configuration.AuthorizationScope))
{
options.AuthorizationScope = configuration.AuthorizationScope;
}
if (configuration.AuthorizationTokenIssuer != null)
{
options.AuthorizationTokenIssuer = configuration.AuthorizationTokenIssuer;
}
using (var tokenFactory = new LogicTokenProviderFactory(options))
using (var httpClient = new HttpClient())
{
var provider = tokenFactory.GetProvider(httpClient);
Log.Information("Requesting access to scope {Scope} with client id {ClientId}", options.AuthorizationScope, options.ClientId);
var authHeader = await provider.GetAuthenticationHeaderAsync(CancellationToken.None).ConfigureAwait(false);
Log.Information("Retrieved authorization header {Scheme} {Parameter}", authHeader.Scheme, authHeader.Parameter);
var jwt = new JsonWebToken(authHeader.Parameter);
Log.Information("Deserialized JWT {@Jwt}", jwt);
}
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider);
var fileSecurityClient = new FileSecurityClient(httpClient, tokenProviderFactory, configuration.FileSecurityOptions);
// Get Sign Configuration
Log.Information("Getting signconfiguration...");
var signConfigurationResult = await fileSecurityClient.GetPdfSignConfiguration(configuration.SignConfigurationDetails.SignConfigurationId).ConfigureAwait(false);
if (signConfigurationResult == null)
{
Log.Error("Couldn't get signconfiguration");
return;
}
Console.WriteLine(
"Configuration recieved successfully. SignConfiguration ID: {0} \nSignConfiguration Name: {1}\nSubscription ID : {2}",
signConfigurationResult.Id,
signConfigurationResult.Name,
signConfigurationResult.SubscriptionId);
// Generate document
Log.Information("Generate document using privileges...");
string pdfSample = configuration.SignConfigurationDetails.PdfEmptySampleLocation;
using Document document = new Document(pdfSample);
var documentPrivilege = FillPrivileges(signConfigurationResult.PdfPrivilege);
document.Encrypt(string.Empty, "owner", documentPrivilege, CryptoAlgorithm.AESx128, false);
document.Save(configuration.SignConfigurationDetails.PdfGeneratedDocumentLocation + "pdf_with_privileges.pdf");
Log.Information(
"Document with configured privileges generated successfully at {location}",
configuration.SignConfigurationDetails.PdfGeneratedDocumentLocation + "pdf-with-privileges.pdf");
}
public GatewayAutomation(HttpClient httpClient, LogicTokenProviderFactory tokenProviderFactory, GatewayOptions options)
{
if (httpClient == null)
{
throw new ArgumentNullException(nameof(httpClient));
}
if (tokenProviderFactory == null)
{
throw new ArgumentNullException(nameof(tokenProviderFactory));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
this.validatePublishing = new ValidatePublishing(httpClient, tokenProviderFactory, options);
this.publish = new Publish(httpClient, tokenProviderFactory, options);
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider);
var gatewayAutomation = new GatewayAutomation(httpClient, tokenProviderFactory, configuration.Gateway);
var results = await gatewayAutomation.PublishAsync(configuration.FolderPath).ConfigureAwait(false);
foreach (var result in results)
{
Console.WriteLine(result.ToString());
}
}
private static async Task <string> Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return("The validation of provider configuration details failed");
}
var tokenProviderOptions = new LogicTokenProviderOptions
{
AuthorizationScope = configuration.TokenProvider.AuthorizationScope,
ClientId = configuration.TokenProvider.ClientId,
ClientSecret = configuration.TokenProvider.ClientSecret,
};
if (configuration.TokenProvider.AuthorizationTokenIssuer != null)
{
tokenProviderOptions.AuthorizationTokenIssuer = configuration.TokenProvider.AuthorizationTokenIssuer;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(tokenProviderOptions);
var options = new CitizenDocumentsOptions(configuration.SubscriptionId, configuration.ServiceUri);
using var citizenDocumentClient = new CitizenDocumentsClient(httpClient, tokenProviderFactory, options);
using Stream stream = File.OpenRead(configuration.DocumentName);
var uploadWithLargeSizeDocument = await citizenDocumentClient.UploadFileAsync(stream, new UploadFileParameters(
new Guid(configuration.ConfigurationId),
new Guid(configuration.SubscriptionId),
cpr : configuration.Cpr,
documentName : configuration.DocumentName,
documentType : configuration.DocumentType,
retentionPeriodInDays : configuration.RetentionPeriodInDays))
.ConfigureAwait(false);
Log.Information("The {DocumentType} document with id {DocumentId} and file access page url {FileAccessPageUrl} is uploaded successfully", uploadWithLargeSizeDocument.DocumentType, uploadWithLargeSizeDocument.DocumentId, uploadWithLargeSizeDocument.FileAccessPageUrl);
return("The citizen document was uploaded successfully");
}
#pragma warning restore SA1401 // Fields should be private
protected void Initialize(CommandBase cmd)
{
this.logicTokenProviderFactory = new LogicTokenProviderFactory(
new LogicTokenProviderOptions
{
AuthorizationScope = cmd.AuthorizationScope,
ClientId = cmd.ClientId,
ClientSecret = cmd.ClientSecret,
});
this.gatewayOptions = new GatewayOptions
{
SubscriptionId = cmd.SubscriptionId,
ProviderId = cmd.ProviderId,
};
this.gatewayOptions.GatewayServiceUri = cmd.GatewayUrl ?? this.gatewayOptions.GatewayServiceUri;
if (cmd.OutputFormat == OutputFormat.Json)
{
this.outputFormatter = new JsonOutputFormatter();
}
}
public ApisPreValidation(string folderPath, HttpClient httpClient, LogicTokenProviderFactory tokenProviderFactory, GatewayOptions options)
: base(folderPath)
{
this.options = options;
this.gatewayClientFactory = new GatewayClientFactory(tokenProviderFactory, httpClient, options);
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider);
using var cvrClient = new CvrClient(httpClient, tokenProviderFactory, configuration.Cvr);
var configs = await cvrClient.GetAllCvrConfigurationsAsync().ConfigureAwait(false);
if (configs == null || configs.Count == 0)
{
Log.Information("There are no CVR configurations defined for this subscription");
return;
}
CvrProviderConfigurationModel cvrProvider;
if (configuration.Cvr.CvrConfigurationId == Guid.Empty)
{
var fakeProviderConfig = await cvrClient.CreateFakeProviderConfiguration($"sample-{Guid.NewGuid()}").ConfigureAwait(false);
Log.Information("Created Fake Provider configuration with name '{Name}'", fakeProviderConfig.Name);
cvrProvider = new CvrProviderConfigurationModel
{
Id = fakeProviderConfig.Id,
SubscriptionId = fakeProviderConfig.SubscriptionId,
Name = fakeProviderConfig.Name,
Provider = "Fake Provider",
};
configuration.Cvr.CvrConfigurationId = fakeProviderConfig.Id.Value;
}
else
{
cvrProvider = configs.FirstOrDefault(x => x.Id == configuration.Cvr.CvrConfigurationId);
if (cvrProvider == null)
{
Log.Error("Invalid CVR configuration id {Id}", configuration.Cvr.CvrConfigurationId);
return;
}
}
Log.Information("Fetching {Cvr} using configuration {Name}", configuration.CvrNumber, cvrProvider.Name);
var company = await cvrClient.GetCompanyByCvrAsync(configuration.CvrNumber).ConfigureAwait(false);
Log.Information("Company data: {@Company}", company);
if (cvrProvider.Provider == "Fake Provider")
{
return;
}
Log.Information("Fetching company by id {Id} using configuration {Name}", company.Id, cvrProvider.Name);
var companyById = await cvrClient.GetCompanyByIdAsync(company.Id).ConfigureAwait(false);
Log.Information("Fetched one company using two methods: {Success}", company.CvrNumber == companyById.CvrNumber);
Log.Information("Fetching Production Units for CVR number {Cvr}", configuration.CvrNumber);
var productionUnits = await cvrClient.GetProductionUnitsAsync(configuration.CvrNumber).ConfigureAwait(false);
if (productionUnits == null || productionUnits.Count == 0)
{
Log.Information("There is no Production Unit defined for this company");
return;
}
Log.Information("Production Units data for Company {@CompanyName}: {@ProductionUnits}", company.CompanyName, productionUnits);
Log.Information("Fetching Production Unit Detail for production unit number {PNumber}", productionUnits[0].PNumber);
var productionUnitDetail = await cvrClient.GetProductionUnitDetailAsync(productionUnits[0].PNumber).ConfigureAwait(false);
Log.Information("Fetching Production Unit Detail for object id {Id}", productionUnitDetail.Id);
var productionUnitById = await cvrClient.GetProductionUnitDetailByIdAsync(productionUnitDetail.Id).ConfigureAwait(false);
Log.Information("Fetched one production unit using two methods: {Success}", productionUnitDetail.PNumber == productionUnitById.PNumber);
Log.Information("Fetching company events using configuration {Name}", cvrProvider.Name);
var events = await cvrClient.GetAllCompanyEventsAsync(DateTime.Now.AddMonths(-2), DateTime.Today, 1, 100).ConfigureAwait(false);
Log.Information("Fetched {Amount} company events", events.Count);
var eventsCount = events.Count;
if (eventsCount > 0)
{
var companyToSubscribe = company.Id;
Log.Information("Subscribing for events of company with object id {ObjectId}", companyToSubscribe);
await cvrClient.SubscribeByIdAsync(companyToSubscribe).ConfigureAwait(false);
var productionUnitToSubscribe = productionUnitDetail.Id;
Log.Information("Subscribing for events of company's production unit with object id {ObjectId}", productionUnitToSubscribe);
await cvrClient.SubscribeByIdAsync(productionUnitToSubscribe).ConfigureAwait(false);
Log.Information("Fetching events for subscribed companies using configuration {Name}", cvrProvider.Name);
var page = 1;
var isEventsExist = true;
while (isEventsExist)
{
var subscribedEvents = await cvrClient.GetSubscribedCompanyEventsAsync(DateTime.Now.AddMonths(-2), DateTime.Today, page, 100).ConfigureAwait(false);
isEventsExist = subscribedEvents.ActualCount > 0;
Log.Information("Fetched {Amount} company subscribed events", subscribedEvents.Events.Count);
page++;
}
var companyToUnSubscribe = company.Id;
bool success = await cvrClient.UnsubscribeByIdAsync(companyToUnSubscribe).ConfigureAwait(false);
if (success)
{
Log.Information("Unsubscribed from company events with object id {ObjectId}", companyToUnSubscribe);
}
}
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider);
var fileSecurityClient = new FileSecurityClient(httpClient, tokenProviderFactory, configuration.FileSecurityOptions);
var certificateId = configuration.CertificateDetails.CertificateId;
Log.Information("Fetching certificate details for certificate id {CertificateId} ", configuration.CertificateDetails.CertificateId);
var result = await fileSecurityClient.GetCertificate(certificateId).ConfigureAwait(false);
if (result == null)
{
Log.Error("Invalid certificate id {Id}", configuration.CertificateDetails.CertificateId);
return;
}
Console.WriteLine("Certificate ID: {0} \nCertificate Name: {1}\nSubscription ID : {2}", result.CertificateId, result.Name, result.SubscriptionId);
// Create a Sign Configuration
var signConfigurationRequest = BuildSignConfigurationRequest(configuration);
Log.Information("Creating signconfiguration...");
var signConfigurationResult = await fileSecurityClient.CreateSignConfigurationPdf(signConfigurationRequest).ConfigureAwait(false);
if (signConfigurationResult == null)
{
Log.Error("Couldn't create signconfiguration");
return;
}
Console.WriteLine(
"Configuration created successfully. SignConfiguration ID: {0} \nSignConfiguration Name: {1}\nSubscription ID : {2}",
signConfigurationResult.Id,
signConfigurationResult.Name,
signConfigurationResult.SubscriptionId);
// Get a Sign Configuration
var signConfigurationID = configuration.SignConfigurationDetails.SignConfigurationId;
Log.Information("Fetching sign configuration details for sign configuration id {SignConfigurationId}", configuration.SignConfigurationDetails.SignConfigurationId);
var signConfigurationGetResult = await fileSecurityClient.GetPdfSignConfiguration(signConfigurationID);
if (signConfigurationGetResult == null)
{
Log.Error("Sign configuration not found for id {Id}", configuration.SignConfigurationDetails.SignConfigurationId);
return;
}
Console.WriteLine(
"Sign Configuration Details. \nSignConfiguration ID: {0} " +
"\nSignConfiguration Name: {1}" +
"\nCertificate ID : {2}" +
"\nSubscription ID : {3}" +
"\nCreatedDate : {4}" +
"\nDocumentType : {5}" +
"\nPrivileges : {6}",
signConfigurationGetResult.Id,
signConfigurationGetResult.Name,
signConfigurationGetResult.CertificateId,
signConfigurationGetResult.SubscriptionId,
signConfigurationGetResult.CreatedDate,
"Pdf",
Newtonsoft.Json.JsonConvert.SerializeObject(signConfigurationGetResult.PdfPrivilege, Newtonsoft.Json.Formatting.Indented));
}
private static IEnumerable <GatewayAutomationResult> PreValidateEntities(string folderPath, PublishFileModel publishFileModel, HttpClient httpClient, GatewayOptions options, LogicTokenProviderFactory logicTokenProvider)
{
var preValidations = new List <IPreValidation>
{
new ProductsPreValidation(folderPath),
new ApisPreValidation(folderPath, httpClient, logicTokenProvider, options),
};
var publishResults = new List <GatewayAutomationResult>();
foreach (var validation in preValidations)
{
var results = validation.ValidateAsync(publishFileModel);
publishResults.AddRange(results);
}
return(publishResults);
}
public GatewayClientFactory(LogicTokenProviderFactory logicTokenProviderFactory, HttpClient httpClient, GatewayOptions gatewayOptions)
{
this.logicTokenProviderFactory = logicTokenProviderFactory;
this.httpClient = httpClient;
this.gatewayOptions = gatewayOptions;
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentGenerationClient"/> class.
/// </summary>
/// <param name="httpClient">The HTTP client to use. The caller is expected to manage this resource and it will not be disposed.</param>
/// <param name="tokenProviderFactory">The Logic access token provider factory.</param>
/// <param name="options">The required configuration options.</param>
public DocumentGenerationClient(HttpClient httpClient, LogicTokenProviderFactory tokenProviderFactory, DocumentGenerationOptions options)
: base(httpClient, tokenProviderFactory, options)
{
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using (var httpClient = new HttpClient())
using (var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider))
{
var cvrClient = new CvrClient(httpClient, tokenProviderFactory, configuration.Cvr);
var configs = await cvrClient.GetAllCvrConfigurationsAsync().ConfigureAwait(false);
if (configs == null || configs.Count == 0)
{
Log.Information("There are no CVR configurations defined for this subscription");
return;
}
CvrProviderConfigurationModel cvrProvider;
if (configuration.Cvr.CvrConfigurationId == Guid.Empty)
{
if (configs.Count > 1)
{
Log.Error("There is more than one CVR configuration defined for this subscription");
return;
}
cvrProvider = configs[0];
configuration.Cvr.CvrConfigurationId = cvrProvider.Id.Value;
}
else
{
cvrProvider = configs.FirstOrDefault(x => x.Id == configuration.Cvr.CvrConfigurationId);
if (cvrProvider == null)
{
Log.Error("Invalid CVR configuration id {Id}", configuration.Cvr.CvrConfigurationId);
return;
}
}
Log.Information("Fetching {Cvr} using configuration {Name}", configuration.CvrNumber, cvrProvider.Name);
var company = await cvrClient.GetCompanyByCvrAsync(configuration.CvrNumber).ConfigureAwait(false);
Log.Information("Company data: {@Company}", company);
Log.Information("Fetching Production Units for CVR number {Cvr}", configuration.CvrNumber);
var productionUnits = await cvrClient.GetProductionUnitsAsync(configuration.CvrNumber).ConfigureAwait(false);
if (productionUnits == null || productionUnits.Count == 0)
{
Log.Information("There is no Production Unit defined for this company");
return;
}
Log.Information("Production Units data for Company {@CompanyName}: {@ProductionUnits}", company.CompanyName, productionUnits);
Log.Information("Fetching Production Unit Detail for production unit number {PNumber}", productionUnits[0].PNumber);
var productionUnitDetail = await cvrClient.GetProductionUnitDetailAsync(productionUnits[0].PNumber).ConfigureAwait(false);
Log.Information("Production Unit Detail data: {@ProductionUnitDetail}", productionUnitDetail);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CprClient"/> class.
/// </summary>
/// <param name="httpClient">The HTTP client to use. The caller is expected to manage this resource and it will not be disposed.</param>
/// <param name="tokenProviderFactory">The Logic access token provider factory.</param>
/// <param name="options">The required configuration options.</param>
public CprClient(HttpClient httpClient, LogicTokenProviderFactory tokenProviderFactory, CprOptions options)
{
this.httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.tokenProviderFactory = tokenProviderFactory ?? throw new ArgumentNullException(nameof(tokenProviderFactory));
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using (var httpClient = new HttpClient())
using (var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider))
{
var documentGenerationClient = new DocumentGenerationClient(httpClient, tokenProviderFactory, configuration.DocumentGeneration);
var subject = string.Empty;
var mergeData = JObject.Parse(File.ReadAllText($"values/{CustomerDataFileName}"));
ITemplateStorageConfiguration sampleTemplateStorageConfiguration;
if (configuration.ConfigurationSample.UseAzureBlob)
{
sampleTemplateStorageConfiguration = new AzureBlobTemplateStorage(
configuration.AzureBlobSample.StorageConnectionString,
configuration.AzureBlobSample.ContainerName,
configuration.AzureBlobSample.BlobPrefix);
}
else
{
sampleTemplateStorageConfiguration = new SharePointOnlineTemplateStorage(
configuration.SharePointOnlineSample.ClientId,
configuration.SharePointOnlineSample.TenantId,
configuration.SharePointOnlineSample.ClientSecret,
configuration.SharePointOnlineSample.GroupName);
}
var configurationId = configuration.ConfigurationSample.ConfigurationId ?? throw new Exception("Configuration Id not configured");
// Get an existing document generation configuration of template storage directories
DiagnosticLog("Getting a document generation template storage configuration.");
var documentGenerationConfiguration =
await documentGenerationClient.GetDocumentGenerationConfiguration(configurationId).ConfigureAwait(false);
// Update the existing configuration
documentGenerationConfiguration.Name = "ConfigurationSample Name";
documentGenerationConfiguration.LevelNames = new[] { "one", "two" };
documentGenerationConfiguration.MetadataFilenameExtension = "json";
// Create a root directory for this configuration
var rootTemplateStorageDirectory =
documentGenerationConfiguration.SetRootTemplateStorageDirectory(
"Root directory",
sampleTemplateStorageConfiguration);
// Create a hierarchy of sub directories.
// In this case each sub directory is really the Logic template storage area for this subscription,
// so they'll all resolve to the same place server side.
foreach (var childKey in new[] { "schoolone", "schooltwo" })
{
var childEntry =
rootTemplateStorageDirectory.AddChild(
documentGenerationConfiguration.CreateDocumentGenerationTemplateStorageDirectory(
childKey,
$"school {childKey}",
sampleTemplateStorageConfiguration));
foreach (var grandChildKey in new[] { "A", "B", "C" })
{
childEntry.AddChild(
grandChildKey,
$"dept {grandChildKey}",
sampleTemplateStorageConfiguration);
}
}
// Save the created configuration to the Logic server
{
DiagnosticLog("Saving the rebuilt document generation template storage configuration.");
await documentGenerationConfiguration.Save().ConfigureAwait(false);
DiagnosticLog("Document generation template storage configuration uploaded.");
}
// For the sake of the sample, load the configuration from the sever.
// This is not really required to proceed.
{
DiagnosticLog("Downloading the saved document generation template storage configuration.");
documentGenerationConfiguration =
await documentGenerationClient.GetDocumentGenerationConfiguration(documentGenerationConfiguration.Id).ConfigureAwait(false);
DiagnosticLog($"Document generation template storage configuration \"{documentGenerationConfiguration.Name}\" downloaded.");
}
// For the sake of the sample, modify the configuration and upload again.
// This is not required to proceed.
{
DiagnosticLog("Modifying and uploading the document generation template storage configuration.");
var modifyThisTemplateDirectory =
documentGenerationConfiguration.FindDirectoryByPath(new HierarchyPath(new[] { string.Empty, "schooltwo", "B" }));
modifyThisTemplateDirectory.Key = "BModified";
await documentGenerationConfiguration.Save().ConfigureAwait(false);
DiagnosticLog($"Document generation template storage configuration \"{documentGenerationConfiguration.Name}\" modified and uploaded.");
}
// Choose an arbitrary template directory
var hierarchyPath = new HierarchyPath(new[] { string.Empty, "schooltwo", "BModified" });
var templateDirectory = documentGenerationConfiguration.FindDirectoryByPath(hierarchyPath);
try
{
// Get all the templates relative to that template directory and ancestor directories
var templates =
(await templateDirectory.GetTemplates(subject).ConfigureAwait(false))
.ToDictionary(t => t.TemplateId, t => t);
// If the template we're interested in hasn't been uploaded to the storage area, don't continue.
if (!templates.TryGetValue(BasicWordTemplateId, out var template))
{
DiagnosticLog($"Unable to find {BasicWordTemplateId} in the template storage area");
throw new Exception("Finishing prematurely");
}
var language = template.Languages.FirstOrDefault() ?? string.Empty;
// Get the template metadata if it exists
try
{
var metadataStream =
await templateDirectory.GetMetadata(BasicWordTemplateId, language)
.ConfigureAwait(false);
var metadataFilename = GetTempFilename("Metadata_for_" + BasicWordTemplateId, "json");
await using (var fs = new FileStream(metadataFilename, FileMode.Create, FileAccess.Write, FileShare.None))
{
await metadataStream.CopyToAsync(fs).ConfigureAwait(false);
}
DiagnosticLog($"Template metadata written to {metadataFilename}");
}
catch (DocumentGenerationException d)
{
DiagnosticLog($"Unable to get template metadata: {d.Message}");
}
// Request a document be generated using a template found in the templateDirectory or in ancestor directories
DiagnosticLog($"Requesting a document be generated using template {BasicWordTemplateId} found in {hierarchyPath} or in ancestor directories");
var documentGenerationProgress =
await templateDirectory.RequestDocumentGeneration(
template.TemplateId,
language,
DocumentFormat.Docx,
mergeData,
null,
false,
new Guid("11111111-1111-1111-1111-111111111111"))
.ConfigureAwait(false);
var documentGenerationRequestId = documentGenerationProgress?.Id;
Uri downloadLink;
if (documentGenerationRequestId == null)
{
DiagnosticLog($"Unable to request document generation");
throw new Exception("Finishing prematurely");
}
try
{
downloadLink = await PollForProgress(documentGenerationConfiguration, documentGenerationRequestId.Value).ConfigureAwait(false);
}
catch (Exception e)
{
throw new Exception($"Generation failed for {template.TemplateId}. Finishing prematurely", e);
}
if (downloadLink == null)
{
DiagnosticLog($"Generation took too long. Finishing prematurely");
return;
}
DiagnosticLog($"{template.TemplateId}: secure download link found: {downloadLink}");
var filename = GetTempFilename(template.TemplateId, DocumentFormat.Docx.ToString().ToLower());
await DownloadToFilesystem(downloadLink, filename, $"Generated {template.TemplateId}").ConfigureAwait(false);
// Request the new document be converted to Pdf/A
DiagnosticLog($"Requesting the generated document be converted to Pdf/A");
var conversionProgress =
await documentGenerationConfiguration.RequestDocumentConversionToPdfA(
new DocumentConversionToPdfARequestDetails(
downloadLink,
DocumentFormat.Docx))
.ConfigureAwait(false);
var conversionProgressId = conversionProgress?.Id;
Uri convertedDocumentDownloadLink;
if (conversionProgressId == null)
{
DiagnosticLog($"Unable to request document conversion");
throw new Exception("Finishing prematurely");
}
else
{
try
{
convertedDocumentDownloadLink =
await PollForProgress(documentGenerationConfiguration, conversionProgressId.Value)
.ConfigureAwait(false);
}
catch (Exception e)
{
throw new Exception($"Conversion to Pdf/A failed for {template.TemplateId}. Finishing prematurely", e);
}
}
if (convertedDocumentDownloadLink == null)
{
DiagnosticLog($"Conversion took too long. Finishing prematurely");
return;
}
DiagnosticLog($"{template.TemplateId}: secure download link to rendered document found: {convertedDocumentDownloadLink}");
var convertedDocumentFilename = GetTempFilename(template.TemplateId, DocumentFormat.Pdf.ToString().ToLower());
await DownloadToFilesystem(convertedDocumentDownloadLink, convertedDocumentFilename, $"Rendered {template.TemplateId}").ConfigureAwait(false);
}
catch (Exception e)
{
DiagnosticLog($"{e.Message}/{e.StackTrace}");
}
}
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using (var httpClient = new HttpClient())
using (var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider))
{
var client = new DigitalPostClient(httpClient, tokenProviderFactory, configuration.DigitalPost);
var response = await client.SendMessageAsync(IdentifierType.Cpr, "0101010000", "Hi there", "Digital Post test").ConfigureAwait(false);
var configurations = await client.GetAllConfigurationsAsync().ConfigureAwait(false);
if (configuration.DigitalPost.ConfigurationId == Guid.Empty)
{
if (configurations != null && configurations.Count > 0)
{
if (configurations.Count > 1)
{
Log.Error("There is more than one digital post configuration defined for this subscription");
return;
}
else
{
configuration.DigitalPost.ConfigurationId = configurations[0].Id.Value;
}
}
else
{
Log.Error("There is no digital post configurations defined for this subscription");
return;
}
}
else
{
var usedConfig = configurations.FirstOrDefault(x => x.Id == configuration.DigitalPost.ConfigurationId);
if (usedConfig == null)
{
Log.Error("The specified digital post configuration does not exist");
return;
}
else
{
Log.Information("Using configuration {Name} for environment {Environment}", usedConfig.Name, usedConfig.Environment);
}
}
MessageAttachment document = null;
using (var stream = File.OpenRead(configuration.DocumentPath))
{
var uploadResponse = await client.UploadAttachmentAsync(stream).ConfigureAwait(false);
if (uploadResponse == null || uploadResponse.ReferenceId == null)
{
Log.Error("Unable to upload attachment {Path}", configuration.DocumentPath);
return;
}
document = uploadResponse.ToAttachment(Path.GetFileName(configuration.DocumentPath));
}
Log.Information("Attachment was uploaded and got ReferenceId {ReferenceId}", document.ReferenceId);
var result = await client.SendDocumentAsync(
configuration.IdentifierType.Value,
configuration.Identifier,
document,
configuration.Title,
configuration.MaterialId,
configuration.PNumber,
configuration.Metadata)
.ConfigureAwait(false);
Log.Information("Document was sent and got MessageId {MessageId}", result.MessageId);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogicHttpClientProvider"/> class.
/// </summary>
/// <param name="httpClient">The HTTP client to use. The caller is expected to manage this resource and it will not be disposed.</param>
/// <param name="tokenProviderFactory">The Logic access token provider factory.</param>
/// <param name="options">The required configuration options.</param>
protected LogicHttpClientProvider(HttpClient httpClient, LogicTokenProviderFactory tokenProviderFactory, DocumentGenerationOptions options)
{
this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
this._options = options ?? throw new ArgumentNullException(nameof(options));
this._tokenProviderFactory = tokenProviderFactory ?? throw new ArgumentNullException(nameof(tokenProviderFactory));
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using var httpClient = new HttpClient();
using var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider);
using var cprClient = new CprClient(httpClient, tokenProviderFactory, configuration.Cpr);
Guid?newlyCreatedConfigId = null;
if (configuration.Cpr.CprConfigurationId == Guid.Empty)
{
Log.Information("Creating new fake provider configuration.");
var result = await cprClient
.CreateFakeProviderConfiguration($"Test-{Guid.NewGuid()}")
.ConfigureAwait(false);
newlyCreatedConfigId = result.Id;
var configurationId = newlyCreatedConfigId.GetValueOrDefault();
cprClient.SwitchConfiguration(configurationId);
Log.Information("Configuration created with id {id}", configurationId);
}
var configs = await cprClient
.GetAllCprConfigurationsAsync()
.ConfigureAwait(false);
if (configs == null)
{
Log.Error(
"There was a problem when getting CPR configurations.");
return;
}
else if (configs.Count == 0 && configuration.Cpr.CprConfigurationId != Guid.Empty)
{
Log.Error(
"There are no CPR configurations defined for this subscription and configuration id is defined in configuration file.");
return;
}
CprProviderConfigurationModel cprProvider;
if (configuration.Cpr.CprConfigurationId == Guid.Empty)
{
if (newlyCreatedConfigId.HasValue)
{
cprProvider = configs.FirstOrDefault(x => x.Id == newlyCreatedConfigId.Value);
}
else if (configs.Count > 1)
{
Log.Error("There is more than one CPR configuration defined for this subscription");
return;
}
else
{
cprProvider = configs[0];
configuration.Cpr.CprConfigurationId = cprProvider.Id.Value;
}
}
else
{
cprProvider = configs.FirstOrDefault(x => x.Id == configuration.Cpr.CprConfigurationId);
if (cprProvider == null)
{
Log.Error("Invalid CPR configuration id {Id}", configuration.Cpr.CprConfigurationId);
return;
}
}
Log.Information("Fetching {Cpr} using configuration {Name}", configuration.CprNumber, cprProvider.Name);
var citizen = await cprClient.GetCitizenByCprAsync(configuration.CprNumber).ConfigureAwait(false);
Log.Information("Citizen data: {@Citizen}", citizen);
var detailedCitizen = await cprClient.GetCitizenDetailsByCprAsync(configuration.CprNumber).ConfigureAwait(false);
Log.Information("Detailed citizen data: {@Citizen}", detailedCitizen);
var citizenList = await cprClient.GetAllCprEventsAsync(DateTime.Today.AddMonths(-2), DateTime.Today, 1, 10).ConfigureAwait(false);
if (citizenList == null)
{
Log.Error("Error in retriving citizen list");
return;
}
var success = await cprClient.SubscribeByCprAsync(configuration.CprNumber).ConfigureAwait(false);
if (!success)
{
Log.Error("Invalid CPR Number {@CprNumber}", configuration.CprNumber);
return;
}
Log.Information("Subscribed successfully for CprNumber {CprNumber}", configuration.CprNumber);
success = await cprClient.SubscribeByIdAsync(citizen.Id).ConfigureAwait(false);
if (!success)
{
Log.Error("Invalid CPR PersonId {personId}", citizen.Id);
return;
}
Log.Information("Subscribed successfully for personId {personId}", citizen.Id);
success = await cprClient.UnsubscribeByCprAsync(configuration.CprNumber).ConfigureAwait(false);
if (success)
{
Log.Information("Unsubscribed successfully for CprNumber {CprNumber}", configuration.CprNumber);
}
success = await cprClient.UnsubscribeByIdAsync(citizen.Id).ConfigureAwait(false);
if (success)
{
Log.Information("Unsubscribed successfully for personId {personId}", citizen.Id);
}
int pageNo = 1;
int pageSize = 100;
var subscribedCitizenList = await cprClient.GetSubscribedCprEventsAsync(DateTime.Today.AddMonths(-2), DateTime.Today, pageNo, pageSize).ConfigureAwait(false);
if (subscribedCitizenList == null)
{
Log.Error("Error in retriving subscribed citizen list");
return;
}
while (subscribedCitizenList.ActualCount > 0)
{
subscribedCitizenList = await cprClient.GetSubscribedCprEventsAsync(DateTime.Today.AddMonths(-2), DateTime.Today, ++pageNo, pageSize).ConfigureAwait(false);
if (subscribedCitizenList == null)
{
Log.Error("Error in retriving subscribed citizen list");
return;
}
}
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using (var httpClient = new HttpClient())
using (var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider))
{
var documentGenerationClient = new DocumentGenerationClient(httpClient, tokenProviderFactory, configuration.DocumentGeneration);
var configurationId = configuration.GenerationSample.ConfigurationId ?? throw new Exception("Validation should have reported no ConfigurationId set");
var hierarchyPath = configuration.GenerationSample.HierarchyPath;
var subject = configuration.GenerationSample.Subject;
var mergeData = JObject.Parse(File.ReadAllText($"values/{CustomerDataFileName}"));
try
{
var templates =
(await documentGenerationClient.GetTemplates(configurationId, hierarchyPath, subject)
.ConfigureAwait(false))
.ToDictionary(t => t.TemplateId, t => t);
var allFormats = Enum.GetValues(typeof(DocumentFormat)).Cast <DocumentFormat>().ToArray();
var documentDetailsList = new List <DocumentDetails>();
foreach (var templateId in new[] { BasicWordTemplateId, WordWithPartialTemplateId, WordToSaveAsTxtTemplateId })
{
if (!templates.TryGetValue(templateId, out var template))
{
DiagnosticLog($"Unable to find {templateId} in the template storage area");
continue;
}
await GetMetaDataForTemplate(documentGenerationClient, configurationId, template, hierarchyPath).ConfigureAwait(false);
foreach (var format in allFormats)
{
var documentDetails = new GeneratedDocumentDetails
{
ConfigurationId = configurationId,
HierarchyPath = hierarchyPath,
Template = template,
MergeData = mergeData,
DocumentFormat = format,
Description = $"Generated from {template.TemplateId} to {format}",
};
await documentGenerationClient.GenerateDocumentFromTemplate(documentDetails)
.ConfigureAwait(false);
if (documentDetails.AnchorDetails != null)
{
documentDetailsList.Add(documentDetails);
if (documentDetails.AnchorDetails.Href != null)
{
var convertedDocumentDetails = new ConvertedDocumentDetails
{
ConfigurationId = configurationId,
SourceDocumentUrl = documentDetails.AnchorDetails.Href,
SourceDocumentFormat = format,
DocumentFormat = DocumentFormat.Pdf,
Description = $"Rendered from ({documentDetails.Description})",
};
await documentGenerationClient.RenderPdfAFromDocumentLink(convertedDocumentDetails)
.ConfigureAwait(false);
if (convertedDocumentDetails.AnchorDetails != null)
{
documentDetailsList.Add(convertedDocumentDetails);
}
}
}
}
}
GeneratePageWithDocumentLinks(documentDetailsList);
}
catch (Exception e)
{
DiagnosticLog($"{e.Message}/{e.StackTrace}");
}
}
}
private static async Task Run(AppConfiguration configuration)
{
var validator = new ConfigurationValidator(configuration);
if (!validator.Validate())
{
return;
}
using (var httpClient = new HttpClient())
using (var tokenProviderFactory = new LogicTokenProviderFactory(configuration.TokenProvider))
{
var consentClient = new ConsentClient(httpClient, tokenProviderFactory, configuration.Consent);
var groups = await consentClient.GetAllConsentGroupsAsync().ConfigureAwait(false);
if (configuration.Consent.ConsentGroupId == Guid.Empty)
{
if (groups != null && groups.Count > 0)
{
if (groups.Count > 1)
{
Log.Error("There is more than one consent group defined for this subscription");
return;
}
else
{
configuration.Consent.ConsentGroupId = groups[0].Id.Value;
}
}
else
{
var memberTitle = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(configuration.Consent.ConsentMember);
var scopes = string.IsNullOrEmpty(configuration.ConsentScope)
? null
: new List <string> {
configuration.ConsentScope
};
var newGroup = await consentClient.CreateConsentGroup(
$"{memberTitle} Sample Group",
new List <ConsentGroupMemberRequest>
{
new ConsentGroupMemberRequest
{
Key = configuration.Consent.ConsentMember,
Name = memberTitle,
SubscriptionId = configuration.Consent.SubscriptionId,
Roles = new ConsentRolesRequestResponse
{
CanRead = true,
CanWrite = true,
CanDelete = true,
},
},
},
configuration.ConsentKeyFormat,
scopes).ConfigureAwait(false);
Log.Information("Created consent group {Name} with id {Id}", newGroup.Name, newGroup.Id);
configuration.Consent.ConsentGroupId = newGroup.Id.Value;
}
}
var ownedGroup = groups.FirstOrDefault(x => x.Id == configuration.Consent.ConsentGroupId);
if (ownedGroup != null)
{
Log.Information(
"Consent Group {Id}, {Name} is managed by subscription {SubscriptionId}",
ownedGroup.Id,
ownedGroup.Name,
configuration.Consent.SubscriptionId);
var groupDetails = await consentClient.GetConsentGroupAsync(configuration.Consent.ConsentGroupId).ConfigureAwait(false);
Log.Information("Consent group data: {@Details}", groupDetails);
}
Log.Information("Fetching consent for {Key}", configuration.ConsentKey);
var details = await consentClient.GetConsentAsync(configuration.ConsentKey, configuration.ConsentScope).ConfigureAwait(false);
Log.Information("Consent data: {@Details}", details);
if (details == null)
{
await consentClient.SaveConsentAsync(configuration.ConsentKey).ConfigureAwait(false);
Log.Information("Created new consent for key {Key}", configuration.ConsentKey);
}
if (ownedGroup != null)
{
var consentReview = await consentClient.ReviewConsentAsync(configuration.ConsentKey).ConfigureAwait(false);
if (consentReview != null)
{
Log.Information("Found consent definition {@Definition}", consentReview);
}
else
{
Log.Error("Unable to find consent details for key {Key}", configuration.ConsentKey);
}
}
var deleted = await consentClient.DeleteConsent(configuration.ConsentKey).ConfigureAwait(false);
if (deleted)
{
Log.Information("Consent for key {Key} was revoked", configuration.ConsentKey);
}
else
{
Log.Error("Unable to revoke consent details for key {Key}", configuration.ConsentKey);
}
if (ownedGroup != null)
{
var consentReview = await consentClient.ReviewConsentAsync(configuration.ConsentKey).ConfigureAwait(false);
if (consentReview != null)
{
Log.Error("Unexpectedly found consent definition {@Definition}", consentReview);
}
else
{
Log.Information("Consent details for key {Key} not longer exist, as expected", configuration.ConsentKey);
}
}
}
}
