public async Task <IActionResult> Create([FromBody] CreateBrandRequest brandRequest) { var brand = new Brand { ArabicName = brandRequest.ArabicName, EnglishName = brandRequest.EnglishName, ImgUrl = brandRequest.ImgUrl }; var status = await _brandService.CreateBrandAsync(brand); if (status == -1) { return(Conflict(new ErrorResponse { message = "Dublicate Entry", status = Conflict().StatusCode })); } if (status == 1) { var response = new BrandResponse { Id = brand.Id }; return(Ok(response)); } return(NotFound(new ErrorResponse { message = "Not Found", status = NotFound().StatusCode })); }
public async Task <CreateBrandResponse> AddAsync(CreateBrandRequest brand) { var brandValidatorResult = new CreateBrandValidator().Validate(brand); var errorResult = new List <BaseResponse <CreateBrandResponse, ErrorsResponse> >(); //errorResult.AddRange(brandValidatorResult.Errors.Select(p => new BaseResponse<CreateBrandResponse, ErrorsResponse>().Error.AddError(p.ErrorMessage))); if (!brandValidatorResult.IsValid) { var response = _mapper.Map <CreateBrandResponse>(errorResult); return(response); } var obj = new Brand() { Id = Guid.NewGuid(), Name = brand.Name, }; await _brandRepository.AddAsync(obj); var result = _mapper.Map <CreateBrandResponse>(obj); return(result); }
public async stt::Task CreateBrandRequestObjectAsync() { moq::Mock <IdentityAwareProxyOAuthService.IdentityAwareProxyOAuthServiceClient> mockGrpcClient = new moq::Mock <IdentityAwareProxyOAuthService.IdentityAwareProxyOAuthServiceClient>(moq::MockBehavior.Strict); CreateBrandRequest request = new CreateBrandRequest { Parent = "parent7858e4d0", Brand = new Brand(), }; Brand expectedResponse = new Brand { Name = "name1c9368b0", SupportEmail = "support_email60b1be92", ApplicationTitle = "application_title59ccbd06", OrgInternalOnly = false, }; mockGrpcClient.Setup(x => x.CreateBrandAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Brand>(stt::Task.FromResult(expectedResponse), null, null, null, null)); IdentityAwareProxyOAuthServiceClient client = new IdentityAwareProxyOAuthServiceClientImpl(mockGrpcClient.Object, null); Brand responseCallSettings = await client.CreateBrandAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); Brand responseCancellationToken = await client.CreateBrandAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public static Brand ConvertToBrand(this CreateBrandRequest createRequest) { Brand brand = new Brand(); brand.Name = createRequest.Name; return(brand); }
public CreateBrandResponse SaveBrand(CreateBrandRequest createBrandRequest) { var brand = messageMapper.MapToBrand(createBrandRequest.Brand); brandRepository.SaveBrand(brand); var createbrandresponse = new CreateBrandResponse { Brand = messageMapper.MapToBrandDto(brand) }; return(createbrandresponse); }
public static void UpdateBrand(this Brand model, CreateBrandRequest createModel) { model.Name = createModel.Name; model.Alias = createModel.Alias; model.Description = createModel.Description; model.Logo = createModel.Logo; model.MetaDescription = createModel.MetaDescription; model.MetaKeyword = createModel.MetaKeyword; model.CreateDate = createModel.CreateDate; model.CreateBy = createModel.CreateBy; model.Status = createModel.Status; }
public IActionResult Create(CreateBrandRequest request) { try { var brand = Mapper.Map <Brand>(request); return(Created("/Brand", Mapper.Map <BrandDTO>(_serviceUow.BrandService.CreateBrand(brand)))); } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task <IActionResult> CreateBrand([FromBody] CreateBrandRequest brand) { try { var obj = await _brandService.AddAsync(brand); return(Created(nameof(CreateBrand), obj)); } catch (ArgumentNullException ex) { return(BadRequest(ex.Message)); } }
public CreateBrandResponse SaveBrand(CreateBrandRequest parBrandRequest) { var varBrand = _MessageMapper.MapToBrand(parBrandRequest.locBrandDTO); _BrandRepository.Save(); var varBrandDTO = _MessageMapper.MapToBrandDto(varBrand); CreateBrandResponse locCreateBrandResponse = new CreateBrandResponse { locBrandDTO = varBrandDTO }; return(locCreateBrandResponse); }
/// <summary>Snippet for CreateBrand</summary> public void CreateBrandRequestObject() { // Snippet: CreateBrand(CreateBrandRequest, CallSettings) // Create client IdentityAwareProxyOAuthServiceClient identityAwareProxyOAuthServiceClient = IdentityAwareProxyOAuthServiceClient.Create(); // Initialize request argument(s) CreateBrandRequest request = new CreateBrandRequest { Parent = "", Brand = new Brand(), }; // Make the request Brand response = identityAwareProxyOAuthServiceClient.CreateBrand(request); // End snippet }
public async Task <IActionResult> Create([FromBody] CreateBrandRequest request) { var test = "1"; var name = request.Name.Trim(); var brand = new Brand { Name = name }; await _brandService.CreateBrandAsync(brand); brand = await _brandService.GetBrandByNameAsync(name); return(Created($"v1/api/brands/{brand.Id}", _mapper.Map <BrandResponse>(brand))); }
public CreateBrandResponse CreateBrand(CreateBrandRequest request) { CreateBrandResponse response = new CreateBrandResponse(); try { Brand brand = request.ConvertToBrand(); brandRepository.Create(brand); response.Success = true; } catch (Exception ex) { response.Success = false; response.Message = ex.Message; } return(response); }
public CreateBrandResponse SaveBrand(CreateBrandRequest request) { var response = new CreateBrandResponse(); WithErrorHandling(() => { var brand = request.Brand.MapToBrand(); _brandRepository.SaveBrand(brand); var brandDto = brand.MapToBrandDto(); response.Brand = brandDto; response.Messages.Add("Successfully saved the brand"); response.StatusCode = HttpStatusCode.Created; }, response); return(response); }
/// <summary>Snippet for CreateBrandAsync</summary> public async Task CreateBrandRequestObjectAsync() { // Snippet: CreateBrandAsync(CreateBrandRequest, CallSettings) // Additional: CreateBrandAsync(CreateBrandRequest, CancellationToken) // Create client IdentityAwareProxyOAuthServiceClient identityAwareProxyOAuthServiceClient = await IdentityAwareProxyOAuthServiceClient.CreateAsync(); // Initialize request argument(s) CreateBrandRequest request = new CreateBrandRequest { Parent = "", Brand = new Brand(), }; // Make the request Brand response = await identityAwareProxyOAuthServiceClient.CreateBrandAsync(request); // End snippet }
public IHttpActionResult Create(CreateBrandRequest requestModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var model = new Brand(); model.UpdateBrand(requestModel); var result = _brandService.Add(model); if (result != null) { return(Ok(result)); } return(BadRequest()); }
public CreateBrandResponse SaveBrand(CreateBrandRequest brandRequest) { var createBrandResponse = new CreateBrandResponse(); var brand = _messageMapper.MapToBrand(brandRequest.brand); try { _brandRepository.SaveBrand(brand); var brandDto = _messageMapper.MapToBrandDto(brand); createBrandResponse.Brand = brandDto; createBrandResponse.Messages.Add(item: "Successfully saved the Brand"); createBrandResponse.StatusCode = System.Net.HttpStatusCode.Created; } catch (Exception e) { var error = e.ToString(); createBrandResponse.Messages.Add(error); createBrandResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError; } return(createBrandResponse); }
public ActionResult Edit(BrandSinglePageViewModel model) { if (model.BrandViewModel.BrandId == 0) { CreateBrandRequest request = new CreateBrandRequest(); CreateBrandResponse response = new CreateBrandResponse(); request.Name = model.BrandViewModel.Name; response = brandService.CreateBrand(request); if (response.Success) { return(RedirectToAction("Index")); } else { model.Success = false; model.ErrorMessage = response.Message; return(View(model)); } } else { UpdateBrandRequest request = new UpdateBrandRequest(); UpdateBrandResponse response = new UpdateBrandResponse(); request.BrandId = model.BrandViewModel.BrandId; request.Name = model.BrandViewModel.Name; response = brandService.UpdateBrand(request); if (response.Success) { return(RedirectToAction("Index")); } else { model.Success = false; model.ErrorMessage = response.Message; return(View(model)); } } }
public void CreateBrandRequestObject() { moq::Mock <IdentityAwareProxyOAuthService.IdentityAwareProxyOAuthServiceClient> mockGrpcClient = new moq::Mock <IdentityAwareProxyOAuthService.IdentityAwareProxyOAuthServiceClient>(moq::MockBehavior.Strict); CreateBrandRequest request = new CreateBrandRequest { Parent = "parent7858e4d0", Brand = new Brand(), }; Brand expectedResponse = new Brand { Name = "name1c9368b0", SupportEmail = "support_email60b1be92", ApplicationTitle = "application_title59ccbd06", OrgInternalOnly = false, }; mockGrpcClient.Setup(x => x.CreateBrand(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); IdentityAwareProxyOAuthServiceClient client = new IdentityAwareProxyOAuthServiceClientImpl(mockGrpcClient.Object, null); Brand response = client.CreateBrand(request); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public ActionResult <CreateBrandResponse> PostBrand(CreateBrandRequest request) { var response = _service.SaveBrand(request); return(response); }
public Task <CreateBrandResponse> CreateBrand([FromBody] CreateBrandRequest request) => _mediator.Send(request);
public ActionResult <CreateBrandResponse> PostBrand(CreateBrandRequest createBrandRequest) //Model binding { var createBrandResponse = _brandService.SaveBrand(createBrandRequest); return(createBrandResponse); }
public ActionResult <CreateBrandResponse> PostBrand(CreateBrandRequest createBrandRequest) { return(brandService.SaveBrand(createBrandRequest)); }