public static IServiceCollection AddKRFController(this IServiceCollection services, Action <MvcOptions> options)
{
services.AddControllers(options)
.AddJsonOptions(o => KRFJsonSerializerOptions.GetJsonSerializerOptions(o.JsonSerializerOptions));
return(services);
}
public static IServiceCollection AddKRFController(this IServiceCollection services)
{
services.AddControllers(o =>
{
o.AllowEmptyInputInBodyModelBinding = true;
o.RespectBrowserAcceptHeader = true;
o.ReturnHttpNotAcceptable = false;
})
.AddJsonOptions(o => KRFJsonSerializerOptions.GetJsonSerializerOptions(o.JsonSerializerOptions));
return(services);
}
public static IApplicationBuilder ApiConfigure(this IApplicationBuilder app, AppConfiguration configuration, ILoggerFactory loggerFactory, bool isDev = false)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(AppConfiguration));
}
app.UseLocalization(configuration.LocalizationConfiguration);
app.KRFLogAndExceptionHandlerConfigure(
loggerFactory,
configuration,
isDev);
app.UseHttpsRedirection();
app.UseRouting();
app.UseStatusCodePages(async ctx =>
{
var serializerOpt = KRFJsonSerializerOptions.GetJsonSerializerOptions();
switch (ctx.HttpContext.Response.StatusCode)
{
case (( int )HttpStatusCode.Unauthorized):
{
string message = "Selected token is invalid or user is not authenticated";
string code = null;
if (ctx.HttpContext.Response.Headers.TryGetValue(KRFConstants.AuthenticateHeader, out var authHeader))
{
code = authHeader[0];
switch (code)
{
case KRFTokenErrors.TokenSignatureErrorCode:
{
message = "Invalid token signature, please logout and login again";
break;
}
case KRFTokenErrors.TokenExpiredErrorCode:
{
message = "Your token has expired, request new token from auth server and send new request";
break;
}
default:
{
code = KRFTokenErrors.TokenDefaultErrorCode;
break;
}
}
}
if (!isDev)
{
message = "User is not authenticated";
}
await ctx.HttpContext.Response.WriteAsJsonAsync(new ErrorOut(HttpStatusCode.Unauthorized, message, ResponseErrorType.Application, "Authentication", code), serializerOpt);
break;
}
case (( int )HttpStatusCode.Forbidden):
{
await ctx.HttpContext.Response.WriteAsJsonAsync(new ErrorOut(HttpStatusCode.Forbidden, "User is not allowed to resource", ResponseErrorType.Application, "Authorization", KRFConstants.AuthorizationErrorCode), serializerOpt);
break;
}
case (( int )HttpStatusCode.NotFound):
{
await ctx.HttpContext.Response.WriteAsJsonAsync(new ErrorOut(HttpStatusCode.NotFound, "Could not find desired resource", ResponseErrorType.Application, KRFConstants.DefaultErrorCode), serializerOpt);
break;
}
default:
{
await ctx.HttpContext.Response.WriteAsJsonAsync(new ErrorOut(( HttpStatusCode )ctx.HttpContext.Response.StatusCode, "Unknown error occurred", ResponseErrorType.Unknown, KRFConstants.DefaultErrorCode), serializerOpt);
break;
}
}
});
app.CorsConfigure(configuration.CorsConfiguration, isDev);
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
return(app);
}
public ServerConfigurationHandler(string path)
{
try
{
var configPath = Path.IsPathRooted(path) ? path : $"{Environment.CurrentDirectory}\\{path}";
//Read all json configurations from path
var configurations = new Dictionary <string, ServerConfiguration>();
var configFilePaths = Directory.GetFiles(configPath, "*.json");
foreach (var filePath in configFilePaths)
{
var file = File.ReadAllText(filePath);
var data = JsonSerializer.Deserialize <ServerConfiguration>(file, KRFJsonSerializerOptions.GetJsonSerializerOptions());
configurations.Add(data.ServerName.ToLowerInvariant(), data);
}
this.ServerConfigurations = configurations;
}
catch (Exception ex)
{
throw new Exception($"Could not load configuration files - {ex.Message}");
}
}
private static IApplicationBuilder _KRFExceptionHandlerMiddlewareConfigure(this IApplicationBuilder app, ILoggerFactory loggerFactory, AppConfiguration configuration, bool isDev = false)
{
var _eventId = new EventId(KRFConstants.ApiEventId, KRFConstants.LogExceptionEvtName);
app.UseExceptionHandler(b => b.Run(async c =>
{
var error = ( IExceptionHandlerFeature )c.Features[typeof(IExceptionHandlerFeature)];
if (configuration.EnableReqLogs || isDev)
{
var requestToken = c.Request.Headers[configuration.TokenIdentifier];
string reqBody;
if (c.Request.Body.CanSeek &&
!c.Request.Method.Equals(KRFConstants.GetMethod, StringComparison.InvariantCultureIgnoreCase) &&
!c.Request.Method.Equals(KRFConstants.DeleteMethod, StringComparison.InvariantCultureIgnoreCase) &&
c.Request.ContentLength != null && (!configuration.RequestBufferSize.HasValue || configuration.RequestBufferSize.Value >= c.Request.ContentLength) &&
c.Request.ContentType != null && c.Request.ContentType.Contains(KRFConstants.JsonContentType, StringComparison.InvariantCultureIgnoreCase))
{
var body = new MemoryStream();
c.Request.Body.Seek(0, SeekOrigin.Begin);
await c.Request.Body.CopyToAsync(body);
c.Request.Body.Seek(0, SeekOrigin.Begin);
body.Seek(0, SeekOrigin.Begin);
using (var reqReader = new StreamReader(body))
{
reqBody = await reqReader.ReadToEndAsync();
}
}
else
{
reqBody = "Could not read request body: Get method or Request reading disabled or content too long";
}
var requestUrl = c.Request.Path + c.Request.QueryString;
var appLogger = loggerFactory.CreateLogger(string.Format("{0} - {1}", configuration.ApiName, "Exceptions"));
var log = new StringBuilder();
log.Append("\n------------------------------------------------------");
log.Append("\n Request Log:");
log.Append("\n------------------------------------------------------");
log.Append("\nTimeStamp:");
log.Append(DateTime.Now.ToString(KRFConstants.TimeStampFormat));
log.Append("\nRequest: ");
log.Append(requestUrl);
log.Append("\nRequest Method: ");
log.Append(c.Request.Method);
log.Append("\nRequest Token: ");
log.Append(requestToken);
log.Append("\nStatusCode:");
log.Append(c.Response.StatusCode.ToString());
log.Append("\nRequest Body:\n");
log.Append(reqBody);
log.Append("\n\n------------------------------------------------------");
log.Append("\n Exception:");
log.Append("\n------------------------------------------------------\n");
log.Append(error.Error.Message);
appLogger.LogError(_eventId, error.Error, log.ToString());
}
//Check specific exceptons first
var serializerOpt = KRFJsonSerializerOptions.GetJsonSerializerOptions();
switch (error.Error)
{
case HttpRequestException httpEx:
{
await c.Response.WriteAsJsonAsync(new ErrorOut(( HttpStatusCode )c.Response.StatusCode, "Could not execute request to the server", ResponseErrorType.Exception, "HttpRequest", KRFConstants.HttpExErrorCode), serializerOpt);
break;
}
case KRFMemoryCacheException memoryCacheException:
{
await c.Response.WriteAsJsonAsync(new ErrorOut(( HttpStatusCode )c.Response.StatusCode, memoryCacheException.Message, ResponseErrorType.Exception, "MemoryCache", memoryCacheException.Code), serializerOpt);
break;
}
default:
{
await c.Response.WriteAsJsonAsync(new ErrorOut(( HttpStatusCode )c.Response.StatusCode, error.Error.Message, ResponseErrorType.Exception, "Exception", KRFConstants.DefaultErrorCode), serializerOpt);
break;
}
}
}));
return(app);
}
private static async Task <KRFHttpResponse <TResp> > RequestHttpInternal <TResp>(KRFHttpRequest request, string stringBody = null)
where TResp : class
{
HttpResponseMessage response = null;
string route = string.Format("{0}{1}", request.Route, request.QueryString);
try
{
using (var handler = new HttpClientHandler())
{
if (request.ForceDisableSSL.HasValue && request.ForceDisableSSL.Value)
{
handler.ServerCertificateCustomValidationCallback = (message, cert, chain, err) =>
{
return(true);
};
}
else
{
if (!string.IsNullOrEmpty(request.CertificatePath))
{
//Add ssl certificate
if (!string.IsNullOrEmpty(request.CertificateKey))
{
//Add ssl certificate password
}
}
}
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(request.Url);
client.DefaultRequestHeaders.Accept.Append(new MediaTypeWithQualityHeaderValue(KRFConstants.JsonContentType));
if (!string.IsNullOrEmpty(request.BearerToken) && !string.IsNullOrEmpty(request.BearerTokenHeader))
{
client.DefaultRequestHeaders.Add(request.BearerTokenHeader, request.BearerToken);
}
if (request.Timeout.HasValue)
{
client.Timeout = new TimeSpan(0, 0, request.Timeout.Value);
}
switch (request.Method)
{
case HttpMethodEnum.GET:
{
response = await client.GetAsync(route);
break;
}
case HttpMethodEnum.DELETE:
{
response = await client.DeleteAsync(route);
break;
}
case HttpMethodEnum.POST:
case HttpMethodEnum.PUT:
{
using (HttpContent req = new StringContent(stringBody ?? string.Empty, Encoding.UTF8))
{
req.Headers.ContentType.MediaType = KRFConstants.JsonContentType;
req.Headers.ContentType.CharSet = "utf-8";
if (request.Method.Equals(HttpMethodEnum.POST))
{
response = await client.PostAsync(route, req);
}
else
{
response = await client.PutAsync(route, req);
}
}
break;
}
}
if (response == null || response.Content == null)
{
throw new Exception("No response found from service");
}
var respBody = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
return(new KRFHttpResponse <TResp>
{
Response = JsonSerializer.Deserialize <TResp>(respBody, KRFJsonSerializerOptions.GetJsonSerializerOptions()),
HttpStatus = response.StatusCode,
ResponseHeaders = response.Headers
});
}
return(new KRFHttpResponse <TResp>
{
Error = JsonSerializer.Deserialize <ErrorOut>(respBody, KRFJsonSerializerOptions.GetJsonSerializerOptions()),
HttpStatus = response.StatusCode,
ResponseHeaders = response.Headers
});
}
}
}
catch
{
return(new KRFHttpResponse <TResp>
{
Error = new ErrorOut(HttpStatusCode.InternalServerError, string.Format("Could not retrieve response from {0}/{1}", request.Url, route), ResponseErrorType.Proxy, KRFConstants.NotAvailableErrorCode),
HttpStatus = HttpStatusCode.InternalServerError
});
}
}
public static async Task <KRFHttpResponse <TResp> > RequestHttp <TBody, TResp>(KRFHttpRequestWithBody <TBody> request)
where TBody : class
where TResp : class
{
if (request == null)
{
throw new Exception("No request was defined for Http Rest call");
}
string stringBody = string.Empty;
if (request.Body != null)
{
stringBody = request.Body is string?(request.Body as string) : JsonSerializer.Serialize(request.Body, KRFJsonSerializerOptions.GetJsonSerializerOptions());
}
return(await RequestHttpInternal <TResp>(request, stringBody));
}