public async Task AddAsync(CategoryUpdateRequest name) { await CategoryRepository.CreateAsync(new Category() { Name = name.Name }); }
public async Task <IActionResult> PutCategory(long id, CategoryUpdateRequest category) { var cat = _mapper.Map <Category>(category.Data); cat.CategoryId = id; _context.Entry(cat).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <BaseDtoResponse <CategoryDto> > Update(Guid id, CategoryUpdateRequest request) { try { Category category = await _categoryRepository.GetById(id); if (category != null) { category.Name = request.Name; category.Description = request.Description; await _categoryRepository.Update(category); Category updatedResult = await _categoryRepository.GetById(id); CategoryDto result = _mapper.Map <Category, CategoryDto>(updatedResult); return(new BaseDtoResponse <CategoryDto>(result)); } else { return(new BaseDtoResponse <CategoryDto>("Category Not found")); } } catch (Exception ex) { return(new BaseDtoResponse <CategoryDto>($"An error occurred when updating the category: {ex.Message}")); } }
public CategoryUpdateResponse Update(CategoryUpdateRequest request) { var response = new CategoryUpdateResponse(); var existing = CheckForExisting(request.Name); if (existing != null && existing.Id != request.Id) { response.ErrorMessage = "Update would create a duplicate"; } else { var existingById = _categoryRepository.Get(request.Id); if (existingById == null) { response.ErrorMessage = "Category not found"; } else { _session.Flush(); existingById.Name = request.Name; existingById.LastUpdate = DateTime.UtcNow; _categoryRepository.Update(existingById); response.Category = new Category() { Id = existingById.Id, Name = existingById.Name, LastUpdate = existingById.LastUpdate }; } } return(response); }
public async Task <IActionResult> Save(string strCategory) { JavaScriptSerializer serializer = new JavaScriptSerializer(); CategoryVm categoryVm = serializer.Deserialize <CategoryVm>(strCategory); bool status = false; if (categoryVm.Id == 0) { var request = new CategoryCreateRequest(); request.Name = categoryVm.Name; request.Description = categoryVm.Description; request.UserId = new Guid("69bd714f-9576-45ba-b5b7-f00649be00de"); request.CreatedDate = DateTime.Now; status = await _categoryApiClient.Add(request); } else { var request = new CategoryUpdateRequest(); request.Id = categoryVm.Id; request.Name = categoryVm.Name; request.Description = categoryVm.Description; request.UserId = new Guid("69bd714f-9576-45ba-b5b7-f00649be00de"); request.CreatedDate = DateTime.Now; status = await _categoryApiClient.Update(request); } return(Json(new { status = status })); }
public async Task <ApiResult <string> > Update(CategoryUpdateRequest request, int categoryId) { var sections = _httpContextAccessor.HttpContext.Session.GetString("Token"); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sections); var json = JsonConvert.SerializeObject(request); MultipartFormDataContent form = new MultipartFormDataContent(); form.Add(new StringContent(request.LanguageId), "languageId"); form.Add(new StringContent(request.Name), "Name"); form.Add(new StringContent(request.IsShowOnHome.ToString()), "IsShowOnHome"); if (request.ThumbnailImage != null) { byte[] data; using (var br = new BinaryReader(request.ThumbnailImage.OpenReadStream())) data = br.ReadBytes((int)request.ThumbnailImage.OpenReadStream().Length); ByteArrayContent bytes = new ByteArrayContent(data); form.Add(bytes, "ThumbnailImage", request.ThumbnailImage.FileName); } var response = await _client.PatchAsync($"/api/categories/{categoryId}", form); if (response.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <ApiResultSuccess <string> >(await response.Content.ReadAsStringAsync())); } return(JsonConvert.DeserializeObject <ApiResultErrors <string> >(await response.Content.ReadAsStringAsync())); }
public async Task <ApiResult <bool> > Update(CategoryUpdateRequest request, int categoryId) { var category = await _context.Categories.FindAsync(categoryId); var categoryTranslation = await _context.CategoryTranslations.FirstOrDefaultAsync(x => x.CategoryId == categoryId && x.LanguageId == request.LanguageId); if (category == null || categoryTranslation == null) { return(new ApiResultErrors <bool>($"Cannot find a category with id: {categoryId}")); } categoryTranslation.Name = request.Name; categoryTranslation.CategoryUrl = GetUrlByName.Converts(request.Name); category.IsShowOnHome = request.IsShowOnHome; //Save Image if (request.ThumbnailImage != null) { var OldImagePath = category.ImagePath; category.ImagePath = await this.SaveFile(request.ThumbnailImage); if (OldImagePath != null) { await _storageService.DeleteFileAsync(OldImagePath); } } return(await SaveChangeService.SaveChangeAsyncNotImage(_context)); }
public override async Task <Empty> UpdateCategory(CategoryUpdateRequest request, ServerCallContext context) { var category = await _db.GetAsync <Category>(request.Id); if (category == null) { throw new Exception($"{request.Id} category not found"); } if (!string.IsNullOrEmpty(request.Name)) { category.Name = request.Name; } if (!string.IsNullOrEmpty(request.Color)) { category.Color = ColorTranslator.FromHtml(request.Color); } if (request.ParentId.HasValue()) { category.CategoryId = request.ParentId; } await _db.UpdateAsync(category); return(new Empty()); }
public BaseResponse <CategoryResponse> UpdateCategory([FromBody] CategoryUpdateRequest request, [FromHeader] Guid UserID) { return(BaseResponse <CategoryResponse> .ConstructResponse( HttpStatusCode.OK, HttpStatusCode.OK.ToString(), categoryService.UpdateCategory(request, UserID))); }
// ......................................................................................... public static bool UpdateCategory(CategoryUpdateRequest model) { bool isSuccess = false; try { DataProvider.ExecuteNonQuery(GetConnection, "dbo.Update_Category", inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@CategoryId", model.CategoryId); paramCollection.AddWithValue("@UserId", model.UserId); paramCollection.AddWithValue("@ForcastType", model.ForecastType); paramCollection.AddWithValue("@FixedPrediction", model.FixedPrediction); isSuccess = true; } ); } catch (Exception e) { throw e; } return(isSuccess); }
public async Task CategoriesController_Put_Success() { var createRequest = new CategoryCreateRequest { Name = "Test category5" }; var controller = new CategoriesController(_fixture.CategoryService); var createResult = await controller.Post(createRequest); var createResponse = GetResponse <CategoryCreateResponse>(createResult); Assert.Equal(createRequest.Name, createResponse.Name); var updateRequest = new CategoryUpdateRequest { Id = createResponse.Id, Name = "New Name" }; var updateResult = await controller.Put(updateRequest); var updateResponse = GetResponse <CategoryUpdateResponse>(updateResult); Assert.Equal(updateRequest.Id, updateResponse.Id); Assert.Equal(updateRequest.Name, updateResponse.Name); }
public CategoryUpdateResponse Update([FromBody] CategoryUpdateRequest request) { CategoryUpdateResponse response = new CategoryUpdateResponse(); if (request.Id == 0 || request.Id < 0) { response.Status = -1; return(response); } CategoryEntity entity = categoryRepository.GetById(request.Id); if (entity == null) { response.Status = 404; return(response); } categoryRepository.Update(categoryConvertor.toEntity(request, entity)); theCategoryMeta.Refresh(); response.Status = 1; return(response); }
public async Task <bool> UpdateCategory(CategoryUpdateRequest request) { var sessions = _httpContextAccessor .HttpContext .Session .GetString(SystemConstants.AppSettings.Token); var languageId = _httpContextAccessor.HttpContext.Session.GetString(SystemConstants.AppSettings.DefaultLanguageId); var client = _httpClientFactory.CreateClient(); client.BaseAddress = new Uri(_configuration[SystemConstants.AppSettings.BaseAddress]); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions); var requestContent = new MultipartFormDataContent(); //requestContent.Add(new StringContent(request.Id.ToString()), "id"); requestContent.Add(new StringContent(request.Name.ToString()), "name"); var response = await client.PutAsync($"/api/categories/" + request.Id, requestContent); return(response.IsSuccessStatusCode); }
public IActionResult Edit(CategoryUpdateRequest request) { HttpClient httpclient = new HttpClient(); var result = httpclient.PutAsJsonAsync(uri, request).Result; return(RedirectToAction("Edit", new { categoryId = request.Id })); }
public async Task <IActionResult> UpdateCategory([FromBody] CategoryUpdateRequest category, int categoryId) { _logger.LogDebug("START UpdateCategory"); if (categoryId != category.CategoryId) { return(BadRequest($"invalid categoryId")); } var categoryDto = _mapper.Map <CategoryDto>(category); categoryDto.CategoryId = categoryId; var productResult = await CommandAsync(new UpdateCategoryCommand { Category = categoryDto }); if (!productResult.HaveError) { return(NoContent()); } else { return(UnprocessableEntity(productResult.Errors)); } }
public async Task EditAsync(int id, CategoryUpdateRequest request) { await CategoryRepository.UpdateAsync(new Category() { Name = request.Name, CategoryId = id }); }
public async Task <StatusData <string> > UpdateCategory(CategoryUpdateRequest request, SystemSession session) { var userCategory = new UserCategory { UserId = session.UserId.ToString(), UserCategoryTypeId = request.CategoryId, Name = request.Name, Description = request.Description }; var result = (await Task.Factory.StartNew(() => Client.UserService.editCategoryMeta(userCategory, session.GetSession())).ConfigureAwait(false)).GetStatusData <string>(); return(result); }
public async Task Update(CategoryUpdateRequest dto) { var data = await this._categoryRepo.GetAsync(dto.Id); data.Name = dto.Name; data.Description = dto.Description; await this._categoryRepo.UpdateAsync(data); }
public ActionResult Update(CategoryUpdateRequest request) { //doldur CommonResponse updateResponse = WebApiOperation.SendPost <CategoryUpdateRequest, CommonResponse>(Constants.PRODUCT_API_BASE_URI, Constants.PRODUCT_API_UPDATE_CATEGORY, request); TempData["ResponseCode"] = updateResponse.Code; TempData["ResponseMessage"] = updateResponse.Message; return(RedirectToAction("Index", "Category")); }
public async Task <ActionResult <CategoryVm> > PutCategory(int id, CategoryUpdateRequest request) { var category = await _categoryService.PutCategory(id, request); if (category > 0) { return(Ok(request)); } return(NoContent()); }
public async Task <IActionResult> UpdateCategory([FromForm] CategoryUpdateRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _categoryService.Update(request); return(Ok()); }
public async Task <IActionResult> update(CategoryUpdateRequest request) { var result = await _manageCategoryService.Update(request); if (result > 0) { return(Ok(new { message = "Cập nhập danh mục thành công!" })); } return(BadRequest("Cập nhập danh mục thất bại!")); }
public CategoryEntity toEntity(CategoryUpdateRequest request, CategoryEntity oldEntity) { CategoryEntity entity = new CategoryEntity(); entity.Id = request.Id; entity.CategoryId = request.CategoryId != null ? request.CategoryId.Value : 0; entity.CategoryName = request.CategoryName; entity.Description = request.Description; return(entity); }
public async Task <CategoryUpdateResponse> UpdateAsync(CategoryUpdateRequest request) { var category = await _context.Categories.FindAsync(request.Id); category.Name = request.Name; _context.Categories.Update(category); await _context.SaveChangesAsync(); return(_mapper.Map <CategoryUpdateResponse>(category)); }
public async Task <int> Update(CategoryUpdateRequest updateCategory) { var category = await _context.Categories.FindAsync(updateCategory.Id); if (category == null) { return(-1); } category.Name = updateCategory.Name; return(await _context.SaveChangesAsync()); }
public async Task <int> PutCategory(int CategoryId, CategoryUpdateRequest request) { var category = await _context.Categories.FindAsync(CategoryId); if (category == null) { return(-1); } category.Name = request.Name; return(await _context.SaveChangesAsync()); }
public Task <CategoryResponse> UpdateAsync(CategoryUpdateRequest categoryUpdateRequest) { return(base.ExecuteWithExceptionHandledOperation(async() => { var category = Mapper.Map <Category>(categoryUpdateRequest); _categoryRepository.Update(category); await _categoryRepository.SaveChangeAsync(); return Mapper.Map <CategoryResponse>(category); })); }
public async Task <int> Update(CategoryUpdateRequest request) { var category = new Category() { id = request.id, name = request.name, generalityName = request.generalityName, status = request.status, }; _context.Entry(category).State = EntityState.Modified; return(await _context.SaveChangesAsync()); }
public async Task <IActionResult> Edit(int id) { var result = await _categoryApiClient.GetById(id); var Request = new CategoryUpdateRequest() { Id = id, Name = result.Name, SortOrder = result.SortOrder, ParentId = result.ParentId }; return(View(Request)); }
public async Task <IActionResult> Update(int id, [FromBody] CategoryUpdateRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var affected = await _categoryService.Update(id, request); if (!affected.IsSuccessed) { return(BadRequest()); } return(Ok(affected)); }
public async Task<StatusData<string>> UpdateCategory(CategoryUpdateRequest request, SystemSession session) { var userCategory = new UserCategory { UserId = session.UserId.ToString(), UserCategoryTypeId = request.CategoryId, Name = request.Name, Description = request.Description }; var result = (await Task.Factory.StartNew(() => Client.UserService.editCategoryMeta(userCategory, session.GetSession())).ConfigureAwait(false)).GetStatusData<string>(); return result; }
public Task<StatusData<string>> UpdateCategory(CategoryUpdateRequest request, SystemSession session) { return _jUnitOfWork.Category.UpdateCategory(request, session); }