コード例 #1
0
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            var response = new DeleteProductResponse {
                Errors = new List <Error>()
            };

            try
            {
                Repository.DeleteProduct(request.Id);
                response.Message = "Product deleted successfully!";
            }
            catch (Exception ex)
            {
                response.Errors.Add(
                    new Error
                {
                    CustomisedMessage = "Unable to delete  product",
                    StackTrace        = ex.StackTrace,
                    SystemMessage     = ex.Message,
                });

                Logger.Fatal(request);
                Logger.Fatal(response, ex);
            }
            return(response);
        }
コード例 #2
0
        public async Task <DeleteProductResponse> DeleteProduct(Guid productId)
        {
            _logger.LogInformation($"Deleting a product with productId: {productId}");

            var productOptions = await _productRepository.GetProductOptionsByProductId(productId);

            foreach (var productOption in productOptions)
            {
                var deleteProductOptionResult = await _productRepository.DeleteProductOption(productOption.Id);

                if (!deleteProductOptionResult)
                {
                    _logger.LogWarning($"Fail to delete product option with optionId: {productOption.Id} and productId: {productOption.ProductId}");
                }
                else
                {
                    _logger.LogInformation($"Delete product option with optionId: {productOption.Id} and productId: {productOption.ProductId}");
                }
            }

            var deletionProductResult = await _productRepository.DeleteProduct(productId);

            var deleteProductResponse = new DeleteProductResponse
            {
                IsSuccessful = deletionProductResult
            };

            return(deleteProductResponse);
        }
コード例 #3
0
        public void TestDeleteProduct()
        {
            DeleteProductResponse response = new DeleteProductResponse();

            Expect.Once.On(service).Method("DeleteProduct").Will(Return.Value(response));
            serviceFacade.DeleteProduct(1);
        }
コード例 #4
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DeleteProductResponse response = new DeleteProductResponse();


            return(response);
        }
コード例 #5
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DeleteProductResponse response = new DeleteProductResponse();


            return response;
        }
コード例 #6
0
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            DeleteProductResponse res = new DeleteProductResponse();
            string strSP = SqlCommandStore.uspDeleteProduct;

            try
            {
                using (SqlCommand cmd = new SqlCommand(strSP))
                {
                    cmd.Parameters.Add("ProductID", SqlDbType.BigInt).Value = request.ProductID;

                    cmd.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;

                    DataSet ds = DB.ExecuteSPDataSet(cmd);
                    res.Code = (ReturnCode)Convert.ToInt32(cmd.Parameters["@Return"].Value);

                    if (res.Code != ReturnCode.Success)
                    {
                        DB.RollBackTran();
                        return(res);
                    }

                    DB.CommitTran();
                    return(res);
                }
            }
            catch (Exception ex)
            {
                LogWriter.WriteLogException(ex);
                res.Code = ReturnCode.Fail;
                return(res);
            }
        }
コード例 #7
0
ファイル: AdminService.cs プロジェクト: fferragina/Fallstudie
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            DeleteProductResponse    response = new DeleteProductResponse();
            ProductBusinessComponent bc       = DependencyInjectionHelper.GetProductBusinessComponent();

            bc.DeleteProduct(request.Id);

            return(response);
        }
コード例 #8
0
        public DeleteProductResponse DeleteProduct(DeleteProductRequest deleteProductRequest)
        {
            var product = productRepository.FindProductById(deleteProductRequest.Id);

            productRepository.Delete(product);
            var deletebrandresponse = new DeleteProductResponse {
                Product = messageMapper.MapToProductDto(product)
            };

            return(deletebrandresponse);
        }
コード例 #9
0
        public static DeleteProductResponse Unmarshall(UnmarshallerContext _ctx)
        {
            DeleteProductResponse deleteProductResponse = new DeleteProductResponse();

            deleteProductResponse.HttpResponse = _ctx.HttpResponse;
            deleteProductResponse.RequestId    = _ctx.StringValue("DeleteProduct.RequestId");
            deleteProductResponse.Success      = _ctx.BooleanValue("DeleteProduct.Success");
            deleteProductResponse.Code         = _ctx.StringValue("DeleteProduct.Code");
            deleteProductResponse.ErrorMessage = _ctx.StringValue("DeleteProduct.ErrorMessage");

            return(deleteProductResponse);
        }
コード例 #10
0
        /// <summary>
        /// 删除产品
        /// </summary>
        public DeleteProductResponse DeleteProduct(DeleteProductRequest deleteProductRequest)
        {
            Dictionary <string, string> urlParam = new Dictionary <string, string>();

            urlParam.Add("product_id", deleteProductRequest.ProductId.ToString());
            string                urlPath  = HttpUtils.AddUrlPath("/v5/iot/{project_id}/products/{product_id}", urlParam);
            SdkRequest            request  = HttpUtils.InitSdkRequest(urlPath, deleteProductRequest);
            HttpResponseMessage   response = DoHttpRequestSync("DELETE", request);
            DeleteProductResponse deleteProductResponse = JsonUtils.DeSerializeNull <DeleteProductResponse>(response);

            return(deleteProductResponse);
        }
