public async Task <CreateCategoryResponseModel> CreateCategory(CreateCategoryRequestModel createCategoryRequestModel)
{
if (createCategoryRequestModel == null)
{
throw new ArgumentNullException(nameof(createCategoryRequestModel));
}
var createCategoryResponseModel = new CreateCategoryResponseModel();
try
{
await _inMemoryStorage.Save(
new Category
{
Id = createCategoryRequestModel.Id,
Description = createCategoryRequestModel.Description,
Name = createCategoryRequestModel.Name,
UserId = createCategoryRequestModel.UserId,
}, true)
.ConfigureAwait(false);
}
catch (Exception ex)
{
createCategoryResponseModel.ErrorMessage = ex.Message;
}
return(createCategoryResponseModel);
}
public async Task <JObject> CreateCategoryAsync(CreateCategoryRequestModel model, string accessToken)
{
try
{
var client = _httpClientFactory.CreateClient("Ocelot");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
StringContent content = new(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");
var result = await client.PostAsync("/v1/Category", content);
string bodyContent = await result.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(bodyContent))
{
return(JObject.Parse(bodyContent));
}
JObject error = new();
error.Add("statusCode", (int)result.StatusCode);
error.Add("title", result.ReasonPhrase);
error.Add("succeeded", false);
return(error);
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Post([FromBody] CreateCategoryRequestModel model)
{
var id = await this.categories.Create(
model.Name);
return(Ok(id));
}
public async Task <ActionResult <int> > Create(CreateCategoryRequestModel model)
{
var userId = this.User.GetId();
var id = await this.categoryService.Create(model.CategoryPicUrl, model.Name, userId);
return(Created(nameof(this.Create), id));
}
public async Task <IActionResult> Create([FromBody] CreateCategoryRequestModel model)
{
var idResult = await this.categoryService.Create(model.Name);
if (idResult == 0)
{
return(this.BadRequest($@"Category with Name: ""{model.Name}"" already exists."));
}
return(this.Ok(idResult));
}
public async void TestCreateCategoryAsync(CreateCategoryRequestModel requestModel)
{
var responseModel = await service.CreateCategoryAsync(requestModel);
Assert.Equal(HttpStatusCode.OK, responseModel.HttpResponse.StatusCode);
Assert.NotNull(responseModel.Data);
Assert.True(!string.IsNullOrWhiteSpace(responseModel.Data.ToParam));
var categoryCode = responseModel.Data.ToParam;
var expectedCategoryUri = $"/api/account/{ACCOUNT_CODE}/categories/{categoryCode}.xml";
Assert.Equal(expectedCategoryUri, responseModel.Data.CategoryUri);
}
public async Task <ActionResult> Create(CreateCategoryRequestModel model)
{
var userId = this.User.GetId();
var result = await this.categoryService.CreateCategoryAsync(model.Name, userId);
if (!result.Success)
{
return(Unauthorized(new { result.Errors }));
}
;
return(Created(nameof(Create), result));
}
public IActionResult Post([FromBody] CreateCategoryRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!this.categories.Exists(model.Name))
{
return(BadRequest("Author don't exist."));
}
var id = this.categories.Create(model.Name);
return(Ok(id));
}
public async Task <IActionResult> Post([FromBody] CreateCategoryRequestModel model)
{
if (await this.categories.Exists(model.Name))
{
return(BadRequest("Category already exist!!!"));
}
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
var id = await this.categories.Create(model.Name);
return(Ok(id));
}
public async Task <IActionResult> AddCategoryMakeModel([FromBody] CreateCategoryRequestModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var doesExist = await _categoryReadRepository.DoesCategoryExist(model.Name);
if (doesExist && !model.ParentId.HasValue)
{
return(BadRequest("Category name already exists!"));
}
Category category;
Category returnModel;
if (model.ParentId.HasValue)
{
category = Category.CreateChildItem(model.Name, model.Description, model.ParentId.Value);
var currentCategory = await _categoryReadRepository.GetCategoryWithChildren(model.ParentId.Value);
currentCategory.AddChildCategory(category);
returnModel = _categoryWriteRepository.UpdateCategory(currentCategory);
}
else
{
category = Category.CreateInitialItem(model.Name, model.Description);
returnModel = _categoryWriteRepository.AddCategory(category);
}
_categoryWriteRepository.SaveChanges();
return(Ok(returnModel));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public CategoryResponseModel CreateCategory(CreateCategoryRequestModel createCategoryRequest)
{
if (createCategoryRequest == null)
{
throw new EShopperException("Please provide required information!");
}
var isCategoryExist = _unitOfWork.Category.Find(x => x.Title == createCategoryRequest.Title).FirstOrDefault();
if (isCategoryExist != null)
{
throw new EShopperException($"{createCategoryRequest.Title} - Already exist!");
}
using (var transaction = _unitOfWork.EShopperDbContext.Database.BeginTransaction())
{
var mappedCategoryData = _mapper.Map <Category>(createCategoryRequest, options =>
{
options.AfterMap((src, dest) => dest.UserId = _currentUser.Id);
});
try
{
_unitOfWork.Category.Add(mappedCategoryData);
_unitOfWork.Complete();
transaction.Commit();
transaction.Commit();
}
catch (Exception ex)
{
throw new EShopperException(ex.Message);
}
transaction.Dispose();
}
return(new CategoryResponseModel
{
Message = $"{createCategoryRequest.Title} - Added"
});
}
public async Task <IActionResult> CreateCategory(CreateCategoryRequestModel model)
{
try
{
string accessToken = await HttpContext.GetTokenAsync("access_token");
var result = await _categoryService.CreateCategoryAsync(model, accessToken);
ViewBag.Result = result;
}
catch (Exception)
{
JObject error = new();
error.Add("succeeded", false);
error.Add("title", "Internal Error");
ViewBag.Result = error;
}
return(View());
}
// Category public abstract Task <GovDeliveryResponseModel <CreateCategoryResponseModel> > CreateCategoryAsync(CreateCategoryRequestModel resquestModel);
public async Task <IActionResult> Create([FromBody] CreateCategoryRequestModel categoryRequestModel)
{
_logger.LogDebug($"Got request for creating category with name: {categoryRequestModel?.Name} and user id: {categoryRequestModel?.UserId}");
return(CreatedAtAction("Create", new { categoryName = categoryRequestModel.Name }, await _categoryCommandHandler.CreateCategory(categoryRequestModel).ConfigureAwait(false)));
}
public IActionResult Create([FromBody] CreateCategoryRequestModel createCategoryRequestModel)
{
var response = _categoryService.CreateCategory(createCategoryRequestModel);
return(Ok(response));
}
// Category
public override async Task <GovDeliveryResponseModel <CreateCategoryResponseModel> > CreateCategoryAsync(CreateCategoryRequestModel requestModel)
{
var responseModel = new CreateCategoryResponseModel
{
ToParam = "12345",
CategoryUri = $"/api/account/{accountCode}/categories/12345.xml",
};
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = SerializationUtils.ModelToStringContent(responseModel)
};
return(new GovDeliveryResponseModel <CreateCategoryResponseModel>
{
HttpResponse = httpResponse,
Data = await SerializationUtils.ResponseContentToModel <CreateCategoryResponseModel>(httpResponse.Content)
});
}
// Categories
public override async Task <GovDeliveryResponseModel <CreateCategoryResponseModel> > CreateCategoryAsync(CreateCategoryRequestModel requestModel)
{
var res = await client.PostAsync("categories.xml", SerializationUtils.ModelToStringContent(requestModel));
InterceptHttpError(res);
return(new GovDeliveryResponseModel <CreateCategoryResponseModel>
{
HttpResponse = res,
Data = await SerializationUtils.ResponseContentToModel <CreateCategoryResponseModel>(res.Content)
});
}
