/// <inheritdoc />
/// <summary>
/// Create a new category <b>Permissions Needed:</b> CATEGORIES_ADMIN
/// </summary>
/// <param name="category">The category to create</param>
public void CreateCategory(CategoryResource category)
{
mWebCallEvent.WebPath = "/categories";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(category); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mCreateCategoryStartTime = DateTime.Now;
mWebCallEvent.Context = mCreateCategoryResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mCreateCategoryStartTime, "CreateCategory", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
public async Task <IActionResult> CreateCategoryAsync([FromBody] CategoryResource categoryResource)
{
if (categoryResource == null)
{
ProblemDetails problem = new ProblemDetails
{
Title = "Failed to create a new category.",
Detail = "The specified category resource was null",
Instance = "ABA3B997-1B80-47FC-A72B-69BC0D8DFA93"
};
return(BadRequest(problem));
}
Category category = mapper.Map <CategoryResource, Category>(categoryResource);
try
{
await categoryService.AddAsync(category)
.ConfigureAwait(false);
categoryService.Save();
return(Created(nameof(CreateCategoryAsync), mapper.Map <Category, CategoryResourceResult>(category)));
}
catch (DbUpdateException e)
{
Log.Logger.Error(e, "Database exception");
ProblemDetails problem = new ProblemDetails
{
Title = "Failed to save the new category.",
Detail = "There was a problem while saving the category to the database.",
Instance = "D56DBE55-57A1-4655-99C5-4F4ECEEE3BE4"
};
return(BadRequest(problem));
}
}
public async Task <IActionResult> UpdateCategory(int categoryId, [FromBody] CategoryResource categoryResource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await categoriesRepository.GetCategoryByIdAsync(categoryId);
if (category == null)
{
return(NotFound());
}
mapper.Map <CategoryResource, Category>(categoryResource, category);
category.LastUpdate = DateTime.Now;
await unitOfWork.CompleteAsync();
category = await categoriesRepository.GetCategoryByIdAsync(category.Id);
var result = mapper.Map <Category, CategoryResource>(category);
return(Ok(result));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Create([FromBody] CategoryResource categoryResources)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = _mapper.Map <CategoryResource, Category>(categoryResources);
await _unitOfWork.CategoryRepository.AddAsync(category);
// if something happens and the new item can not be saved, return the error
if (!await _unitOfWork.CompleteAsync())
{
_logger.LogMessage(LoggingEvents.SavedFail, ApplicationConstants.ControllerName.Category, category.Id);
return(FailedToSave(category.Id));
}
category = await _unitOfWork.CategoryRepository.GetCategory(category.Id);
var result = _mapper.Map <Category, CategoryResource>(category);
_logger.LogMessage(LoggingEvents.Created, ApplicationConstants.ControllerName.Category, category.Id);
return(CreatedAtRoute(ApplicationConstants.ControllerName.Category, new { id = category.Id }, result));
}
public async Task <CategoryResource> AddAsync(CategoryResource resource)
{
Category entity = ToEntity(resource);
_db.Categories.Add(entity);
await _db.SaveChangesAsync();
return(ToResource(entity));
}
public async Task <CategoryResource> ReplaceAsync(int id, CategoryResource resource)
{
Category entity = await FindAsync(id);
entity.CategoryName = resource.CategoryName;
entity.Description = resource.Description;
await _db.SaveChangesAsync();
return(ToResource(entity));
}
protected async override Task <bool> GetDataAsync()
{
var categoryResource = new CategoryResource(Context);
_results = await categoryResource.GetCategoriesAsync(startIndex : StartIndex, pageSize : PageSize, sortBy : SortBy, filter : Filter, responseFields : ResponseFields);
TotalCount = _results.TotalCount;
PageCount = _results.PageCount;
PageSize = _results.PageSize;
return(_results.Items != null && _results.Items.Count > 0);
}
public async Task <IHttpActionResult> PostCategory(CategoryResource resoure)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CategoryResource result = await _categoriesService.AddAsync(resoure);
return(CreatedAtRoute("DefaultApi", new { id = result.Id }, result));
}
private static void CreateItem(CategoryResource aCategory, string aTitle, string aInfo)
{
ItemResource item = new ItemResource
{
Title = aTitle,
Content = new XmlDocument().CreateCDataSection(aInfo),
};
Assert.Check(item.Valid());
aCategory.Items.Add(item);
}
private static CategoryResource CreateCategory(ListOfCategoryResource CategoryList, string aTitle)
{
CategoryResource category = new CategoryResource
{
Title = aTitle
};
Assert.Check(category.Valid());
CategoryList.Categories.Add(category);
return(category);
}
public async Task <IActionResult> UpdateCategory(int id, [FromForm] CategoryResource category)
{
var target = await repository.GetCat(id);
if (target == null)
{
return(NotFound());
}
mapper.Map <CategoryResource, Category>(category, target);
repository.UpdateCat(target);
return(Ok(target));
}
public async Task <IHttpActionResult> GetCategory(int id)
{
try
{
CategoryResource resource = await _categoriesService.SingleAsync(id);
return(Ok(resource));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public async Task <IHttpActionResult> PutCategory(int id, CategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
resource.Id = id;
await _categoriesService.ReplaceAsync(id, resource);
return(StatusCode(HttpStatusCode.NoContent));
}
public static void Main(string[] args)
{
ListOfTestResource testList = new ListOfTestResource();
Ticket.CreateTest(testList, 0, "Test1", TestResourceResult.Pass, "Result1", "blah blah blah1");
Ticket.CreateTest(testList, 1, "Test2", TestResourceResult.Fail, "Result2", "blah blah blah2");
Ticket.CreateTest(testList, 2, "Test3", TestResourceResult.Warning, "Result3", "blah blah blah3");
ListOfCategoryResource categoryList = new ListOfCategoryResource();
var category1 = Ticket.CreateCategory(categoryList, "Audio");
Ticket.CreateItem(category1, "Item1", "item1-1 info...");
Ticket.CreateItem(category1, "Item2", "item1-2 info...");
Ticket.CreateItem(category1, "Item3", "item1-3 info...");
Ticket.CreateItem(category1, "Item4", "item1-4 info...");
CategoryResource category2 = Ticket.CreateCategory(categoryList, "Network Connection");
Ticket.CreateItem(category2, "Item1", "item2-1 info...");
Ticket.CreateItem(category2, "Item2", "item2-2 info...");
Ticket.CreateItem(category2, "Item3", "item2-3 info...");
Ticket.CreateItem(category2, "Item4", "item2-4 info...");
Ticket ticket = new Ticket("Eamonn", "Brady", "*****@*****.**", "01413035414", "UTC", "Any time between 12 and 1pm",
"Win7", "01010101", "Kiko DSM", "3.7.1", "00:26:0f:21:b9:67",
"It's broke!", "1.0.0", "Network Audio", categoryList, testList);
if (ticket.Valid())
{
string response;
if (ticket.Submit(out response))
{
Console.WriteLine("Ticket posted successfully!");
}
else
{
Console.WriteLine("Ticket post FAILED!!!");
}
}
else
{
Console.WriteLine("Ticket is INVALID!!!");
Console.WriteLine("\n\n\n\n" + ticket.ValidationInfo());
}
Thread.Sleep(3000);
}
public async Task <IActionResult> AddCategory([FromForm] CategoryResource category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var created = mapper.Map <CategoryResource, Category>(category);
await repository.AddCat(created);
await unit.Commit();
var result = mapper.Map <Category, CategoryResource>(created);
return(Ok(result));
}
public void DeleteCategoryBadRequestTest()
{
var categoryResource = new CategoryResource()
{
Name = "Beer"
};
var categoryResponse = new Mock <CategoryResponse>("Error trying to delete Category");
categoryService.Setup(p => p.DeleteAsync(It.IsAny <int>())).ReturnsAsync(categoryResponse.Object);
// Act
var badResult = categoryController.DeleteAsync(1);
// Assert
Assert.IsType <BadRequestObjectResult>(badResult.Result);
}
public async Task <IActionResult> CreateCategory([FromBody] CategoryResource categoryResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = mapper.Map <CategoryResource, Category>(categoryResource);
categoryRepository.AddCategory(category);
await unitOfWork.Complete();
var result = mapper.Map <Category, CategoryResource>(category);
return(Ok(result));
}
public IActionResult UpdateCategory(int id, [FromBody] CategoryResource categoryResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = categoryRepository.Get(id);
mapper.Map <CategoryResource, Category>(categoryResource);
uow.Complete();
var result = mapper.Map <Category, CategoryResource>(category);
return(Ok(result));
}
public void DeleteCategoryTest()
{
var categoryResource = new CategoryResource()
{
Id = 1
};
var categoryResponse = new Mock <CategoryResponse>(new Category());
categoryService.Setup(p => p.DeleteAsync(It.IsAny <int>())).ReturnsAsync(categoryResponse.Object);
mapper.Setup(m => m.Map <Category, CategoryResource>(It.IsAny <Category>())).Returns(categoryResource);
// Act
var okResult = categoryController.DeleteAsync(1);
// Assert
Assert.IsType <OkObjectResult>(okResult.Result);
}
public BreweryDbClient(string key)
{
ApplicationKey = key;
Beers = new BeerResource<Beer>(this);
Breweries = new BreweryResource<Brewery>(this);
Categories = new CategoryResource<Category>(this);
Adjuncts = new AdjunctResource<Adjunct>(this);
Yeasts = new YeastResource<Yeast>(this);
SocialSites = new SocialSiteResource<SocialSite>(this);
Events = new EventResource<Event>(this);
Features = new FeatureResource<Feature>(this);
Guildes = new GuildResource<Guild>(this);
Fermentables = new FermentableResource<Fermentable>(this);
FluidSizes = new FluidSizeResource<FluidSize>(this);
Changes = new ChangeResource<Change>(this);
}
public async Task <ActionResult> Create(CategoryResource categoryResource)
{
if (ModelState.IsValid)
{
var category = Mapper.Map <CategoryResource, Category>(categoryResource);
category.CreatedDate = DateTime.Now;
category.UpdatedDate = DateTime.Now;
var userId = System.Web.HttpContext.Current.User.Identity.GetUserId();
category.UserId = userId;
await _categoryService.AddAsync(category);
_categoryService.UnitOfWorkSaveChanges();
return(RedirectToAction("Index"));
}
return(View(categoryResource));
}
public async Task <ActionResult> Edit(CategoryResource categoryResource)
{
if (ModelState.IsValid)
{
var exstcategory = await _categoryService.GetByIdAsync(Convert.ToInt32(categoryResource.Id));
exstcategory.Name = categoryResource.Name;
exstcategory.Status = categoryResource.Status;
exstcategory.UpdatedDate = DateTime.Now;
var userId = System.Web.HttpContext.Current.User.Identity.GetUserId();
exstcategory.UserId = userId;
await _categoryService.UpdateAsync(exstcategory);
_categoryService.UnitOfWorkSaveChanges();
return(RedirectToAction("Index"));
}
return(View(categoryResource));
}
public async Task <IActionResult> DeleteAsync(int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var result = await _categoryService.DeleteAsync(id);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = new CategoryResource(result.Category.Id, result.Category.Name);
return(Ok(categoryResource));
}
public async Task <IEnumerable <ProductResource> > ListAsync()
{
var products = await _productService.ListAsync();
var resources = products.Select(product =>
{
var productResource = new ProductResource();
productResource.UnitOfMeasurement = product.UnitOfMeasurement.ToDescriptionString();
productResource.Name = product.Name;
productResource.Id = product.Id;
productResource.QuantityInPackage = product.QuantityInPackage;
var categoryResource = new CategoryResource(product.Category.Id, product.Category.Name);
productResource.Category = categoryResource;
return(productResource);
});
return(resources);
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
Category category = _mapper.Map <Category>(resource);
CategoryResponse result = await _categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
CategoryResource categoryResource = _mapper.Map <CategoryResource>(result.Category);
return(Ok(categoryResource));
}
public void PostNewCategoryTest()
{
var saveCategoryResource = new SaveCategoryResource()
{
Name = "Beer"
};
var categoryResource = new CategoryResource()
{
Name = "Beer"
};
var categoryResponse = new Mock <CategoryResponse>(new Category());
mapper.Setup(m => m.Map <Category, CategoryResource>(It.IsAny <Category>())).Returns(categoryResource);
categoryService.Setup(p => p.SaveAsync(It.IsAny <Category>())).ReturnsAsync(categoryResponse.Object);
// Act
var okResult = categoryController.PostAsync(saveCategoryResource);
// Assert
Assert.IsType <OkObjectResult>(okResult.Result);
}
public BreweryDbClient(string key, Func <HttpClient> httpClientFactory = null)
{
ApplicationKey = key;
if (httpClientFactory != null)
{
JsonDownloader.HttpClientFactory = httpClientFactory;
}
Beers = new BeerResource <Beer>(this);
Breweries = new BreweryResource <Brewery>(this);
Categories = new CategoryResource <Category>(this);
Adjuncts = new AdjunctResource <Adjunct>(this);
Yeasts = new YeastResource <Yeast>(this);
SocialSites = new SocialSiteResource <SocialSite>(this);
Events = new EventResource <Event>(this);
Features = new FeatureResource <Feature>(this);
Guildes = new GuildResource <Guild>(this);
Fermentables = new FermentableResource <Fermentable>(this);
FluidSizes = new FluidSizeResource <FluidSize>(this);
Changes = new ChangeResource <Change>(this);
}
public async Task <IActionResult> AddCategory([FromBody] CategoryResource category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var check = await _context.OsStItemcategories.AnyAsync(i => i.Name == category.Name);
if (check)
{
return(BadRequest("Bu adlı kateqoriya artıq mövcuddur!"));
}
var cat = _mapper.Map <CategoryResource, OsStItemcategories>(category);
_context.OsStItemcategories.Add(cat);
await _context.SaveChangesAsync();
var categories = await _context.OsStItemcategories.Include(s => s.OsStItemsubcategories).ToListAsync();
return(Ok(_mapper.Map <List <OsStItemcategories>, List <CategoryResource> >(categories)));
}
public async Task <IActionResult> UpdateCategory(int id, [FromBody] CategoryResource categoryResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await categoryRepository.GetCategory(id);
if (category == null)
{
return(NotFound());
}
mapper.Map <CategoryResource, Category>(categoryResource, category);
await unitOfWork.Complete();
var result = mapper.Map <Category, CategoryResource>(category);
return(Ok(result));
}
public async Task <IActionResult> UpdateCategory(int categoryId, CategoryResource categoryResource)
{
Category currentCategory = await categoryService.FindAsync(categoryId)
.ConfigureAwait(false);
if (currentCategory == null)
{
ProblemDetails problem = new ProblemDetails
{
Title = "Failed to update the category.",
Detail = "The specified category could not be found in the database",
Instance = "8F167FDF-3B2B-4E71-B3D0-AA2B1C1CE2C3"
};
return(NotFound(problem));
}
mapper.Map(categoryResource, currentCategory);
categoryService.Update(currentCategory);
categoryService.Save();
return(Ok(mapper.Map <Category, CategoryResourceResult>(currentCategory)));
}
public async Task <IActionResult> PutAsync([FromBody] UpdateCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var resourceToSave = new Category();
resourceToSave.Name = resource.Name;
var result = await _categoryService.UpdateAsync(resource.Id, resourceToSave);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = new CategoryResource(result.Category.Id, result.Category.Name);
return(Ok(categoryResource));
}
