public async Task <IActionResult> Create([FromBody] DispatchRequest dispatchRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = new DispatchResponse()
{
ResponseResult = new ResponseResult(dispatchRequest.RequestHeader.RequestId)
};
try
{
DispatchRequestDTO dto = GetDispatchRequestDtoFromRequest(dispatchRequest);
var command = new SubmitDispatchCommand(dto,
JsonConvert.SerializeObject(dispatchRequest),
dispatchRequest.GetType().Name);
try
{
var id = await _mediator.Send(command);
result.Reference = new DispatchReferenceResponse
{
DispatchNumber = id,
DispatchDate = dto.DispatchDate
};
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
catch (Exception e)
{
result.ResponseResult.Errors = new List <ErrorDetail>()
{
new ErrorDetail()
{
ErrorCode = "-1",
ErrorMessage = e.Message
}
};
return(BadRequest(result));
}
return(Ok(result));
}
private void WebService_OnMessageReceive(string message)
{
GatewayResponse response = json.Deserialize <GatewayResponse>(message);
if (response == null)
{
return;
}
switch (response.Op)
{
case Op.Hello:
HelloResponse hello = json.Deserialize <HelloResponse>(message);
heartbeatInterval = hello.D.Heartbeat_Interval;
OnConnected();
break;
case Op.Dispatch:
DispatchResponse dispatch = json.Deserialize <DispatchResponse>(message);
lastReceived = dispatch.S;
switch (dispatch.T)
{
case "READY":
heartbeatTimer = new Timer(
async(_) => await webService.Send(json.Serialize(new HeartbeatMessage()
{
d = lastReceived
})),
null,
0,
heartbeatInterval
);
break;
case "MESSAGE_CREATE":
MessageCreateResponse messageResponse = json.Deserialize <MessageCreateResponse>(message);
OnReceiveMessage(messageResponse.D);
break;
default:
Console.WriteLine(message);
break;
}
break;
default:
Console.WriteLine(message);
break;
}
}
/// <summary>
/// The method to push agent info to the respective target
/// </summary>
/// <param name="target"></param>
/// <returns>An instance of DispatchResponse</returns>
public async Task <DispatchResponse> PushAgentInfo(ActivityOrigin target)
{
DispatchResponse response = new DispatchResponse();
if (target == ActivityOrigin.EStart)
{
response = await PushToEStart();
}
else
{
response.Status = ProcessStatus.Failed.ToString();
response.Message = Messages.AgentExportNotAllowed;
}
return(response);
}
public async Task <IDispatchResponse> DispatchRequestAsync(IRequest request)
{
var deferredResponse = new DeferredResponse($"async-{request.RequestType}-{Guid.NewGuid()}");
var tcs = new TaskCompletionSource();
_valueSubscriptions.TryAdd(deferredResponse.Uri, tcs);
var dispatchResponse = new DispatchResponse(deferredResponse, tcs.Task);
var sender = _serviceBusClient.CreateSender(request.RequestType);
var message = new ServiceBusMessage(JsonConvert.SerializeObject(request));
message.ApplicationProperties.Add("deferred-uri", deferredResponse.Uri);
await sender.SendMessageAsync(message);
return(dispatchResponse);
}
private static void Main(string[] args)
{
Task.Run(() =>
{
try
{
// initialize settings
Init();
Console.WriteLine($"Processor is now running...");
ConnectionFactory factory = new ConnectionFactory();
factory.UserName = ApplicationSettings.RabbitMQUsername;
factory.Password = ApplicationSettings.RabbitMQPassword;
factory.HostName = ApplicationSettings.RabbitMQHostname;
factory.Port = ApplicationSettings.RabbitMQPort;
factory.RequestedHeartbeat = 60;
factory.DispatchConsumersAsync = true;
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(queue: ApplicationSettings.DispatchQueueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
DispatchResponse response = new DispatchResponse
{
IsSucceded = true,
ResultId = (int)DispatchResponseEnum.Success
};
// forced-to-disposal
Report report = null;
PDFHelper pdfHelper = null;
MongoDBHelper mongoDBHelper = null;
SendGridHelper sendGridHelper = null;
try
{
byte[] body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var decrypted = string.Empty;
decrypted = NETCore.Encrypt.EncryptProvider.AESDecrypt(message, secret);
var obj_decrypted = JsonConvert.DeserializeObject <DispatchMessage>(decrypted);
//operation id
string guid = Guid.NewGuid().ToString();
// PDF
string pdf = string.Empty;
pdfHelper = new PDFHelper();
pdf = pdfHelper.Create(guid, converter, obj_decrypted);
Console.WriteLine($">> PDF generated successfully");
// MongoDB
report = new Report();
report.fullname = obj_decrypted.Fullname;
report.email = obj_decrypted.Email;
mongoDBHelper = new MongoDBHelper(mongoDBConnectionInfo);
await mongoDBHelper.RegisterReportAsync(report);
Console.WriteLine($">> Record saved successfully");
// SendGrid
sendGridHelper = new SendGridHelper();
await sendGridHelper.SendReportEmailAsync(obj_decrypted.Email, obj_decrypted.Fullname, pdf);
Console.WriteLine($">> Email: {obj_decrypted.Email} sent successfully");
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine($">> Acknowledgement completed, delivery tag: {ea.DeliveryTag}");
}
catch (Exception ex)
{
if (ex is BusinessException)
{
response.IsSucceded = false;
response.ResultId = ((BusinessException)ex).ResultId;
string message = EnumDescription.GetEnumDescription((DispatchResponseEnum)response.ResultId);
Console.WriteLine($">> Message information: {message}");
}
else
{
Console.WriteLine($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
Console.WriteLine($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
}
finally
{
report = null;
pdfHelper.Dispose();
mongoDBHelper.Dispose();
sendGridHelper.Dispose();
}
};
string consumerTag = channel.BasicConsume(ApplicationSettings.DispatchQueueName, false, consumer);
}
catch (Exception ex)
{
Console.WriteLine($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
Console.WriteLine($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
});
// handle Control+C or Control+Break
Console.CancelKeyPress += (o, e) =>
{
Console.WriteLine("Exit");
// allow the manin thread to continue and exit...
waitHandle.Set();
};
// wait
waitHandle.WaitOne();
}
public async Task <IActionResult> Post([FromBody] DispatchRequest dispatchRequest)
{
// non-forced-to-disposal
DispatchResponse response = new DispatchResponse
{
IsSucceded = true,
ResultId = (int)DispatchResponseEnum.Success
};
// forced-to-disposal
KeyVaultConnectionInfo keyVaultConnectionInfo = null;
try
{
if (string.IsNullOrEmpty(dispatchRequest.Fullname))
{
throw new BusinessException((int)DispatchResponseEnum.FailedEmptyFullname);
}
if (string.IsNullOrEmpty(dispatchRequest.Email))
{
throw new BusinessException((int)DispatchResponseEnum.FailedEmptyFullname);
}
keyVaultConnectionInfo = new KeyVaultConnectionInfo()
{
CertificateName = ApplicationSettings.KeyVaultCertificateName,
ClientId = ApplicationSettings.KeyVaultClientId,
ClientSecret = ApplicationSettings.KeyVaultClientSecret,
KeyVaultIdentifier = ApplicationSettings.KeyVaultIdentifier
};
using (MessageQueueHelper messageQueueHelper = new MessageQueueHelper())
{
DispatchMessage dispatchMessage = new DispatchMessage()
{
Fullname = dispatchRequest.Fullname,
Email = dispatchRequest.Email
};
await messageQueueHelper.QueueMessageAsync(dispatchMessage, ApplicationSettings.DispatchQueueName, keyVaultConnectionInfo);
}
}
catch (Exception ex)
{
response.IsSucceded = false;
if (ex is BusinessException)
{
response.ResultId = ((BusinessException)ex).ResultId;
}
else
{
response.ResultId = (int)DispatchResponseEnum.Failed;
this.logger.LogError($">> Exception: {ex.Message}, StackTrace: {ex.StackTrace}");
if (ex.InnerException != null)
{
this.logger.LogError($">> Inner Exception Message: {ex.InnerException.Message}, Inner Exception StackTrace: {ex.InnerException.StackTrace}");
}
}
}
finally
{
keyVaultConnectionInfo = null;
GC.Collect();
}
string message = EnumDescription.GetEnumDescription((DispatchResponseEnum)response.ResultId);
this.logger.LogInformation($">> Message information: {message}");
return((response.IsSucceded) ? (ActionResult) new OkObjectResult(new { message = message }) : (ActionResult) new BadRequestObjectResult(new { message = message }));
}
