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));
}
