public async Task SubscribeToRoomsUpdatesAsync(string userId, string connectionId, params Room[] rooms)
{
await GrpcCallerService.CallService(_urls.GrpcNotifications, async channel =>
{
var client = new NotificationsGrpc.NotificationsGrpcClient(channel);
var request = new RoomsUpdatesRequest
{
UserId = userId,
ConnectionId = connectionId
};
foreach (var room in rooms)
{
var roomModel = new GrpcNotifcations.Room {
Id = room.Id
};
roomModel.MembersIds.AddRange(room.MembersIds);
request.Rooms.Add(roomModel);
}
await client.SubscribeToRoomsUpdatesAsync(request);
});
}
public async Task <CustomerResponse> Register([Required] CustomerRequest 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 Customer.CustomerClient(channel);
_logger.LogDebug("Grpc get customer request {@request}", request);
var customer = await client.AddCustomerAsync(request);
var response = await GrpcCallerService.CallService(urlGrpc: GRPCUrl.ProductService, logger: _logger, func: async channel =>
{
var client = new ProductUser.ProductUserClient(channel);
_logger.LogDebug("Grpc add product customer request {@request}", customer);
return(await client.UpdateCustomerAsync(new ProductUserRequest {
Id = customer.Id, Name = customer.Name, IsDeleted = false
}));
});
return(customer);
});
return(response);
}
public async Task <IActionResult> Login(string returnUrl)
{
var loginKey = await GrpcCallerService.CallService(_settings.InternalEndpoints["grpcResources"], _logger, async channel =>
{
var client = new Resources.API.Grpc.ResourceService.ResourceServiceClient(channel);
var request = new Resources.API.Grpc.GetByKeyRequest()
{
Key = "login_lb", LanguageCode = "fr"
};
_logger.LogInformation("grpc client created, request = {@request}", request);
var reply = await client.GetByKeyAsync(request);
_logger.LogInformation("grpc reply {@reply}", reply);
return(reply?.Value);
});
if (User.Identity.IsAuthenticated == true)
{
return(RedirectToAction(nameof(LoggedIn)));
}
var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
if (context?.IdP != null)
{
throw new NotImplementedException("External login is not implemented!");
}
var vm = BuildLoginViewModel(returnUrl, context);
ViewData["ReturnUrl"] = returnUrl;
return(View(vm));
}
public async Task <IActionResult> GetById(Service.GetByIdRequest request)
{
var response = await GrpcCallerService.CallService <Service.GetByIdResponse>(async() => await _client.GetByIdAsync(request, deadline: DateTime.UtcNow.AddSeconds(30)));
if (!response.IsSuccessful)
{
_logger.LogError($"{nameof(ProductServiceController)} call unsuccessful on GetProductById: {response.Message}");
}
return(ResponseHelper.PrepareServiceCallResponse(this, response.ServiceResponse.ServiceProcessResult.IsSuccessful, response));
}
public async Task <ProductResponse> UpdateProduct([Required] ProductRequest request)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Product.ProductClient(channel);
_logger.LogDebug("Grpc update product request {@request}", request);
return(await client.UpdateProductAsync(request));
});
return(response);
}
public async Task <IEnumerable <Models.Complete.Property> > Get(PropertiesParameters parameters = null) =>
_Grpc ? await GrpcCallerService.CallService(_urls.PropertiesGrpc, async channel =>
{
var client = new Property.PropertyClient(channel);
_logger.LogDebug("grpc client created, request");
var response = await client.GetPropertiesAsync(new Properties.Services.PropertyTypes.GetPropertiesRequest());
_logger.LogDebug("grpc response {@response}", response);
return(response.Properties.Select(p => MapToPropertyComplete(p)));
}) :
WebUtilities.MapListResponse <Models.Complete.Property>(
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 <RetailerResponse> UpdateRetailer([Required] RetailerUpdateRequest request)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Retailer.RetailerClient(channel);
_logger.LogDebug("Grpc put Retailer request {@request}", request);
var retailer = await client.UpdateRetailerAsync(request);
await UpdateProductRetailer(retailer);
return(retailer);
});
return(response);
}
public async Task <RetailerResponse> Get([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 get Retailer request {@request}", id);
return(await client.GetRetailerAsync(new RetailerItemRequest {
Id = id.ToString()
}));
});
return(response);
}
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 <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 <ProductResponse> DeleteProduct([Required] Guid id)
{
var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel =>
{
var client = new Product.ProductClient(channel);
_logger.LogDebug("Grpc delete product request {@request}", id);
return(await client.DeleteProductAsync(new ProductItemRequest {
Id = id.ToString()
}));
});
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 <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 <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 <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 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();
}
}
