public async Task Create(CategoryInputModel model) { Category category = model.To <Category>(); await context.Categories.AddAsync(category); await context.SaveChangesAsync(); }
public CategoryDto CreateCategory(CategoryInputModel category, string slug) { int nextInt = 0; if (CategoryDataProvider.Categories.Count() == 0) { nextInt = 1; } else { nextInt = CategoryDataProvider.Categories.OrderByDescending(c => c.Id).FirstOrDefault().Id + 1; } var entity = new Category { Id = nextInt, Name = category.Name, Slug = slug, ModifiedBy = "Admin" }; CategoryDataProvider.Categories.Add(entity); return(new CategoryDto { Id = entity.Id, Name = entity.Name, Slug = entity.Slug }); }
public async Task <IActionResult> Edit(int id) { if (id == 0) { return(this.CustomNotFound()); } var jobCategory = await this.categoriesService.GetByIdAsync <JobCategoriesViewModel>(id); if (jobCategory == null) { return(this.CustomNotFound()); } var inputModel = new CategoryInputModel { BaseJobCategoryId = jobCategory.BaseJobCategoryId, Description = jobCategory.Description, Id = jobCategory.Id, Name = jobCategory.Name, PictureUrl = jobCategory.PictureUrl, }; return(this.View(inputModel)); }
public async Task <object> Create([FromBody] CategoryInputModel model) { if (this.User.IsInRole("Admin")) { try { var category = await this.categoryService.Create(model); await this.hubContext.Clients.All.SendAsync("CategoryAdd", category); return(this.Ok(new CreateEditReturnMessage <CategoryViewModel> { Message = "Category created successfully", Data = category })); } catch (Exception e) { return(this.BadRequest(new ReturnMessage { Message = e.Message })); } } return(this.Unauthorized(new ReturnMessage { Message = "You are unauthorized!" })); }
public async Task <IActionResult> Create(CategoryInputModel categoryInput) { var existsMatchingCategory = this.categoriesService .Exists(x => x.Name == categoryInput.Name); if (!this.ModelState.IsValid || existsMatchingCategory) { if (existsMatchingCategory) { this.ModelState.AddModelError(MatchingCategoryKey, MatchingCategoryErrorMessage); } return(this.View(categoryInput)); } var image = await this.cloudinaryService.SaveImageAsync(categoryInput.FormFile); await this.categoriesService.AddAsync(categoryInput, image); var categoryNameEncoded = HttpUtility.HtmlEncode(categoryInput.Name); this.TempData[GlobalConstants.MessageKey] = $"Successfully created category <strong>{categoryNameEncoded}</strong>"; return(this.RedirectToAction("Index", "Categories", new { area = "Forum" })); }
public async Task <ActionResult> Create([FromBody] CategoryInputModel input) { if (this.User.Identity.Name == GlobalConstants.AdminName) { var isCategoryAlreadyExisting = await this.categoriesService.IsCategoryAlreadyExistingAsync(input.Name); if (isCategoryAlreadyExisting) { return(this.BadRequest(new BadRequestViewModel { Message = Messages.AlreadyExistsCategory, })); } try { await this.categoriesService.CreateAsync(input.Name, input.Picture); return(this.Ok(new { Message = Messages.SuccessfullyAdded, })); } catch (Exception) { return(this.BadRequest(new BadRequestViewModel { Message = Messages.UnknownError, })); } } return(this.Unauthorized()); }
public async Task DoesCategoryCreateAsyncWorksCorrectly() { var categoryList = new List <Category>(); var service = this.CreateMockAndConfigureService(categoryList, new List <CategoryRecipe>()); using FileStream stream = File.OpenRead(TestImageName); var file = new FormFile(stream, 0, stream.Length, null, stream.Name) { Headers = new HeaderDictionary(), ContentType = TestImageContentType, }; var categoryToAdd = new CategoryInputModel { Name = TestCategoryName, Image = file, }; await service.CreateAsync(categoryToAdd, TestRootPath); var count = categoryList.Count(); Assert.Equal(1, count); }
public async Task <int> CreateAsync(CategoryInputModel inputModel, string rootPath) { if (this.categoriesRepository.All().Any(x => x.Name == inputModel.Name)) { throw new ArgumentException(ExceptionMessages.CategoryAlreadyExists, inputModel.Name); } var imageName = inputModel.Name.ToLower().Replace(" ", "-"); var imageUrl = $"/assets/img/categories/{imageName}.jpg"; string imagePath = rootPath + imageUrl; using (FileStream stream = new FileStream(imagePath, FileMode.Create)) { await inputModel.Image.CopyToAsync(stream); } var category = new Category { Name = inputModel.Name, ImageUrl = imageUrl, }; await this.categoriesRepository.AddAsync(category); await this.categoriesRepository.SaveChangesAsync(); return(category.Id); }
/// <summary> /// Add new category /// </summary> /// <param name="model">Category that should be added</param> /// <returns>Action result</returns> public async Task <IHttpActionResult> Post(CategoryInputModel model) { if (model == null) { return(BadRequest("Model can not be empty.")); } try { if (ModelState.IsValid) { _unitOfWork.Categories.Add(_mapper.Map <Category>(model)); await _unitOfWork.Commit(); } else { return(BadRequest(ModelState)); } } catch { return(InternalServerError()); } return(Ok("Category added")); }
/* From teacher: * "Betri leið væri að sækja stærsta Id * og incrementa það þegar verið er að vinna með lista." */ public Category ToCategory(CategoryInputModel category) { var entity = Mapper.Map <Category>(category); entity.Id = _dataContext.getCategories.Max(c => c.Id) + 1; return(entity); }
public async Task CreateCategoryFailDueToUnauthorizedToken(string email, string password, string username, string categoryName) { await this.Register(email, password, username); var token = await this.Login(email, password); this.client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); var category = new CategoryInputModel { Name = categoryName }; var json = new StringContent( JsonConvert.SerializeObject(category), Encoding.UTF8, "application/json"); var response = await this.client.PostAsync(CategoryCreateEndpoint, json); var content = JsonConvert.DeserializeObject <ReturnMessage>(await response.Content.ReadAsStringAsync()); Assert.Equal(StatusCodes.Status401Unauthorized, content.Status); Assert.Equal(UnauthorizedError, content.Message); }
public async Task CreateCategorySuccessfully(string email, string password, string categoryName) { var token = await this.Login(email, password); this.client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); var category = new CategoryInputModel { Name = categoryName }; var json = new StringContent( JsonConvert.SerializeObject(category), Encoding.UTF8, "application/json"); var response = await this.client.PostAsync(CategoryCreateEndpoint, json); response.EnsureSuccessStatusCode(); var content = JsonConvert.DeserializeObject <CreateEditReturnMessage <CategoryViewModel> >(await response.Content.ReadAsStringAsync()); Assert.Equal("Category created successfully", content.Message); Assert.Equal(StatusCodes.Status200OK, content.Status); }
public async Task <IActionResult> Create(CategoryInputModel categoryData) { if (!this.ModelState.IsValid) { return(this.BadRequest(this.ModelState.ToDictionary(x => x.Key, x => x.Value.Errors))); } var category = new Category { Name = categoryData.Name, NormalizedName = categoryData.Name.ToUpper(), CreatedOn = DateTime.UtcNow, EditedOn = DateTime.UtcNow, IsActive = true }; try { await this.categoryService.Create(category); } catch (Exception e) { this.logger.LogError(e.Message); this.logger.LogInformation(e.StackTrace); return(this.BadRequest("An error occurred while trying to create a category!")); } return(this.Ok("Category created successfully!")); }
public ActionResult <CategoryViewModel> Post(CategoryInputModel categoryInputModel) { Category category = MapearCategory(categoryInputModel); var response = _categoryService.save(category); return((response.Error == false)? Ok(response.Object): BadRequest(response.Menssage)); }
public async Task <IHttpActionResult> Post(CategoryInputModel inputModel) { if (inputModel == null) { throw new ArgumentException("inputModel can't be null"); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var category = new Category() { Name = inputModel.Name, }; var result = await categoryRepository.SaveAsync(category); if (!result) { throw new OperationCanceledException("Error when saved!"); } return(Ok()); }
public async Task <IHttpActionResult> Put([FromUri] int id, [FromBody] CategoryInputModel inputModel) { if (inputModel == null) { throw new ArgumentException("inputModel can't be null"); } if (!ModelState.IsValid) { return(BadRequest()); } var category = await categoryRepository.GetByIdAsync(id); if (category == null) { return(NotFound()); } category.Name = inputModel.Name; var result = await categoryRepository.SaveAsync(category); if (!result) { throw new OperationCanceledException("Error when saved!"); } return(Ok()); }
public CategoryViewModel Category(CategoryInputModel inputModel) { CategoryViewModel viewModel = new CategoryViewModel(); //initialize the dropdownlist values string ex; var performanceCounterCategories = _performanceMonitorService.CategoryNames(out ex).ToList(); if (ex == string.Empty) { var categoryList = performanceCounterCategories.Select(c => new SelectListItem { Text = c.ToString(), Value = c.ToString() }); viewModel.Accessible = true; viewModel.CategoryList = new SelectList(categoryList, "Value", "Text", inputModel.CategoryName); return(viewModel); } else { _notifier.Error(T("Error: Not able to load the categories. Exception: {0} ", ex)); viewModel.Accessible = false; return(viewModel); } }
public int CreateNewCategory(CategoryInputModel category) { var entity = ToCategory(category); _dataContext.getCategories.Add(entity); return(entity.Id); }
public async Task <IActionResult> EditPost(string id, [FromBody] CategoryInputModel categoryInput) { bool isIdCorrect = int.TryParse(id, out int categoryId); if (!isIdCorrect) { return(this.NotFound("Category does not exist!")); } var category = this.categoryService.GetById(categoryId, true); if (category == null) { return(this.NotFound("Category does not exist!")); } if (!this.ModelState.IsValid) { return(this.BadRequest(this.ModelState.ToDictionary(x => x.Key, x => x.Value.Errors))); } try { await this.categoryService.Update(category, categoryInput); } catch (Exception e) { this.logger.LogError(e.Message); this.logger.LogInformation(e.StackTrace); return(this.BadRequest("An error occurred while trying to edit category!")); } return(this.Ok("Successfully edited category!")); }
public async Task CreateAsync(CategoryInputModel input, string imagePath) { var category = new Category() { Name = input.Name, Title = input.Title, Description = input.Description, }; Directory.CreateDirectory($"{imagePath}/categories/"); foreach (var image in input.Images) { var extension = Path.GetExtension(image.FileName).TrimStart('.'); if (!this.allowedExtensions.Any(x => extension.EndsWith(x))) { throw new Exception($"Invalid image extension {extension}"); } var dbImage = new Image { Extension = extension, }; category.Images.Add(dbImage); var physicalPath = $"{imagePath}/categories/{dbImage.Id}.{extension}"; await using Stream fileStream = new FileStream(physicalPath, FileMode.Create); await image.CopyToAsync(fileStream); } await this.categoriesRepository.AddAsync(category); await this.categoriesRepository.SaveChangesAsync(); }
public void UpdateCategoryById(CategoryInputModel body, int id) { var entity = CategoryDataProvider.Categories.FirstOrDefault(c => c.Id == id); //Update props entity.Name = body.Name; entity.Slug = body.Name.Replace(' ', '-').ToLower(); }
public void updateCategoryById(int categoryId, [FromBody] CategoryInputModel inputModel) { if (!ModelState.IsValid) { throw new ModelFormatException(); } _categoryService.updateCategoryById(categoryId, inputModel); }
public IActionResult Create(CategoryInputModel model) { this.categoryService.Create(model, this.User); this.TempData["Message"] = $"Successfully created the {model.Name} category."; return(this.Redirect("/Admin/Category/Create")); }
public void UpdateCategoryById(CategoryInputModel category, int categoryId) { var updateCategory = _dataContext.getCategories.FirstOrDefault(c => c.Id == categoryId); updateCategory.Name = category.Name; updateCategory.ParentCategoryId = category.ParentCategoryId; updateCategory.Slug = category.Slug; }
public async Task Update(int id, CategoryInputModel model) { Category category = context.Categories.Find(id); category.Name = model.Name; context.Categories.Update(category); await context.SaveChangesAsync(); }
public ActionResult <string> createCategory([FromBody] CategoryInputModel inputModel) { if (!ModelState.IsValid) { throw new ModelFormatException(); } return(getCategoryById(_categoryService.createCategory(inputModel))); }
public IActionResult UpdateCategoryById([FromBody] CategoryInputModel body, int id) { if (!ModelState.IsValid) { return(BadRequest("Data was not properly formatted.")); } _categoryService.UpdateCategoryById(body, id); return(NoContent()); }
public void UpdateCategoryById(CategoryInputModel category, int id) { var entity = DataProvider.Categories.FirstOrDefault(n => n.Id == id); entity.Name = category.Name; entity.Slug = category.Name.ToLower().Replace(' ', '-'); entity.ModifiedDate = DateTime.Now; entity.ModifiedBy = "TechnicalRadiationAdmin"; }
public IActionResult EditCategory(int id, [FromBody] CategoryInputModel category) { if (!ModelState.IsValid) { throw new InputFormatException("Category input model was not properly formatted."); } _categoryService.UpdateCategoryById(category, id); return(NoContent()); }
public ActionResult Create() { var sections = this.Data.Sections.All().ProjectTo <SectionConciseViewModel>().ToList(); var inputModel = new CategoryInputModel { Sections = new SelectList(sections, "Id", "Title") }; return(this.View(inputModel)); }
public ActionResult Add(CategoryInputModel model) { if (!this.ModelState.IsValid) { return this.View(model); } this.categories.Create(model.Name); return this.RedirectToAction("ListCategories", "ListCategories"); }
public ActionResult Destroy([DataSourceRequest]DataSourceRequest request, CategoryInputModel categoryInputModel) { CategoryViewModel categoryViewModel = null; if (this.ModelState.IsValid) { var category = this.categoryService.DeleteById(categoryInputModel.Id); this.fileService.DeleteById(category.ImageId); this.categoryService.Update(); categoryViewModel = this.Mapper.Map<CategoryViewModel>(category); } return this.Json(new[] { categoryViewModel }.ToDataSourceResult(request, this.ModelState)); }
public ActionResult Create([DataSourceRequest]DataSourceRequest request, CategoryInputModel categoryInputModel) { CategoryViewModel categoryViewModel = null; if (this.ModelState.IsValid) { var category = this.Mapper.Map<Category>(categoryInputModel); // TODO: find a better way to pass the ImageId string fileName = categoryInputModel.ImageFileName; category.ImageId = Guid.Parse(fileName.Remove(fileName.IndexOf('.'))); this.categoryService.Add(category); categoryViewModel = this.Mapper.Map<CategoryViewModel>(category); categoryViewModel.ImageFileName = categoryInputModel.ImageFileName; } return this.Json(new[] { categoryViewModel }.ToDataSourceResult(request, this.ModelState)); }
public ActionResult Add(CategoryInputModel model) { if (this.ModelState.IsValid) { var categoryName = this.categories .GetAll() .FirstOrDefault(x => x.Name.ToLower() == model.Name.ToLower()); if (categoryName == null) { var category = this.Mapper.Map<Category>(model); this.categories.Add(category); TempData["Success"] = GlobalConstants.CategoryAddNotify; } else { TempData["Warning"] = GlobalConstants.CategoryExistsNotify; } return this.Redirect("/Admin/Categories/Index"); } return this.View(model); }