public async Task <IResponse> CreateProductAsync(ProductRequestVm productRequest)
        {
            var    product     = productRequest.MapToEntity();
            string storagePath = GetStoragePath();
            var    json        = default(string);

            // if file not exist
            try
            {
                json = File.ReadAllText(storagePath);
            }
            catch (Exception)
            {
                File.WriteAllText(storagePath, String.Empty);
            }

            json = File.ReadAllText(storagePath);
            var products = await Task.Run(() => JsonConvert.DeserializeObject <List <Product> >(json));

            var lastProductId = default(long);

            if (products == null)
            {
                products      = new List <Product>();
                lastProductId = 1;
                product.Id    = lastProductId;

                if (!await _nameValidator.ValidateAsync(product.Name) |
                    !await _descriptionValidator.ValidateAsync(product.Description))
                {
                    return(new ResponseBad <string>(400, GetErrorMsg(product)));
                }
                products.Add(product);
            }
            else
            {
                lastProductId = products.OrderByDescending(p => p.Id).FirstOrDefault().Id;
                lastProductId++;
                product.Id = lastProductId;

                if (!await _nameValidator.ValidateAsync(product.Name) |
                    !await _descriptionValidator.ValidateAsync(product.Description))
                {
                    return(new ResponseBad <string>(400, GetErrorMsg(product)));
                }
                products.Add(product);
            }
            File.WriteAllText(storagePath, JsonConvert.SerializeObject(products));
            return(new ResponseOk <ProductResponseVm>(201, product.MapToResponseVm()));
        }
        public async Task <ProductInsertResponse> UpsertAsync([FromBody] ProductInsertRequest request)
        {
            string authorizationHeader = HttpContext.Request.Headers["Authorization"];

            var authorizationResult = await _authorizationService.CheckAuthorizationAsync(authorizationHeader);

            if (authorizationResult.Authorized == false)
            {
                return(new ProductInsertResponse
                {
                    StatusCode = (int)HttpStatusCode.Unauthorized,
                    Data = new InsertProductResponseData(),
                    Message = $"Unauthorized User error"
                });
            }

            var nameValidate = await _nameValidator.ValidateAsync(request.Name);

            var descriptionValidate = await _descriptionValidator.ValidateAsync(request.Description);

            if (!nameValidate || !descriptionValidate)
            {
                return(new ProductInsertResponse
                {
                    StatusCode = (int)HttpStatusCode.BadRequest,
                    Data = new InsertProductResponseData(),
                    Message = $"Bad request error"
                });
            }

            var product = await _productService.AddNewProduct(request.Name, request.Description);

            return(new ProductInsertResponse()
            {
                Message = "Ok",
                Data = new InsertProductResponseData
                {
                    Description = product.Description,
                    Name = product.Name,
                    Id = product.Id
                },
                StatusCode = (int)HttpStatusCode.Created
            });
        }
        public async Task SpecialSignsNameValidator_True(string name)
        {
            var result = await _specialSignsNameValidator.ValidateAsync(name);

            Assert.True(result);
        }
        public async Task RequiredNameValidatorTest_CorrectName()
        {
            var result = await _nameValidator.ValidateAsync("Correct Name");

            Assert.True(result);
        }