public async Task <ServiceResponse <GetProductGroupDto> > DeleteProductGroup(int productGroupId)
{
try
{
var productGroups = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == productGroupId);
if (productGroups is null)
{
return(ResponseResult.Failure <GetProductGroupDto>($"ProductGroup Id ({productGroupId}) not found."));
}
productGroups.IsActive = false;
productGroups.UpdatedById = Guid.Parse(GetUserId());
productGroups.UpdatedDate = Now();
_dbContext.ProductGroups.Update(productGroups);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductGroupDto>(productGroups);
return(ResponseResult.Success(dto));
}
catch (Exception ex)
{
return(ResponseResult.Failure <GetProductGroupDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetProductDto> > GetProductById(int productId)
{
Product product;
try
{
//FirstOrDefaultAsync(x=> x.Id == productId) >>>> select with condition
product = await _dBContext.Products.Include(x => x.ProductGroup).FirstOrDefaultAsync(x => x.Id == productId);
}
catch (System.Exception ex)
{
//Write log
_log.LogError($"Get ProductById({productId}) is error detail: {ex.Message}");
//Return
return(ResponseResult.Failure <GetProductDto>($"{productId} is error to find"));
}
//Validate if null
if (product != null)
{
//mapping and return result
GetProductDto productDto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(productDto));
}
else
{
//return not found result
return(ResponseResult.Failure <GetProductDto>($"{productId} is not found"));
}
}
public async Task <ServiceResponse <GetCharacterDto> > RemoveWeapon(int characterId)
{
var character = await _dBContext.Characters
.Include(x => x.Weapon)
.Include(x => x.CharacterSkills).ThenInclude(x => x.Skill)
.FirstOrDefaultAsync(x => x.Id == characterId);
if (character is null)
{
return(ResponseResult.Failure <GetCharacterDto>("Character not found."));
}
var weapon = await _dBContext.Weapons.Where(x => x.CharacterId == characterId).FirstOrDefaultAsync();
if (weapon is null)
{
return(ResponseResult.Failure <GetCharacterDto>("Weapon not found."));
}
_dBContext.Weapons.Remove(weapon);
await _dBContext.SaveChangesAsync();
var dto = _mapper.Map <GetCharacterDto>(character);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <GetCharacterDto> > AddCharacter(AddCharacterDto newCharacter)
{
_log.LogInformation("Start Add Character process.");
var character = await _dBContext.Characters.FirstOrDefaultAsync(x => x.Name == newCharacter.Name.Trim());
if (!(character is null))
{
_log.LogError("Duplicated Character Name.");
return(ResponseResult.Failure <GetCharacterDto>("Duplicated Character Name."));
}
_log.LogInformation("Add New Character.");
var addCharacter = new Models.Character
{
Name = newCharacter.Name,
HitPoints = newCharacter.HitPoints,
Strength = newCharacter.Strength,
Defense = newCharacter.Defense,
Intelligence = newCharacter.Intelligence
};
_dBContext.Characters.Add(addCharacter);
await _dBContext.SaveChangesAsync();
_log.LogInformation("Success.");
var dto = _mapper.Map <GetCharacterDto>(addCharacter);
_log.LogInformation("End.");
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <ProductDTO> > Get(int productId)
{
// Id must be greater than 0
if (productId <= 0)
{
return(ResponseResult.Failure <ProductDTO>("Id must be greater than 0", ResponseType.BadRequest));
}
// Gettering data
var data = await _dbContext.Product
.Include(entity => entity.CreatedByUser.Products)
.Include(entity => entity.Group)
.Where(x => x.Id == productId)
.FirstOrDefaultAsync();
// If no data return error
if (data is null)
{
return(ResponseResult.Failure <ProductDTO>("Product is not Exist", ResponseType.NoContent));
}
var dto = _mapper.Map <ProductDTO>(data);
return(ResponseResult.Success <ProductDTO>(dto));
}
public async Task <ServiceResponse <GetProductAuditDto> > AddProductAudit(AddProductAuditDto newProductAudit)
{
var product = await _dbContext.Products.FirstOrDefaultAsync(x => x.Id == newProductAudit.ProductId);
if (product == null)
{
return(ResponseResult.Failure <GetProductAuditDto>("Product Not Found."));
}
var productAudit = new mProductAudit
{
Name = newProductAudit.Name,
StockCount = newProductAudit.StockCount,
AuditAmount = newProductAudit.AuditAmount,
AuditTotalAmount = newProductAudit.AuditTotalAmount,
Remark = newProductAudit.Remark,
CreateBy = GetUsername(),
CreateDate = Now(),
ProductGroupId = newProductAudit.ProductGroupId,
ProductId = newProductAudit.ProductId,
ProductAuditTypeId = newProductAudit.ProductAuditTypeId,
};
_dbContext.ProductAudits.Add(productAudit);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductAuditDto>(productAudit);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <List <ProductDto> > > DelectProduct(int Id)
{
ServiceResponse <List <ProductDto> > response = new ServiceResponse <List <ProductDto> >();
Product product = await _db.Products.FirstOrDefaultAsync(c => c.ProductId == Id);
if (product == null)
{
// response.IsSuccess = false;
// response.Message = "ProductId not found";
return(ResponseResult.Failure <List <ProductDto> >("ProductId not found"));
}
try
{
_db.Products.Remove(product);
await _db.SaveChangesAsync();
response.Data = (_db.Products.Select(c => _mapper.Map <ProductDto>(c))).ToList();
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <ServiceResponse <GetDepartmentDto> > EditDepartment(EditDepartmentDto editDepartment)
{
try
{
//check department
var department = await _dbContext.Departments.FirstOrDefaultAsync(x => x.Id == editDepartment.Id);
if (department is null)
{
return(ResponseResult.Failure <GetDepartmentDto>($"Position id {editDepartment.Id} not found"));
}
//assign value
department.Description = editDepartment.DepartmentDescription;
//update database
_dbContext.Departments.Update(department);
await _dbContext.SaveChangesAsync();
//mapper Dto and return
var dto = _mapper.Map <GetDepartmentDto>(department);
_log.LogInformation($"Edit position Success");
return(ResponseResult.Success(dto, "Success"));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetDepartmentDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetEmployeeDto> > GetEmployeeById(int EmployeeId)
{
try
{
var employee = await _dbContext.Employees
.Include(x => x.Department)
.Include(x => x.Position)
.FirstOrDefaultAsync(x => x.Id == EmployeeId);
//check employee
if (employee is null)
{
_log.LogError($"employee id {EmployeeId} not found");
return(ResponseResult.Failure <GetEmployeeDto>($"employee id {EmployeeId} not found"));
}
//mapper Dto and return
var dto = _mapper.Map <GetEmployeeDto>(employee);
_log.LogInformation("GetEmployeesById Success");
return(ResponseResult.Success(dto, "Success"));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetEmployeeDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetPositionDto> > AddPosition(AddPositionDto newPosition)
{
try
{
var position = await _dbContext.Positions.FirstOrDefaultAsync(x => x.Description == newPosition.PositionDescription);
//check Position duplicate
if (!(position is null))
{
return(ResponseResult.Failure <GetPositionDto>("Position duplicate."));
}
//assiign value
var position_new = new Position
{
Description = newPosition.PositionDescription
};
//insert database
_dbContext.Positions.Add(position_new);
await _dbContext.SaveChangesAsync();
var position_return = await _dbContext.Positions.FirstOrDefaultAsync(x => x.Description == newPosition.PositionDescription);
//mapper Dto and return
var dto = _mapper.Map <GetPositionDto>(position_return);
_log.LogInformation("Add Position Success.");
return(ResponseResult.Success(dto, "Success"));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetPositionDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetDepartmentDto> > AddDepartment(AddDepartmentDto newDepartment)
{
try
{
var department = await _dbContext.Departments.FirstOrDefaultAsync(x => x.Description == newDepartment.DepartmentDescription);
//check department duplicate
if (!(department is null))
{
return(ResponseResult.Failure <GetDepartmentDto>("Department duplicate."));
}
//asign value
var department_new = new Department
{
Description = newDepartment.DepartmentDescription
};
//insert database
_dbContext.Departments.Add(department_new);
await _dbContext.SaveChangesAsync();
var department_return = await _dbContext.Departments.FirstOrDefaultAsync(x => x.Description == newDepartment.DepartmentDescription);
//mapper Dto and return
var dto = _mapper.Map <GetDepartmentDto>(department_return);
_log.LogInformation("Add Department Success.");
return(ResponseResult.Success(dto, "Success"));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetDepartmentDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetEmployeeDto> > DeleteEmployee(int deleteEmployeeId)
{
try
{
var employee = await _dbContext.Employees
.Include(x => x.Position)
.Include(x => x.Department)
.FirstOrDefaultAsync(x => x.Id == deleteEmployeeId);
//check Employee
if (employee is null)
{
return(ResponseResult.Failure <GetEmployeeDto>($"employee id {deleteEmployeeId} not found"));
}
//mapper Dto and return
var employee_return = _mapper.Map <GetEmployeeDto>(employee);
//remove database
_dbContext.Employees.RemoveRange(employee);
await _dbContext.SaveChangesAsync();
_log.LogInformation("Delete Employee done.");
return(ResponseResult.Success(employee_return, "success"));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetEmployeeDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetProductGroupDto> > EditProductGroup(EditProductGroup productGroup)
{
try
{
//Find ProductGroup
var prodGrp = await _dBContext.ProductGroups.Include(x => x.Product).Include(x => x.CreateBy).FirstOrDefaultAsync(x => x.Id == productGroup.Id);
if (prodGrp == null)
{
return(ResponseResult.Failure <GetProductGroupDto>("ProductGroup Id not found"));
}
//Update data
prodGrp.Name = productGroup.Name;
prodGrp.IsActive = productGroup.IsActive;
_dBContext.Update(prodGrp);
await _dBContext.SaveChangesAsync();
//Mapping
GetProductGroupDto prodGrpDto = _mapper.Map <GetProductGroupDto>(prodGrp);
return(ResponseResult.Success(prodGrpDto));
}
catch (System.Exception ex)
{
//Write log
_log.LogError($"Update product is error detail: {ex.Message}");
//Return
return(ResponseResult.Failure <GetProductGroupDto>($"Update ProductGroup error detail: {ex.Message}"));
}
}
public async Task <ServiceResponse <GetProductGroupDto> > AddProductGroup(AddProductGroup newProductGroup)
{
try
{
//Validate duplicate
var prodGrpV = _dBContext.ProductGroups.FirstOrDefault(x => x.Name == newProductGroup.Name);
if (prodGrpV != null)
{
return(ResponseResult.Failure <GetProductGroupDto>($"ProductGroup name '{newProductGroup.Name}' is duplicate"));
}
ProductGroup prodGrp = new ProductGroup();
prodGrp.Name = newProductGroup.Name;
prodGrp.IsActive = newProductGroup.IsActive;
prodGrp.CreateById = Guid.Parse(GetUserId());
prodGrp.CreatedDate = Now();
//var prodGrpDB = _mapper.Map<ProductGroup>(newProductGroup);
_dBContext.ProductGroups.Add(prodGrp);
await _dBContext.SaveChangesAsync();
ProductGroup saveProdGrp = await _dBContext.ProductGroups.Include(x => x.Product).Include(x => x.CreateBy).FirstOrDefaultAsync(x => x.Name == newProductGroup.Name);
GetProductGroupDto prodGrpDto = _mapper.Map <GetProductGroupDto>(saveProdGrp);
return(ResponseResult.Success(prodGrpDto));
}
catch (System.Exception ex)
{
//Write log
_log.LogError($"AddProductGroup is error detail: {ex.Message}");
//Return
return(ResponseResult.Failure <GetProductGroupDto>($"AddProductGroup error detail: {ex.Message}"));
}
}
public async Task <ServiceResponse <BookDTO_ToReturn> > UpdateBook(BookDTO_ToUpdate UpdateBook, int id)
{
var oldBookData = _dbContext.Books.FirstOrDefault(x => x.Id == id);
var cateGoryBookCheck = _dbContext.CategoryBooks.FirstOrDefault(x => x.Id == UpdateBook.CategoryBookId);
if (cateGoryBookCheck == null)
{
return(ResponseResult.Failure <BookDTO_ToReturn>("CategoryBook id not found"));
}
else
{
if (oldBookData.Name != UpdateBook.Name ||
oldBookData.Writter != UpdateBook.Writter ||
oldBookData.BorrowDay != UpdateBook.BorrowDay ||
oldBookData.BorrowPrice != UpdateBook.BorrowPrice ||
oldBookData.LatePrice != UpdateBook.LatePrice ||
oldBookData.CategoryBookId != UpdateBook.CategoryBookId)
{
oldBookData.Name = UpdateBook.Name;
oldBookData.Writter = UpdateBook.Writter;
oldBookData.BorrowDay = UpdateBook.BorrowDay;
oldBookData.BorrowPrice = UpdateBook.BorrowPrice;
oldBookData.LatePrice = UpdateBook.LatePrice;
//check categoryBook
oldBookData.CategoryBookId = UpdateBook.CategoryBookId;
await _dbContext.SaveChangesAsync();
}
return(ResponseResult.Success(_mapper.Map <BookDTO_ToReturn>(oldBookData)));
}
}
public async Task <ServiceResponse <GetProductDto> > EditProductr(EditProductDto editProduct)
{
var productgroup = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == editProduct.ProductGroupId);
if (productgroup == null)
{
return(ResponseResult.Failure <GetProductDto>("productgroup not found."));
}
var product = await _dbContext.Products.FirstOrDefaultAsync(x => x.Id == editProduct.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (product == null)
{
return(ResponseResult.Failure <GetProductDto>("Product not found."));
}
product.Name = editProduct.Name;
product.Price = editProduct.Price;
product.Qty = editProduct.Qty;
product.IsActive = editProduct.IsActive;
product.UserId = Guid.Parse(GetUserId());
product.CreatedDate = Now();
product.ProductGroupId = editProduct.ProductGroupId;
_dbContext.Products.Update(product);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <GetProductDto> > AddProduct(AddProductDto newProduct)
{
var productGroup = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == newProduct.ProductGroupId);
if (productGroup == null)
{
return(ResponseResult.Failure <GetProductDto>("Product Group Not Found."));
}
var _product = new mProduct
{
Name = newProduct.Name,
Price = newProduct.Price,
StockCount = newProduct.StockCount,
CreateBy = GetUsername(),
CreateDate = Now(),
Status = true,
ProductGroupId = newProduct.ProductGroupId,
ProductGroup = productGroup
};
_dbContext.Products.Add(_product);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(_product);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <GetProductDto> > EditProductr(EditProductDto editProductr)
{
var product = await _dBContext.Product.FirstOrDefaultAsync(x => x.Id == editProductr.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (product == null)
{
return(ResponseResult.Failure <GetProductDto>("Product not found."));
}
var productgroup = await _dBContext.ProductGroup.Include(x => x.Product).FirstOrDefaultAsync(x => x.Id == editProductr.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (productgroup == null)
{
return(ResponseResult.Failure <GetProductDto>("ProductGroup not found."));
}
product.Name = editProductr.Name;
product.Price = editProductr.Price;
product.StockCount = editProductr.StockCount;
product.ProductGroupId = editProductr.ProductGroupId;
_dBContext.Product.Update(product);
await _dBContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <ProductDto> > UpdateProduct(UpdateProductDto updateProduct)
{
ServiceResponse <ProductDto> response = new ServiceResponse <ProductDto>();
Product product = await _db.Products
.Include(x => x.ProductGroup)
.Include(x => x.Promotions)
.FirstOrDefaultAsync(x => x.ProductId == updateProduct.ProductId);
if (product == null)
{
// response.IsSuccess = false;
// response.Message = "ProductId not Found";
return(ResponseResult.Failure <ProductDto>("ProductId not Found"));
}
try
{
product.ProductDetail = updateProduct.ProductDetail;
product.ProductGroupId = updateProduct.ProductGroupId;
product.PromotionId = updateProduct.PromotionId;
product.Stock = updateProduct.Stock;
product.Price = updateProduct.Price;
product.UpdateDate = DateTime.Now;
_db.Products.Update(product);
await _db.SaveChangesAsync();
response.Data = _mapper.Map <ProductDto>(product);
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <ServiceResponse <ProductGroupDTO_ToReturn> > AddProductGroup(ProductGroupDTO_ToAdd input)
{
try
{
var productGroupToAdd = new ProductGroup();
productGroupToAdd.Name = input.Name;
productGroupToAdd.IconName = input.IconName;
productGroupToAdd.CreatedBy = GetUsername();
productGroupToAdd.CreatedDate = Now();
productGroupToAdd.UpdatedBy = GetUsername();
productGroupToAdd.UpdatedDate = Now();
productGroupToAdd.IsActive = true;
await _context.ProductGroups.AddAsync(productGroupToAdd);
await _context.SaveChangesAsync();
var dto = _mapper.Map <ProductGroupDTO_ToReturn>(productGroupToAdd);
return(ResponseResult.Success <ProductGroupDTO_ToReturn>(dto));
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(ResponseResult.Failure <ProductGroupDTO_ToReturn>(ex.Message));
}
}
public async Task <ServiceResponse <GetOrderDto> > UpdateOrderStatusById(int OrderId, UpdateOrderStatusDto updateOrder)
{
var order = await _dbContext.Orders.FirstOrDefaultAsync(x => x.Id == OrderId);
if (order == null)
{
return(ResponseResult.Failure <GetOrderDto>("Order Not Found."));
}
else
{
order.Status = updateOrder.OrderStatus;
order.CreateBy = GetUsername();
order.CreateDate = Now();
await _dbContext.SaveChangesAsync();
// List<OrderList> orderlist = await _dbContext.OrderLists.Where(x => x.OrderId == OrderId).ToListAsync();
// foreach (var item in orderlist)
// {
// item.Status = updateOrder.OrderListStatus;
// }
// await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetOrderDto>(order);
return(ResponseResult.Success(dto));
}
}
public async Task <ServiceResponse <ProductGroupDTO_ToReturn> > DeleteProductGroup(int id)
{
try
{
var productGroupToDelete = await GetActiveProductGroupById(id);
if (productGroupToDelete is null)
{
var logMsg = $"ProductGroup id:{id} not found";
_logger.LogWarning(logMsg);
return(ResponseResult.Failure <ProductGroupDTO_ToReturn>(logMsg));
}
productGroupToDelete.IsActive = false;
productGroupToDelete.UpdatedDate = Now();
productGroupToDelete.UpdatedBy = GetUsername();
_context.Update(productGroupToDelete);
await _context.SaveChangesAsync();
var dtoToReturn = _mapper.Map <ProductGroupDTO_ToReturn>(productGroupToDelete);
return(ResponseResult.Success <ProductGroupDTO_ToReturn>(dtoToReturn));
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(ResponseResult.Failure <ProductGroupDTO_ToReturn>(ex.Message));
}
}
public async Task <ServiceResponse <GetCharacterDto> > AddSkill(AddSkillDto newSkill)
{
_log.LogInformation("Start Add Skill process.");
var skill = await _dBContext.Skills.FirstOrDefaultAsync(x => x.Name == newSkill.Name.Trim());
if (!(skill is null))
{
_log.LogError("Duplicated Skill Name.");
return(ResponseResult.Failure <GetCharacterDto>("Duplicated Skill Name."));
}
_log.LogInformation("Add New Skill.");
var addSkill = new Skill
{
Name = newSkill.Name,
Damage = newSkill.Damage,
};
_dBContext.Skills.Add(addSkill);
await _dBContext.SaveChangesAsync();
_log.LogInformation("Success.");
var dto = _mapper.Map <GetCharacterDto>(addSkill);
_log.LogInformation("End.");
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <ProductGroupDTO_ToReturn> > EditProductGroup(ProductGroupDTO_ToAdd input, int id)
{
var productGroup = await GetActiveProductGroupById(id);
try
{
if (productGroup is null)
{
var logMsg = $"ProductGroup id:{id} not found";
_logger.LogWarning(logMsg);
return(ResponseResult.Failure <ProductGroupDTO_ToReturn>(logMsg));
}
productGroup.Name = input.Name;
productGroup.IconName = input.IconName;
productGroup.UpdatedBy = GetUsername();
productGroup.UpdatedDate = Now();
_context.Update(productGroup);
await _context.SaveChangesAsync();
var dto = _mapper.Map <ProductGroupDTO_ToReturn>(productGroup);
return(ResponseResult.Success <ProductGroupDTO_ToReturn>(dto));
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(ResponseResult.Failure <ProductGroupDTO_ToReturn>(ex.Message));
}
}
public async Task <ServiceResponse <List <GetProductDto> > > DeleteProduct(int productId)
{
try
{
var product = await _dBContext.Products.FirstOrDefaultAsync(x => x.Id == productId);
if (product == null)
{
return(ResponseResult.Failure <List <GetProductDto> >($"Product Id {productId} is not found"));
}
_dBContext.Products.Remove(product);
await _dBContext.SaveChangesAsync();
var dto = _mapper.Map <List <GetProductDto> >(await _dBContext.Products.Include(x => x.ProductGroup).AsNoTracking().ToListAsync());
return(ResponseResult.Success(dto));
}
catch (System.Exception ex)
{
//Write log
_log.LogError($"Delete Product is error detail: {ex.Message}");
//Return
return(ResponseResult.Failure <List <GetProductDto> >($"Delete Product error detail: {ex.Message}"));
}
}
public async Task <ServiceResponse <GetProductStockLogDto> > UpdateStockLog(UpdateStockProduct updateStock)
{
ServiceResponse <GetProductStockLogDto> res = new ServiceResponse <GetProductStockLogDto>();
ProductStockLog stockLog = await _db.ProductStockLogs
.Include(x => x.Product)
.FirstOrDefaultAsync(c => c.StockLogId == updateStock.StockLogId);
if (stockLog == null)
{
return(ResponseResult.Failure <GetProductStockLogDto>("data not found"));
}
try
{
stockLog.NewEdit = updateStock.NewEdit;
stockLog.UpdatedDate = DateTime.Now;
stockLog.AmountAfter = updateStock.AmountAfter;
stockLog.AmountBefore = updateStock.AmountBefore;
stockLog.TextRemark = updateStock.TextRemark;
stockLog.IsActice = updateStock.IsActice;
_db.ProductStockLogs.Update(stockLog);
await _db.SaveChangesAsync();
res.Data = _mapper.Map <GetProductStockLogDto>(stockLog);
}
catch (Exception ex)
{
res.IsSuccess = false;
res.Message = ex.Message;
}
return(res);
}
public async Task <ServiceResponse <string> > Register(UserRegisterDto userRegisterDto)
{
if (await UserExists(userRegisterDto.Username))
{
return(ResponseResult.Failure <string>("User already exists"));
}
CreatePasswordHash(userRegisterDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
User user = new User
{
Id = Guid.NewGuid(),
Username = userRegisterDto.Username,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
_db.Users.Add(user);
await _db.SaveChangesAsync();
var token = CreateToken(user);
return(ResponseResult.Success(token));
}
public async Task <ServiceResponse <List <GetProductStockLogDto> > > DelectStockLog(int Id)
{
ServiceResponse <List <GetProductStockLogDto> > res = new ServiceResponse <List <GetProductStockLogDto> >();
ProductStockLog stockLog = await _db.ProductStockLogs
.Include(c => c.Product)
.FirstOrDefaultAsync(c => c.StockLogId == Id);
if (stockLog == null)
{
return(ResponseResult.Failure <List <GetProductStockLogDto> >("Data Not Found"));
}
try
{
_db.ProductStockLogs.Remove(stockLog);
await _db.SaveChangesAsync();
res.Data = (_db.ProductStockLogs.Select(c => _mapper.Map <GetProductStockLogDto>(c))).ToList();
}
catch (Exception ex)
{
res.IsSuccess = false;
res.Message = ex.Message;
}
return(res);
}
public async Task <ServiceResponse <GetCharacterDto> > AddCharacterSkill(AddCharacterSkillDto newSkill)
{
var character = await _dBContext.Characters.Include(x => x.Weapon).Include(x => x.CharacterSkills).ThenInclude(x => x.Skill).FirstOrDefaultAsync(x => x.Id == newSkill.CharacterId);
if (character == null)
{
return(ResponseResult.Failure <GetCharacterDto>("Character not found"));
}
var skill = await _dBContext.Skills.FirstOrDefaultAsync(x => x.Id == newSkill.SkillId);
if (skill == null)
{
return(ResponseResult.Failure <GetCharacterDto>("Skill not found"));
}
var c_Skill = new CharacterSkill();
c_Skill.CharacterId = newSkill.CharacterId;
c_Skill.SkillId = newSkill.SkillId;
_dBContext.CharacterSkills.Add(c_Skill);
await _dBContext.SaveChangesAsync();
var dto = _mapper.Map <GetCharacterDto>(character);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <GetProductGroupDto> > UpdateProductGroup(int productGroupId, AddProductGroupDto newProductGroup)
{
try
{
var productGroups = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == productGroupId);
if (productGroups is null)
{
return(ResponseResult.Failure <GetProductGroupDto>($"ProductGroup Id ({productGroupId}) not found."));
}
var duplicateName = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Name == newProductGroup.Name);
if (!(duplicateName is null))
{
return(ResponseResult.Failure <GetProductGroupDto>($"Product Name = {newProductGroup.Name} already exists."));
}
var http = _httpContext.HttpContext.User;
productGroups.Name = newProductGroup.Name;
productGroups.UpdatedById = Guid.Parse(GetUserId());
productGroups.UpdatedDate = Now();
_dbContext.ProductGroups.Update(productGroups);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductGroupDto>(productGroups);
return(ResponseResult.Success(dto));
}
catch (Exception ex)
{
return(ResponseResult.Failure <GetProductGroupDto>(ex.Message));
}
}
