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