fix naming prefix.

pass missing cancellationtoken.

Author: omid-ahmadpour

src/Infrastructure/Persistance/CommandHandlers/Products/AddProductCommandHandler.cs

@@ -13,18 +13,21 @@ namespace CleanTemplate.Persistance.CommandHandlers.Products
 {
     public class AddProductCommandHandler : IRequestHandler<AddProductCommand, int>
     {
-        private readonly CleanArchWriteDbContext dbContext;
-        private readonly ILogger<AddProductCommandHandler> logger;
+        private readonly CleanArchWriteDbContext _dbContext;
+        private readonly ILogger<AddProductCommandHandler> _logger;
 
         public AddProductCommandHandler(CleanArchWriteDbContext dbContext, ILogger<AddProductCommandHandler> logger)
         {
-            this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task<int> Handle(AddProductCommand request, CancellationToken cancellationToken)
         {
-            var existingProduct = await dbContext.Set<Product>().FirstOrDefaultAsync(a => a.Name == request.Name, cancellationToken);
+            if (request is null)
+                throw new ArgumentNullException(nameof(request));
+
+            var existingProduct = await _dbContext.Set<Product>().FirstOrDefaultAsync(a => a.Name == request.Name, cancellationToken);
 
             if (existingProduct != null)
             {
@@ -37,10 +40,10 @@ public async Task<int> Handle(AddProductCommand request, CancellationToken cance
                 Price = request.Price
             };
 
-            await dbContext.Set<Product>().AddAsync(product, cancellationToken);
-            await dbContext.SaveChangesAsync(cancellationToken);
+            await _dbContext.Set<Product>().AddAsync(product, cancellationToken);
+            await _dbContext.SaveChangesAsync(cancellationToken);
 
-            logger.LogInformation("Product Inserted", product);
+            _logger.LogInformation("Product Inserted", product);
 
             return product.Id;
         }

src/Infrastructure/Persistance/CommandHandlers/Users/LoginCommandHandler.cs

@@ -25,11 +25,11 @@ public async Task<LoginResponse> Handle(LoginCommand request, CancellationToken
         {
             var user = await _userManager.FindByNameAsync(request.Username);
             if (user == null)
-                throw new CleanArchAppException("نام کاربری یا رمز عبور اشتباه است");
+                throw new CleanArchAppException("username or password is incorrect");
 
             var isPasswordValid = await _userManager.CheckPasswordAsync(user, request.Password);
             if (!isPasswordValid)
-                throw new CleanArchAppException("نام کاربری یا رمز عبور اشتباه است");
+                throw new CleanArchAppException("username or password is incorrect");
 
             var jwt = await _jwtService.GenerateAsync(user);
 

src/Infrastructure/Persistance/QueryHandlers/Products/GetProductByIdQueryHandler.cs

@@ -12,21 +12,21 @@ namespace CleanTemplate.Persistance.QueryHandlers.Products
 {
     public class GetProductByIdQueryHandler : IRequestHandler<GetProductByIdQuery, ProductQueryModel>
     {
-        private readonly CleanArchReadOnlyDbContext dbContext;
+        private readonly CleanArchReadOnlyDbContext _dbContext;
 
         public GetProductByIdQueryHandler(CleanArchReadOnlyDbContext dbContext)
         {
-            this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+            _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
         }
 
         public async Task<ProductQueryModel> Handle(GetProductByIdQuery request, CancellationToken cancellationToken)
         {
-            var existingProduct = await dbContext.Set<Product>().Where(a => a.Id == request.ProductId).Select(a =>
+            var existingProduct = await _dbContext.Set<Product>().Where(a => a.Id == request.ProductId).Select(a =>
                new ProductQueryModel
                {
                    Name = a.Name,
                    Price = a.Price
-               }).FirstOrDefaultAsync();
+               }).FirstOrDefaultAsync(cancellationToken: cancellationToken);
 
             return existingProduct;
         }

src/Infrastructure/Persistance/QueryHandlers/Products/ReadProductFromRedisQueryHandler.cs

@@ -13,37 +13,38 @@ namespace CleanTemplate.Persistance.QueryHandlers.Products
 {
     public class ReadProductFromRedisQueryHandler : IRequestHandler<ReadProductFromRedisQuery, ReadProductFromRedisResponse>
     {
-        private readonly CleanArchReadOnlyDbContext dbContext;
-        private readonly IStaticCacheManager staticCacheManager;
-        private const string CachePrefix = "product_";
-        private const int CacheExpiryTime = 2; //minitues
+        private readonly CleanArchReadOnlyDbContext _dbContext;
+        private readonly IStaticCacheManager _staticCacheManager;
+
+        private const string _cachePrefix = "product_";
+        private const int _cacheExpiryTime = 2; //minitues
 
         public ReadProductFromRedisQueryHandler(CleanArchReadOnlyDbContext dbContext,
                                                 IStaticCacheManager staticCacheManager)
         {
-            this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
-            this.staticCacheManager = staticCacheManager ?? throw new ArgumentNullException(nameof(staticCacheManager));
+            _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+            _staticCacheManager = staticCacheManager ?? throw new ArgumentNullException(nameof(staticCacheManager));
         }
 
         public async Task<ReadProductFromRedisResponse> Handle(ReadProductFromRedisQuery request, CancellationToken cancellationToken)
         {
             var productId = request.ProductId;
 
-            var result = await staticCacheManager.GetWithExpireTimeAsync(
-                new CacheKey(CachePrefix + productId),
-                CacheExpiryTime,
+            var result = await _staticCacheManager.GetWithExpireTimeAsync(
+                new CacheKey(_cachePrefix + productId),
+                _cacheExpiryTime,
                 async () => await GetProductAsync());
 
             return result;
 
             async Task<ReadProductFromRedisResponse> GetProductAsync()
             {
-                var product = await dbContext.Set<Product>().Where(a => a.Id == productId).Select(a =>
+                var product = await _dbContext.Set<Product>().Where(a => a.Id == productId).Select(a =>
                        new ReadProductFromRedisResponse
                        {
                            Name = a.Name,
                            Price = a.Price
-                       }).FirstOrDefaultAsync();
+                       }).FirstOrDefaultAsync(cancellationToken: cancellationToken);
 
                 return product;
             }