コード例 #11
0
ファイル: Proxy.cs プロジェクト: willdarwin/tta
        /// <summary>
        /// Deletes the product.--by Will
        /// </summary>
        /// <param name="id">The id.</param>
        /// <returns></returns>
        public bool DeleteProduct(int id)
        {
            DeleteProductRequst request = new DeleteProductRequst();

            request.ProductId = id;
            DeleteProductResponse response = MyChannelFactory.CreateChannel().DeleteProduct(request);

            if (response.IsFailed)
            {
                throw (new Exception(response.Message));
            }
            return(!response.IsFailed);
        }
コード例 #12
0
        public void TestDeleteProduct()
        {
            DefaultAcsClient acsClient = Demo.IotClient.GetClient();

            DeleteProductRequest request = new DeleteProductRequest();

            request.ProductKey = "<productKey>";


            DeleteProductResponse response = acsClient.GetAcsResponse(request);

            Console.WriteLine(response.Success);
            Console.WriteLine(response.ErrorMessage);
            Console.WriteLine(response.Code);
        }
コード例 #13
0
 public void DeleteProduct(int productId)
 {
     try
     {
         DeleteProductRequest request = new DeleteProductRequest();
         request.Id = productId;
         DeleteProductResponse response = Service.DeleteProduct(request);
     }
     catch (Exception ex)
     {
         if (ExceptionPolicy.HandleException(ex, "PL Policy"))
         {
             throw;
         }
     }
 }
コード例 #14
0
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            DeleteProductResponse response = new DeleteProductResponse();

            try
            {
                productRepository.Delete(request.ProductId);
                response.Success = true;
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }
            return(response);
        }
コード例 #15
0
        /// <summary>
        /// Deletes the product.--by Will
        /// </summary>
        /// <param name="id">The id.</param>
        /// <returns></returns>
        public bool DeleteProduct(int id)
        {
            DeleteProductRequst request = new DeleteProductRequst();

            request.ProductId = id;
            DeleteProductResponse response = MyChannelFactory.CreateChannel().DeleteProduct(request);

            if (response.IsFailed)
            {
                ILog log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
                log.Error("error", new Exception(response.Message));
                log.Fatal("fatal", new Exception(response.Message));
                throw (new Exception(response.Message));
            }
            return(!response.IsFailed);
        }
コード例 #16
0
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            var response = new DeleteProductResponse();

            WithErrorHandling(() =>
            {
                var product = _productRepository.FindProductById(request.Id);
                _productRepository.DeleteProduct(product);

                var productDto   = product.MapToProductDto();
                response.Product = productDto;
                response.Messages.Add("Successfully deleted the product");
                response.StatusCode = HttpStatusCode.OK;
            }, response);

            return(response);
        }
コード例 #17
0
        public override async Task <DeleteProductResponse> DeleteProduct(DeleteProductRequest request, ServerCallContext context)
        {
            var product = await _productsContext.Product.FindAsync(request.ProductId);

            if (product == null)
            {
                throw new RpcException(new Status(StatusCode.NotFound, $"Product with ID={request.ProductId} is not found."));
            }
            _productsContext.Remove(product);
            var deleteCount = await _productsContext.SaveChangesAsync();

            var response = new DeleteProductResponse
            {
                Success = deleteCount > 0
            };

            return(response);
        }
コード例 #18
0
        public ActionResult Delete(int ProductId)
        {
            DeleteProductRequest  request  = new DeleteProductRequest();
            DeleteProductResponse response = new DeleteProductResponse();

            request.ProductId = ProductId;
            response          = productService.DeleteProduct(request);
            if (response.Success)
            {
                return(RedirectToAction("Index"));
            }
            else
            {
                ProductListPageViewModel model = new ProductListPageViewModel();
                model.Success      = false;
                model.ErrorMessage = response.Message;
                return(View("Index", model));
            }
        }
コード例 #19
0
ファイル: TTAServiceProduct.cs プロジェクト: willdarwin/tta
        /// <summary>
        /// Deletes the product.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public DeleteProductResponse DeleteProduct(DeleteProductRequst request)
        {
            DeleteProductResponse response = new DeleteProductResponse();
            ProductService        service  = new ProductService();

            try
            {
                bool result = service.Delete(request.ProductId);
                if (result == false)
                {
                    response.IsFailed = true; response.Message = "Delete Product failed.";
                }
            }
            catch (Exception ex)
            {
                response.IsFailed = true;
                response.Message  = ex.Message;
            }

            return(response);
        }
コード例 #20
0
ファイル: AdminService.cs プロジェクト: ikelos555/HSROrderApp
        public DeleteProductResponse DeleteProduct(DeleteProductRequest request)
        {
            DeleteProductResponse response = new DeleteProductResponse();
            ProductBusinessComponent bc = DependencyInjectionHelper.GetProductBusinessComponent();

            bc.DeleteProduct(request.Id);

            return response;
        }
コード例 #21
0
 public void TestDeleteProduct()
 {
     DeleteProductResponse response = new DeleteProductResponse();
     Expect.Once.On(service).Method("DeleteProduct").Will(Return.Value(response));
     serviceFacade.DeleteProduct(1);
 }