private async Task <ProductUserResponse> UpdateProductRetailer(RetailerResponse retailer, bool isDeleted = false)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.ProductService, logger : _logger, func : async channel =>
{
var client = new ProductUser.ProductUserClient(channel);
_logger.LogDebug("Grpc delete Retailer request {@request}", retailer);
return(await client.UpdateRetailerAsync(new ProductUserRequest {
Id = retailer.Id, Name = retailer.Name, IsDeleted = isDeleted
}));
});
return(response);
}
public async Task <CustomerResponse> UpdateCustomer([Required] CustomerUpdateRequest customerRequest)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Customer.CustomerClient(channel);
_logger.LogDebug("Grpc get customer request {@request}", customerRequest);
var customer = await client.UpdateCustomerAsync(customerRequest);
await UpdateProductCustomer(customer, false);
return(customer);
});
return(response);
}
public async Task <CustomerResponse> Get([Required] Guid id)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Customer.CustomerClient(channel);
_logger.LogDebug("Grpc get customer request request {@request}", id);
return(await client.GetCustomerAsync(new CustomerItemRequest {
Id = id.ToString()
}));
});
return(response);
}
public async Task <UserModel> GetUserAsync(string id)
{
return(await GrpcCallerService.CallService(_urls.GrpcUsers, async channel =>
{
var client = new UsersGrpc.UsersGrpcClient(channel);
var response = await client.GetUserAsync(new UserRequest {
Id = id
});
return MapToUserData(response);
}));
}
public async Task <IEnumerable <WeatherDataItem> > GetFirst()
{
return(await GrpcCallerService.CallService(_urls.WeatherFirst, async httpClient =>
{
var channel = GrpcChannel.ForAddress(_urls.WeatherFirst);
var client = new WeatherFirst.WeatherFirstClient(channel);
_logger.LogDebug("grpc client created, request");
var response = await client.GetAsync(new ApiFirst.Proto.WeatherRequest());
_logger.LogDebug("grpc response {@response}", response);
return MapToWeatherData(response);
}));
}
public async Task <PaginatedItemsResponse> Get([Required] ProductItemsRequest request)
{
if (!ModelState.IsValid)
{
throw new Exception("Invalid model");
}
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Product.ProductClient(channel);
_logger.LogDebug("Grpc get products request {@request}", request);
return(await client.GetProductsAsync(request));
});
return(response);
}
public async Task <BasketResponse> RemoveToBasket([Required] BasketRequest request)
{
if (!ModelState.IsValid)
{
throw new Exception("Invalid model");
}
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.ProductService, logger : _logger, func : async channel =>
{
var client = new Basket.BasketClient(channel);
_logger.LogDebug("Grpc remove backet {@request}", request);
return(await client.RemoveFromBasketAsync(request));
});
return(response);
}
public async Task <LogoutResponse> Logout([Required] LogoutRequest request)
{
if (!ModelState.IsValid)
{
throw new Exception("Invalid model");
}
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Auth.AuthClient(channel);
_logger.LogDebug("Grpc auth logout {@request}", request);
return(await client.LogoutAsync(request));
});
return(response);
}
public async Task <RetailerResponse> DeleteCustomer([Required] Guid id)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Retailer.RetailerClient(channel);
_logger.LogDebug("Grpc delete Retailer request {@request}", id);
var retailer = await client.DeleteRetailerAsync(new RetailerItemRequest {
Id = id.ToString()
});
await UpdateProductRetailer(retailer, true);
return(retailer);
});
return(response);
}
public async Task SubscribeToUsersStatusUpdatesAsync(string userId, string connectionId, params string[] usersIds)
{
await GrpcCallerService.CallService(_urls.GrpcNotifications, async channel =>
{
var client = new NotificationsGrpc.NotificationsGrpcClient(channel);
var request = new ConnectionsUpdatesRequest
{
UserId = userId,
ConnectionId = connectionId
};
request.UsersIds.AddRange(usersIds);
await client.SubscribeToUsersStatusUpdatesAsync(request);
});
}
public async Task <IActionResult> NewPass(int rut)
{
var person = await mediator.Send(new NewPassQuery(rut));
await GrpcCallerService.CallService(_urls.GrpcMail, channel =>
{
var client = new Mailer.MailerClient(channel);
client.MailChagedPassword(new MailRequest
{
CuentaDestino = person.CORREO_ELECTRONICO,
Nombre = person.NOMBRE_COMPLETO,
IdPersona = person.ID_PER,
CodEmail = 1
});
return(Task.CompletedTask);
});
return(Ok(person));
}
public void OnAuthorization(AuthorizationFilterContext filterContext)
{
try
{
var skipAuthorization = (filterContext.ActionDescriptor as ControllerActionDescriptor)
.MethodInfo.GetCustomAttributes(typeof(AllowAnonymousAttribute), true);
if (skipAuthorization.Length > 0)
{
return;
}
var tokenString = filterContext.HttpContext.Request.Headers["Authorization"].ToString();
if (string.IsNullOrWhiteSpace(tokenString))
{
throw new UnauthorizedAccessException();
}
var response = Task.Run(async() =>
await GrpcCallerService.CallService(urlGrpc: GRPCUrl.IdentityService, logger: null,
func: async channel =>
{
var client = new Auth.AuthClient(channel);
return(await client.ValidTokenAsync(new TokenRequest {
Token = tokenString
}));
}))
.ConfigureAwait(false).GetAwaiter().GetResult();
if (!response.IsValid)
{
throw new UnauthorizedAccessException();
}
SetClaim(filterContext: filterContext, response: response);
}
catch (Exception ex)
{
throw new UnauthorizedAccessException();
}
}
