protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
try
{
using var channel = GrpcChannel.ForAddress(_config.GetValue <string>("WorkerService:ServerUrl"));
var client = new ProductProtoService.ProductProtoServiceClient(channel);
_logger.LogInformation("AddProductAsync started..");
var addProductResponse = await client.AddProductAsync(await _factory.Generate());
_logger.LogInformation("AddProduct Response: {product}", addProductResponse.ToString());
}
catch (Exception exception)
{
_logger.LogError(exception.Message);
throw exception;
}
await Task.Delay(_config.GetValue <int>("WorkerService:TaskInterval"), stoppingToken);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
//0 Get Token from IS4
//1 Create SC if not exist
//2 Retrieve products from product grpc with server stream
//3 Add sc items into SC with client stream
//0 Get Token from IS4
var token = await GetTokenFromIS4();
//1 Create SC if not exist
using var scChannel = GrpcChannel.ForAddress(_config.GetValue <string>("WorkerService:ShoppingCartServerUrl"));
var scClient = new ShoppingCartProtoService.ShoppingCartProtoServiceClient(scChannel);
var scModel = await GetOrCreateShoppingCartAsync(scClient, token);
// open sc client stream
using var scClientStream = scClient.AddItemIntoShoppingCart();
//2 Retrieve products from product grpc with server stream
using var productChannel = GrpcChannel.ForAddress(_config.GetValue <string>("WorkerService:ProductServerUrl"));
var productClient = new ProductProtoService.ProductProtoServiceClient(productChannel);
_logger.LogInformation("GetAllProducts started..");
using var clientData = productClient.GetAllProducts(new GetAllProductsRequest());
await foreach (var responseData in clientData.ResponseStream.ReadAllAsync())
{
_logger.LogInformation("GetAllProducts Stream Response: {responseData}", responseData);
//3 Add sc items into SC with client stream
var addNewScItem = new AddItemIntoShoppingCartRequest
{
Username = _config.GetValue <string>("WorkerService:UserName"),
DiscountCode = "CODE_100",
NewCartItem = new ShoppingCartItemModel
{
ProductId = responseData.ProductId,
Productname = responseData.Name,
Price = responseData.Price,
Color = "Black",
Quantity = 1
}
};
await scClientStream.RequestStream.WriteAsync(addNewScItem);
_logger.LogInformation("ShoppingCart Client Stream Added New Item : {addNewScItem}", addNewScItem);
}
await scClientStream.RequestStream.CompleteAsync();
var addItemIntoShoppingCartResponse = await scClientStream;
_logger.LogInformation("AddItemIntoShoppingCart Client Stream Response: {addItemIntoShoppingCartResponse}", addItemIntoShoppingCartResponse);
await Task.Delay(_config.GetValue <int>("WorkerService:TaskInterval"), stoppingToken);
}
}
private static async Task DeleteProductAsync(ProductProtoService.ProductProtoServiceClient client)
{
var replay = await client.DeleteProductAsync(new DeleteProductRequest
{
ProductId = 4
});
Console.WriteLine("Deleted Product Status : " + replay.ToString());
}
private static async Task GetProductAsync(ProductProtoService.ProductProtoServiceClient client)
{
Console.WriteLine("GetProductAsync started...");
var response = await client.GetProductAsync(
new GetProductRequest
{
Id = 1
});
Console.WriteLine("GetProductAsync Response: " + response.ToString());
}
static async Task Main(string[] args)
{
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new ProductProtoService.ProductProtoServiceClient(channel);
// Get All Product
Console.WriteLine("*****************************");
//Console.WriteLine("Get All Product List");
//using (var clientData = client.GetAllProducts(new GetAllProductRequest()))
//{
// while (await clientData.ResponseStream.MoveNext(new System.Threading.CancellationToken()))
// {
// var currentProduct = clientData.ResponseStream.Current;
// Console.WriteLine(currentProduct.ToString());
// }
//}
await GetProductAsync(client);
Console.WriteLine("Get All Product List ");
await GetAllProductAsync(client);
await AddProductAsync(client);
Console.WriteLine("");
Console.WriteLine("");
await UpdateProductAsync(client);
Console.WriteLine("Get All Product List ");
await GetAllProductAsync(client);
Console.WriteLine("");
Console.WriteLine("");
await DeleteProductAsync(client);
Console.WriteLine("Get All Product List ");
await GetAllProductAsync(client);
Console.WriteLine("");
Console.WriteLine("");
await InsertBulkProductAsync(client);
Console.WriteLine("Get All Product List ");
await GetAllProductAsync(client);
Console.ReadLine();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
Thread.Sleep(3000);
while (!stoppingToken.IsCancellationRequested)
{
//_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
using var scChannel = GrpcChannel.ForAddress(_configuration.GetValue <string>("WorkerService:ShoppingCartServerURL"));
var scClient = new ShoppingCartProtoService.ShoppingCartProtoServiceClient(scChannel);
//Get token from identity Server
var token = await GetTokenFromIdentityServer();
var scModel = await GetOrCreateShoppingModel(scClient, token);
using var scClientStraem = scClient.AddItemIntoShopppingCart();
// get Products
using var productCannel = GrpcChannel.ForAddress(_configuration.GetValue <string>("WorkerService:ProductServerURL"));
var productClient = new ProductProtoService.ProductProtoServiceClient(productCannel);
_logger.LogInformation("*****GetAllProducts Started****");
using var clientData = productClient.GetAllProducts(new GetAllProductRequest());
await foreach (var product in clientData.ResponseStream.ReadAllAsync())
{
_logger.LogInformation("--Each Product--" + product);
var newSCItem = new AddItemIntoShopppingCartRequest
{
Username = _configuration.GetValue <string>("WorkerService:UserName"),
DiscountCode = "D100",
NewCartItem = new ShoppingCartItemModel
{
ProductId = product.ProductId,
Color = "GREEN",
Price = product.Price,
Productname = product.Name,
Quantity = 1
}
};
await scClientStraem.RequestStream.WriteAsync(newSCItem);
_logger.LogInformation("Written Client Stream" + newSCItem.ToString());
}
await scClientStraem.RequestStream.CompleteAsync();
var addItemClientStreamResponse = await scClientStraem;
_logger.LogInformation("Add Client Stream Retsponse" + addItemClientStreamResponse.ToString());
await Task.Delay(_configuration.GetValue <int>("WorkerService:TaskInterval"), stoppingToken);
}
}
private static async Task UpdateProductAsync(ProductProtoService.ProductProtoServiceClient client)
{
var replay = await client.UpdateProductAsync(new UpdateProductRequest
{
Product = new ProductModel
{
ProductId = 4,
Name = "Test_2_1",
Description = "This is a test_2_1 product.",
Price = 100,
Status = ProductStatus.Instock,
CreatedTime = Timestamp.FromDateTime(DateTime.UtcNow)
}
});
Console.WriteLine("After Update Product Obj:-" + replay.ToString());
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
Console.WriteLine("Waitting for Server is running.....");
Thread.Sleep(2000);
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
using var channel = GrpcChannel.ForAddress(_config.GetValue <string>("WorkerService:ServerUrl"));
var client = new ProductProtoService.ProductProtoServiceClient(channel);
_logger.LogInformation("AddProductAsyn started....");
var addProductAsync = await client.AddProductAsync(await _factory.Gennerate());
_logger.LogInformation("AddProductAsyn Response:" + addProductAsync.ToString());
await Task.Delay(_config.GetValue <int>("WorkerService:TakeInterval"), stoppingToken);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
using var channel = GrpcChannel.ForAddress(_configuration.GetValue <string>("WorkerService:ServerUrl"));
var client = new ProductProtoService.ProductProtoServiceClient(channel);
// await GetProdudtAsync(client);
// await AddProductAsync(client);
var addProductFactory = await client.AddProductAsync(await _productFactory.Generate());
_logger.LogInformation("Add Product Response :{Product}", addProductFactory.ToString());
await Task.Delay(_configuration.GetValue <int>("WorkerService:TaskInterval"), stoppingToken);
}
}
private static async Task UpdateProductAsync(ProductProtoService.ProductProtoServiceClient client)
{
Console.WriteLine("UpdateProductAsync started...");
var updateProductResponse = await client.UpdateProductAsync(
new UpdateProductRequest
{
Product = new ProductModel
{
Id = 1,
Name = "Mi10T",
Description = "New Xiaomi 10T awesome smartphone",
Price = 699,
Status = ProductStatus.Instock,
CreatedAt = Timestamp.FromDateTime(DateTime.UtcNow)
}
});
Console.WriteLine("UpdateProductAsync Response: " + updateProductResponse.ToString());
}
