public QueueConnectionManager(IOptions <QueueConnectionSettings> queueConnectionSettings,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <QueueConnectionManager>();
_queueConnectionSettings = queueConnectionSettings;
Connect();
}
public WeatherService(
IApiLogger <WeatherService> logger,
IEnumerable <IWeatherRemoteApiClient> weatherServiceClients)
{
_logger = logger;
_weatherServiceClients = weatherServiceClients;
}
public CountryService(
IApiLogger <CountryService> logger,
ICountryRemoteApiClient countryServiceClient)
{
_logger = logger;
_countryServiceClient = countryServiceClient;
}
public WeatherController(
IApiLogger <WeatherController> logger,
ICountryService countryService,
IWeatherService weatherService)
{
_logger = logger;
_countryService = countryService;
_weatherService = weatherService;
}
public IntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.SetupQueue(_settings);
}
public TransactionProcessorIntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.CreateExchange(_settings);
}
public async Task Invoke(HttpContext context, IApiLogger logger)
{
try
{
await _next(context);
}
catch (Exception ex)
{
logger.LogException(ex);
}
}
public async Task Invoke(HttpContext context, IApiLogger logger)
{
logger.LogInformation(await GetRequestLogging(context), LoggingType.Request);
var bodyStream = context.Response.Body;
var responseBodyStream = new MemoryStream();
context.Response.Body = responseBodyStream;
await _next(context);
logger.LogInformation(await GetResponseLogging(context.Response, context.Request.Path, responseBodyStream, bodyStream), LoggingType.Response);
}
public QueueListener(ILoggerFactory loggerFactory,
IQueueChannelManager queueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory queueFactory,
IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_logger = loggerFactory.GetLogger <QueueListener>();
_settings = queueSettingsResolver.GetSettings(nameof(QueueListener));
_channel = queueChannelManager.GetChannel();
_consumer = new EventingBasicConsumer(_channel);
queueFactory.SetupQueue(_settings);
}
public async Task Invoke(HttpContext context, IApiLogger logger)
{
var currentBody = context.Response.Body;
using (var memoryStream = new MemoryStream())
{
//set the current response to the memorystream.
context.Response.Body = memoryStream;
try
{
await _next(context);
}
catch (Exception e)
{
logger.LogException(e);
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
//reset the body
context.Response.Body = currentBody;
memoryStream.Seek(0, SeekOrigin.Begin);
var readToEnd = new StreamReader(memoryStream).ReadToEnd();
var objResult = JsonConvert.DeserializeObject(readToEnd);
if (context.Response.StatusCode > 400 && objResult == null)
{
var result = StausCodeMapper.Map((HttpStatusCode)context.Response.StatusCode);
//Ideally this should be retrieved from System.Net.Mime.Mediatypes but application/json does not yet exist
//So manually added the exact type with charset from an example response that's set by asp.net core (used the else part
//of this if to see what asp.net core uses by default)
//See: https://github.com/dotnet/corefx/issues/24895
context.Response.ContentType = "application / json; charset = utf - 8";
await context.Response.WriteAsync(JsonConvert.SerializeObject(result));
}
else
{
await context.Response.WriteAsync(JsonConvert.SerializeObject(objResult));
}
}
}
public TransactionGeneratorService(IServiceProvider serviceProvider)
{
_serviceScope = serviceProvider.CreateScope();
var loggerFactory = _serviceScope.ServiceProvider.GetServiceOrThrow <ILoggerFactory>();
_logger = loggerFactory.GetLogger <TransactionGeneratorService>();
_transactionFeedService = _serviceScope.ServiceProvider.GetService(typeof(IIntegrationEventQueue)) as IIntegrationEventQueue;
_db = _serviceScope.ServiceProvider.GetService(typeof(FundContext)) as FundContext;
_merchants = new Dictionary <Guid, string>()
{
{ Guid.NewGuid(), "Merchant 1" },
{ Guid.NewGuid(), "Merchant 2" },
{ Guid.NewGuid(), "Merchant 3" },
{ Guid.NewGuid(), "Merchant 4" },
{ Guid.NewGuid(), "Merchant 5" },
{ Guid.NewGuid(), "Merchant 6" },
{ Guid.NewGuid(), "Merchant 7" },
{ Guid.NewGuid(), "Merchant 8" },
{ Guid.NewGuid(), "Merchant 9" },
{ Guid.NewGuid(), "Merchant 10" }
};
}
private Country GetWeather(IApiLogger <WeatherService> logger, string countryName, string cityName)
{
/* Work through available weather services until we find data.
* Similar approach to factory pattern, however, intention in here to provide more flexibility to
* add new clients later, through DI, without modifying the existing code
* */
foreach (var weatherService in _weatherServiceClients)
{
try
{
var weather = weatherService.GetWeather(countryName, cityName);
if (weather != null)
{
return(weather);
}
}
catch (Exception exp)
{
logger.Error("WeatherService failed at GetWeather", exp);
}
}
return(null);
}
public T InvokeApi <T>(string url, ApiRequestData data, IApiLogger logger)
{
string value = "";
try
{
var request = (HttpWebRequest)WebRequest.Create(url);
request.Credentials = CredentialCache.DefaultCredentials;
request.Timeout = data.requestTimeout;
// headers
if (data.acceptHeader != null)
{
request.Accept = data.acceptHeader;
}
foreach (KeyValuePair <string, string> header in data.headers)
{
request.Headers.Add(header.Key, header.Value);
}
request.Method = data.method.ToString();
//處理POST資料
if (data.method == ApiRequestData.Method.POST ||
data.method == ApiRequestData.Method.PUT)
{
var paramBytes = Encoding.UTF8.GetBytes(data.postData);
request.ContentType = data.contentTypeText;
request.ContentLength = paramBytes.Length;
using (var stream = request.GetRequestStream())
{
stream.Write(paramBytes, 0, paramBytes.Length);
}
}
logger.Info($"{url} req: {data.postData}");
using (var response = (HttpWebResponse)request.GetResponse())
{
//HttpStatusCode=200才算呼叫成功
if (response.StatusCode == HttpStatusCode.OK)
{
using (var sr = new StreamReader(response.GetResponseStream()))
{
value = sr.ReadToEnd();
}
}
else
{
throw new Exception(((int)response.StatusCode).ToString() + ":" + response.StatusDescription);
}
}
}
catch (Exception ex)
{
logger.Error($"invokeApi {ex.ToString()}");
}
logger.Info($"{url} resp: {value}");
return(JsonConvert.DeserializeObject <T>(value));
}
public QueueFactory(IQueueChannelManager queueChannelManager,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <QueueFactory>();
_queueChannelManager = queueChannelManager;
}
public OrderProxy(string ApiRootUrl, string ApiToken, IApiLogger logger) : base(ApiRootUrl, ApiToken)
{
this.Logger = logger;
}
public QueueChannelManager(IQueueConnectionManager queueConnectionManager,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <QueueChannelManager>();
_channel = queueConnectionManager.GetConnection().CreateModel();
}
