/// <summary>
/// The Handle
/// </summary>
/// <param name="request">The request<see cref="SendServiceOutPutMessageCommand"/></param>
/// <param name="cancellationToken">The cancellationToken<see cref="CancellationToken"/></param>
/// <returns>The <see cref="Task{MessageProcessResponse}"/></returns>
public async Task <MessageProcessResponse> Handle(SendServiceOutPutMessageCommand request, CancellationToken cancellationToken)
{
ICoreKeyVaultClient keyVault = app.ApplicationServices.GetRequiredService <ICoreKeyVaultClient>();
IntegrationEvent integrationEvent = null;
MessageProcessResponse messageProcessResponse = MessageProcessResponse.Abandon;
try
{
request = request ?? throw new ArgumentNullException(nameof(request));
integrationEvent = PrepareOutputMessage(request.Items, request.Message);
if (request.Status)
{
await sendMngr.SendAsync(await keyVault.GetSecret(BusinessValidationConstants.KEYVAULT_BUSINESSVALIDATIONSUCCESSTOPIC), integrationEvent);
messageProcessResponse = MessageProcessResponse.Complete;
}
else
{
integrationEvent.Body.ServiceOutput = new ServiceOutput();
await sendMngr.SendAsync(await keyVault.GetSecret(BusinessValidationConstants.ErrorTopicNameKeyName), integrationEvent);
messageProcessResponse = MessageProcessResponse.Complete;
}
return(messageProcessResponse);
}
catch (Exception ex)
{
integrationEvent = GetIntegrationEvent(request?.Message);
integrationEvent.Body.ServiceOutput = new ServiceOutput();
await sendMngr.SendAsync(await keyVault.GetSecret(BusinessValidationConstants.KEYVAULT_ERRORTOPICNAME), integrationEvent);
Log.Error(ex.Message);
return(MessageProcessResponse.Abandon);
}
}
/// <summary>
/// The ValidateNetbsadAsync
/// </summary>
/// <param name="aggregate">The aggregate<see cref="Aggregate{Disbsad}"/></param>
/// <returns>The <see cref="Task{BusinessValidationProxy}"/></returns>
private async Task <BusinessValidationProxy> ValidateDisbsadAsync(Aggregate <Disbsad> aggregate)
{
outbound = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_PROCESSING);
rejected = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_REJECTED);
try
{
validator.ValidateAndThrow(aggregate, ruleSet: BusinessValidationConstants.ERRORCHECK);
var warningResult = validator.Validate(aggregate, ruleSet: BusinessValidationConstants.WARNINGCHECK);
if (aggregate.ValidFlow.Any())
{
await UploadDisBsadRecordsAsSucceeded(aggregate);
}
if (aggregate.InValidFlow.Any())
{
warningResult.LogErrorMessage();
await UploadAndPublishRecordsAsRejected(aggregate);
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
aggregate.ErrorMessage = ex.Message;
businessValidationProxy.ErrorMessages.Add(ex.Message);
}
return(businessValidationProxy);
}
public static void RegisterBlob(this IServiceCollection services, ICoreKeyVaultClient keyVaultClient)
{
string storageAccount = Task.Run(async() => await keyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_STORAGEACCOUNT)).Result;
string storageKey = Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_STORAGEKEY)).Result;
string containerName = Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_CONTAINERNAME)).Result;
services.AddScoped <ICoreBlobStorage, CoreBlobStorage>(factory =>
{
return(new CoreBlobStorage(new CoreBlobSettings(storageAccount, storageKey, containerName)));
});
}
/// <summary>
/// The GetConfigurationDataFromKeyVault
/// </summary>
/// <param name="aggregate">The aggregate<see cref="Aggregate{Bod}"/></param>
private async Task GetConfigurationDataFromKeyVault(Aggregate <Bod> aggregate)
{
var settlementDuration = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_SETTLEMENTDURATION);
var minPairId = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_MINPAIRID);
var maxPairId = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_MAXPAIRID);
aggregate.MaxPairId = int.Parse(maxPairId);
aggregate.MinPairId = int.Parse(minPairId);
aggregate.SettlementDuration = int.Parse(settlementDuration);
}
public static void RegisterServiceBus(this IServiceCollection services, ICoreKeyVaultClient keyVaultClient)
{
services.AddSingleton <ICoreMessageHeader, CoreMessageHeader>();
string serviceBusConnectionString = Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_SERVICEBUSCONNECTIONSTRING)).Result;
string receiveTopic = Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_RECEIVETOPIC)).Result;
string subscriptionName = Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_SUBSCRIPTIONNAME)).Result;
services.AddSingleton <ISendManager, SendManager>(_ => new SendManager(new CoreTopicSettings(serviceBusConnectionString)));
services.AddSingleton <IReceiveManager, ReceiveManager>(_ =>
{
return(new ReceiveManager(new CoreSubscriptionSettings(serviceBusConnectionString, receiveTopic, subscriptionName)));
});
}
/// <summary>
/// The GetBMUParticipationAsync
/// </summary>
/// <param name="TimeFrom">The TimeFrom<see cref="DateTime"/></param>
/// <param name="TimeTo">The TimeTo<see cref="DateTime"/></param>
/// <returns>The <see cref="Task{List{ParticipantEnergyAsset}}"/></returns>
public async Task <List <ParticipantEnergyAsset> > GetBmuParticipationAsync(DateTime TimeFrom, DateTime TimeTo)
{
List <ParticipantEnergyAsset> result = new List <ParticipantEnergyAsset>();
try
{
string timeFrom = TimeFrom.ToString(BusinessValidationConstants.DATETIMEFORMAT);
string timeTo = TimeTo.ToString(BusinessValidationConstants.DATETIMEFORMAT);
var url = GetPath(await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_TABLEAPIURL), timeFrom, timeTo);
var configSystemParamJsonData = await corehttpServiceClient.GetAsync <List <ParticipantEnergyAsset> >(url);
result = configSystemParamJsonData;
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
return(result);
}
/// <summary>
/// The ProcessFileForInValidRecords
/// </summary>
/// <param name="aggregate">The aggregate<see cref="Aggregate{Boalf}"/></param>
/// <returns>The <see cref="Task"/></returns>
private async Task ProcessFileForInValidRecords(Aggregate <Boalf> aggregate)
{
try
{
string rejected = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_REJECTED);
string path = Common.GetRejectedFolderPath(rejected);
var newPath = BusinessValidationConstants.BOALF + DateTime.Now.ToString(BusinessValidationConstants.DATEFORMATE) + BusinessValidationConstants.FILEEXTENSION;
await UploadAcceptance(aggregate.InValidFlow, path.Replace(BusinessValidationConstants.BOALFFILE, newPath, StringComparison.CurrentCultureIgnoreCase));
aggregate.InValidPath.Add(path);
await writer.UpdateFileStatus(Common.GetStatusOfRejectedFile(aggregate.InValidPath.FirstOrDefault(), BusinessValidationConstants.WARNING));
Log.Information(BusinessValidationConstants.LOGMESSAGES_BOALFFAILUREMESSAGE);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
/// <summary>
/// The GetConfigurationDataFromKeyVault
/// </summary>
/// <param name="aggregate">The aggregate<see cref="Aggregate{Boalf}"/></param>
private async Task GetConfigurationDataFromKeyVault(Aggregate <Boalf> aggregate)
{
try
{
var settlementDuration = await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_SETTLEMENTDURATION);
aggregate.SettlementDuration = int.Parse(settlementDuration);
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
}
/// <summary>
/// The GetConfigurationDataFromKeyVault
/// </summary>
/// <param name="aggregate">The aggregate<see cref="Aggregate{Fpn}"/></param>
private async Task GetConfigurationDataFromKeyVault(Aggregate <Fpn> aggregate)
{
var settlementDuration = await _coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_SETTLEMENTDURATION);
aggregate.SettlementDuration = int.Parse(settlementDuration);
}
/// <summary>
/// The UpdateFileStatus
/// </summary>
/// <param name="statusTableEntity">The statusTableEntity<see cref="StatusTableEntity"/></param>
/// <returns>The <see cref="Task"/></returns>
public async Task UpdateFileStatus(StatusTableEntity statusTableEntity)
{
string status = JsonConvert.SerializeObject(statusTableEntity);
var url = GetPath(await coreKeyVaultClient.GetSecret(BusinessValidationConstants.KEYVAULT_STATUSTABLEURL), status);
await corehttpServiceClient.GetAsync <StatusTableEntity>(url);
}
public static void RegisterLogs(this IServiceCollection services, ICoreKeyVaultClient keyVaultClient)
{
Log.Init(Task.Run(async() => await keyVaultClient?.GetSecret(BusinessValidationConstants.KEYVAULT_APPLICATIONINSIGHTSKEY)).Result, BusinessValidationConstants.LOGGINGLEVEL,
BusinessValidationConstants.BUSINESSVALIDATION, BusinessValidationConstants.BUSINESSVALIDATION);
}
