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