public async Task <IBusinessResult <GetByIdCustomerResponse> > GetById(int id)
{
#region [ Config Cache ]
string keyCache = string.Format(keyGetByIdCache, id);
TimeSpan expirationCache = TimeSpan.FromMinutes(20);
#endregion
if (!_cache.TryGetValue(keyCache, out IBusinessResult <GetByIdCustomerResponse> result))
{
result = await GetByIdCache(id);
if (!result.HasErrors)
{
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSlidingExpiration(expirationCache);
// Save data in cache.
_cache.Set(keyCache, result, cacheEntryOptions);
}
}
if (!result.Data.AnyOrNotNull())
{
return(BusinessResult <GetByIdCustomerResponse> .Create(
"Customer not found.".ToMessageResult("GetById", MessageType.Warning)
));
}
return(result);
}
public async Task <IBusinessResult <VoidResult> > Delete(int id)
{
if (await this.RemoveByIdAsync(id) > 0)
{
RemoveGetByIdCache(id);
RemoveGetByCache();
return(BusinessResult <VoidResult> .Create(
"Operation performed successfully.".ToMessageResult("Delete", MessageType.Success)
));
}
return(BusinessResult <VoidResult> .Create(
"Customer not found.".ToMessageResult("Delete", MessageType.Warning)
));
}
public async Task <IBusinessResult <CreateCustomerResponse> > Create(CreateCustomerRequest dto)
{
var customer = dto.MapTo <Customer>();
if (await this.AddAsync(customer) > 0)
{
RemoveGetByCache();
return(customer
.MapTo <CreateCustomerResponse>()
.ToBusinessWithMessage(
"Operation performed successfully.".ToMessageResult("CustomerCreate", MessageType.Success)
));
}
return(BusinessResult <CreateCustomerResponse> .Create(
"An attempt to perform an operation failed.".ToMessageResult("CustomerCreate", MessageType.Error)
));
}
public async Task <IBusinessResult <VoidResult> > Update(int id, UpdateCustomerRequest dto)
{
var customer = dto.MapTo <Customer>();
customer.Id = id;
if (await this.ModifyAsync(customer) > 0)
{
RemoveGetByIdCache(id);
RemoveGetByCache();
return(BusinessResult <VoidResult> .Create(
"Operation performed successfully.".ToMessageResult("Update", MessageType.Success)
));
}
return(BusinessResult <VoidResult> .Create(
"Customer not found.".ToMessageResult("Update", MessageType.Warning)
));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
IConfiguration configuration = (IConfiguration)context.HttpContext.RequestServices.GetService(typeof(IConfiguration));
if (configuration == null)
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Result = new JsonResult(
BusinessResult <VoidResult> .Create(
"Project settings not found for authentication filter (OAuth2).".ToMessageResult("internalservererror", MessageType.Error)
));
return;
}
string authValidadeUrl = configuration.GetSection("JWTAuthorize:ValidateUrl")?.Value;
string authByPass = configuration.GetSection("JWTAuthorize:ByPass")?.Value;
if (authByPass?.ToLower() == "true" || string.IsNullOrEmpty(authValidadeUrl))
{
await next();
return;
}
bool isAuthorized = true;
string authKey = context.HttpContext.Request
.Headers["Authorization"].SingleOrDefault();
if (string.IsNullOrWhiteSpace(authKey))
{
authKey = "Bearer " + context.HttpContext.Request.Query["Token"].FirstOrDefault();
}
if (string.IsNullOrWhiteSpace(authKey))
{
isAuthorized = false;
}
if (isAuthorized)
{
Hashtable header = new Hashtable();
header.Add("Authorization", authKey);
var response = await WebRequestHelper.GetAsync($"{authValidadeUrl}", header);
if (!string.IsNullOrEmpty(response))
{
try
{
var result = JsonConvert.DeserializeObject <LoginResult>(response);
if (isAuthorized && string.IsNullOrEmpty(result.UserName))
{
isAuthorized = false;
}
else
{
var claims = new List <Claim>();
foreach (var role in result.Claims ?? new List <ClaimResult>())
{
claims.Add(new Claim(role.Type, role.Value));
}
ClaimsIdentity identity = new ClaimsIdentity(claims);
ClaimsPrincipal principal = new ClaimsPrincipal(identity);
Thread.CurrentPrincipal = principal;
}
}
catch (Exception)
{
isAuthorized = false;
}
}
else
{
isAuthorized = false;
}
}
if (isAuthorized)
{
await next();
}
else
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
context.Result = new JsonResult(
BusinessResult <VoidResult> .Create(
"Provide a valid access token (OAuth2).".ToMessageResult("unauthorized", MessageType.Error)
));
}
}
