public async Task<ServiceResult> SaveAsync(IFormFile file, string path) { Check.NotNull(file, nameof(file)); Check.NotNullOrEmpty(path, nameof(path)); if (file.Length <= 0) { return ServiceResultFactory.BadRequestResult(nameof(file), "File not found."); } var relativePath = Constants.GetRelativePathToImage(path); var fullPath = Path.Combine(_environment.WebRootPath, relativePath); if (File.Exists(fullPath)) { return ServiceResultFactory.BadRequestResult(nameof(path), "File already exist."); } var dirPath = Path.GetDirectoryName(fullPath); if (Directory.Exists(dirPath) == false) { Directory.CreateDirectory(dirPath); } using (var fileStream = new FileStream(fullPath, FileMode.Create)) { await file.CopyToAsync(fileStream); } return ServiceResultFactory.Success; }
public async Task <ServiceResult> Add([FromBody] InfoObjectAddModel apiEntity) { var type = Enum.Parse <InfoObjectType>(apiEntity.Type, ignoreCase: true); if (type == InfoObjectType.Image) { // validate file exist var fileExistValidationAttribute = new FileExistValidationAttribute(Constants.WEB_CONTENT_ROOT_PATH, Constants.DEFAULT_PATH_TO_IMAGE); var validationResult = fileExistValidationAttribute.IsValid(apiEntity.Content); if (validationResult != ValidationResult.Success) { return(ServiceResultFactory.BadRequestResult(nameof(apiEntity.Content), validationResult.ErrorMessage)); } } var entity = InfoObjectAddModel.Map(apiEntity); var result = await _infoObjectService.AddAsync(entity); if (result.TryCastModel(out InfoObject infoObject)) { result.ViewModel = InfoObjectViewModel.Map(infoObject); } return(result); }
public async Task <ServiceResult> UpdateRoleAsync(Guid id, string newRole) { Check.NotNullOrEmpty(newRole, nameof(newRole)); var user = await this.FindByAsync(x => x.Id == id); if (user == null) { return(ServiceResultFactory.NotFound); } newRole = Role.Normalize(newRole); if (string.IsNullOrEmpty(newRole)) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateRoleAsync), "Incorrect role name.")); } user.Role = newRole; user.LastModified = DateTime.UtcNow; _context.Users.Update(user); var result = await _context.SaveAsync(nameof(UpdateRoleAsync)); result.SetModelIfSuccess(user); return(result); }
public async Task <ServiceResult> UpdateAsync(Order model) { Check.NotNull(model, nameof(model)); var order = await _context.Orders.FirstOrDefaultAsync(x => x.Id == model.Id); if (order == null) { return(ServiceResultFactory.NotFound); } if (order.DateOfApproved.HasValue || order.DateOfRejected.HasValue || order.DateOfClosed.HasValue) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), $"Order is already proccessed.")); } var changed = false; // update name if (Utility.IsModified(order.Name, model.Name)) { order.Name = model.Name; changed = true; } // update mobile if (Utility.IsModified(order.Mobile, model.Mobile)) { order.Mobile = model.Mobile; changed = true; } // update address if (Utility.IsModified(order.Address, model.Address)) { order.Address = model.Address; changed = true; } // update comment if (Utility.IsModified(order.Comment, model.Comment)) { order.Comment = model.Comment; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.Orders.Update(order); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(order); return(result); }
public async Task <ServiceResult> UpdateAsync(MenuItem model) { Check.NotNull(model, nameof(model)); var menuItem = await _context.MenuItems.FirstOrDefaultAsync(x => x.Id == model.Id); if (menuItem == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update text if (Utility.IsModified(menuItem.Text, model.Text)) { // Doesn't supported StringComparison.OrdinalIgnoreCase by SQL var menuItemTextExist = await _context.MenuItems.AnyAsync(x => model.Text.ToLower() == x.Text.ToLower()); if (menuItemTextExist) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), $"MenuItem text is already exist.")); } menuItem.Text = model.Text; changed = true; } // update order if (Utility.IsModified(menuItem.Order, model.Order)) { menuItem.Order = model.Order; changed = true; } // update iconPath if (Utility.IsModified(menuItem.IconPath, model.IconPath)) { menuItem.IconPath = model.IconPath; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.MenuItems.Update(menuItem); _context.History.Add(ChangeHistory.Create(TableName.MenuItem, ActionType.Modify)); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(menuItem); return(result); }
public async Task <ServiceResult> UpdateAsync(ContentGroup model) { Check.NotNull(model, nameof(model)); var contentGroup = await _context.ContentGroups.FirstOrDefaultAsync(x => x.Id == model.Id); if (contentGroup == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update title if (Utility.IsModified(contentGroup.Title, model.Title)) { contentGroup.Title = model.Title; changed = true; } // update order if (Utility.IsModified(contentGroup.Order, model.Order)) { contentGroup.Order = model.Order; changed = true; } // update groupname if (model.GroupName != contentGroup.GroupName) { contentGroup.GroupName = model.GroupName; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.ContentGroups.Update(contentGroup); _context.History.Add(ChangeHistory.Create(model.GroupName, ActionType.Modify)); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(contentGroup); return(result); }
public ServiceResult Delete(string path) { Check.NotNullOrEmpty(path, nameof(path)); var relativePath = Constants.GetRelativePathToImage(path); var fullPath = Path.Combine(_environment.WebRootPath, relativePath); if (File.Exists(fullPath) == false) { return ServiceResultFactory.BadRequestResult(nameof(path), "File not found."); } File.Delete(fullPath); return ServiceResultFactory.Success; }
private ServiceResult AuthUser(AppUser user, string password) { if (user == null) { return(ServiceResultFactory.BadRequestResult(nameof(AuthenticateAsync), "Username was not found.")); } var success = _passwordManager.VerifyPassword(password, user.PasswordHash, user.PasswordSalt); if (success == false) { return(ServiceResultFactory.BadRequestResult(nameof(AuthenticateAsync), "Password is wrong.")); } return(ServiceResultFactory.SuccessResult(user)); }
public async Task UpdatePassword_Params_Valid_Result_BadRequest() { _context .Setup(x => x.SaveAsync(It.IsAny <string>())) .Returns(Task.FromResult(ServiceResultFactory.BadRequestResult(It.IsAny <string>(), It.IsAny <string>()))); // Arrange var userService = new UserService(_context.Object, _passwordManager.Object); // Act var result = await userService.UpdatePasswordAsync(_data.First().Id, Constants.PASSWORD); // Assert Assert.NotNull(result); Assert.Equal(ServiceResultKey.BadRequest, result.Key); Assert.NotEmpty(result.Errors); }
public async Task Delete_Id_Valid_Result_BadRequest() { _context .Setup(x => x.SaveAsync(It.IsAny <string>())) .Returns(Task.FromResult(ServiceResultFactory.BadRequestResult(It.IsAny <string>(), It.IsAny <string>()))); // Arrange var userService = new UserService(_context.Object, null); // Act var result = await userService.DeleteAsync(_data.First().Id); // Assert Assert.NotNull(result); Assert.Equal(ServiceResultKey.BadRequest, result.Key); Assert.NotEmpty(result.Errors); }
private async Task <ServiceResult> CloseAsync(Order order, Guid userId) { if (order.DateOfClosed.HasValue) { return(ServiceResultFactory.Success); } if (order.DateOfApproved.HasValue == false && order.DateOfRejected.HasValue == false) { return(ServiceResultFactory.BadRequestResult(nameof(CloseAsync), "Order should be approved or rejected.")); } order.DateOfClosed = DateTime.UtcNow; order.CloseUserId = userId; _context.Orders.Update(order); return(await _context.SaveAsync(nameof(CloseAsync))); }
public async Task <ServiceResult> AddAsync(ShopItemDetail model) { Check.NotNull(model, nameof(model)); var shopItemExist = await _context.ShopItems.AnyAsync(x => x.Id == model.ShopItemId); if (shopItemExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), $"ShopItem not found with id: '{model.ShopItemId}'.")); } _context.ShopItemDetails.Add(model); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task <ServiceResult> AddAsync(Order model) { Check.NotNull(model, nameof(model)); var cartExist = await _context.Carts.AnyAsync(x => x.Id == model.CartId); if (cartExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), $"Cart not found with id: '{model.CartId}'.")); } _context.Orders.Add(model); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task <ServiceResult> ProccessOrderAsync(ProcessOrderType processOrder, Guid id, Guid userId) { var userExist = await _context.Users.AnyAsync(x => x.Id == userId); if (userExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(ProccessOrderAsync), "User not found.")); } var order = await this.FindByAsync(x => x.Id == id); if (order == null) { return(ServiceResultFactory.NotFound); } ServiceResult result; switch (processOrder) { case ProcessOrderType.Approve: result = await this.ApproveAsync(order, userId); break; case ProcessOrderType.Reject: result = await this.RejectAsync(order, userId); break; case ProcessOrderType.Close: result = await this.CloseAsync(order, userId); break; default: throw new NotImplementedException(nameof(ProcessOrderType)); } result.SetModelIfSuccess(order); return(result); }
public async Task <ServiceResult> AddAsync(InfoObject model) { Check.NotNull(model, nameof(model)); var contentGroupExist = await _context.ContentGroups.AnyAsync(x => x.Id == model.ContentGroupId); if (contentGroupExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(model.ContentGroupId), $"ContentGroup not found with id: '{model.ContentGroupId}'.")); } _context.InfoObjects.Add(model); _context.History.Add(ChangeHistory.Create(TableName.InfoObject, ActionType.Add)); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task <ServiceResult> SaveAsync(string code) { try { await this.SaveChangesAsync(); return(ServiceResultFactory.Success); } catch (DbUpdateConcurrencyException ex) { return(ServiceResultFactory.BadRequestResult(code, ex.InnerException.Message)); } catch (DbUpdateException ex) { return(ServiceResultFactory.BadRequestResult(code, ex.InnerException.Message)); } catch (Exception ex) { return(ServiceResultFactory.InternalServerErrorResult(ex.InnerException.Message)); } }
public async Task <ServiceResult> AddAsync(AppUser model, string password) { Check.NotNull(model, nameof(model)); Check.NotNullOrEmpty(model.Username, nameof(model.Username)); Check.NotNullOrEmpty(model.Email, nameof(model.Email)); Check.NotNullOrEmpty(password, nameof(password)); // Doesn't supported StringComparison.OrdinalIgnoreCase by SQL var usernameExist = await this.ExistAsync(x => model.Username.ToLower() == x.Username.ToLower()); if (usernameExist) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), "Username is already taken.")); } var emailExist = await this.ExistAsync(x => model.Email.ToLower() == x.Email.ToLower()); if (emailExist) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), "Email is already taken.")); } model.Role = Role.Normalize(model.Role); if (string.IsNullOrEmpty(model.Role)) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), "Incorrect role name.")); } var(passwordHash, passwordSalt) = _passwordManager.CreatePasswordHash(password); model.PasswordHash = passwordHash; model.PasswordSalt = passwordSalt; _context.Users.Add(model); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task <ServiceResult> AddAsync(MenuItem model) { Check.NotNull(model, nameof(model)); Check.NotNullOrEmpty(model.Text, nameof(model.Text)); // Doesn't supported StringComparison.OrdinalIgnoreCase by SQL var menuItemExist = await this.ExistAsync(x => model.Text.ToLower() == x.Text.ToLower()); if (menuItemExist) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), $"MenuItem text already exist.")); } _context.MenuItems.Add(model); _context.History.Add(ChangeHistory.Create(TableName.MenuItem, ActionType.Add)); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task Add_Model_Valid_Result_BadRequest() { _context .Setup(x => x.SaveAsync(It.IsAny <string>())) .Returns(Task.FromResult(ServiceResultFactory.BadRequestResult(It.IsAny <string>(), It.IsAny <string>()))); // Arrange var userService = new UserService(_context.Object, _passwordManager.Object); var user = new AppUser { Username = "******", Email = "*****@*****.**", Role = Role.Admin }; // Act var result = await userService.AddAsync(user, Constants.PASSWORD); // Assert Assert.NotNull(result); Assert.Equal(ServiceResultKey.BadRequest, result.Key); Assert.NotEmpty(result.Errors); }
public async Task <ServiceResult> Edit(Guid id, [FromBody] InfoObjectEditModel apiEntity) { if (string.Equals(apiEntity.Type, InfoObjectType.Image.ToString(), StringComparison.OrdinalIgnoreCase)) { // validate file exist var fileExistValidationAttribute = new FileExistValidationAttribute(Constants.WEB_CONTENT_ROOT_PATH, Constants.DEFAULT_PATH_TO_IMAGE); var validationResult = fileExistValidationAttribute.IsValid(apiEntity.Content); if (validationResult != ValidationResult.Success) { return(ServiceResultFactory.BadRequestResult(nameof(apiEntity.Content), validationResult.ErrorMessage)); } } var entity = InfoObjectEditModel.Map(apiEntity, id); var result = await _infoObjectService.UpdateAsync(entity); if (result.TryCastModel(out InfoObject infoObject)) { result.ViewModel = InfoObjectViewModel.Map(infoObject); } return(result); }
private async Task <ServiceResult> RejectAsync(Order order, Guid userId) { if (order.DateOfRejected.HasValue) { return(ServiceResultFactory.Success); } if (order.DateOfApproved.HasValue) { return(ServiceResultFactory.BadRequestResult(nameof(RejectAsync), "Order is already approved.")); } if (order.DateOfClosed.HasValue) { return(ServiceResultFactory.BadRequestResult(nameof(RejectAsync), "Order is already closed.")); } order.DateOfRejected = DateTime.UtcNow; order.RejectUserId = userId; _context.Orders.Update(order); return(await _context.SaveAsync(nameof(RejectAsync))); }
public async Task <ServiceResult> UpdateAsync(AppUser model) { Check.NotNull(model, nameof(model)); var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == model.Id); if (user == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update username if (Utility.IsModified(user.Username, model.Username)) { var usernameExist = await this.ExistAsync(x => x.Username == model.Username); if (usernameExist) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Username is already taken.")); } user.Username = model.Username; changed = true; } // update email if (Utility.IsModified(user.Email, model.Email)) { var emailExist = await this.ExistAsync(x => x.Email == model.Email); if (emailExist) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Email is already taken.")); } user.Email = model.Email; user.EmailConfirmed = false; changed = true; } // update firstname if (Utility.IsModified(user.FirstName, model.FirstName)) { user.FirstName = model.FirstName; changed = true; } // update lastname if (Utility.IsModified(user.LastName, model.LastName)) { user.LastName = model.LastName; changed = true; } // update phonenumber if (Utility.IsModified(user.PhoneNumber, model.PhoneNumber)) { user.PhoneNumber = model.PhoneNumber; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } user.LastModified = DateTime.UtcNow; _context.Users.Update(user); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(user); return(result); }
public async Task <ServiceResult> UpdateAsync(InfoObject model) { Check.NotNull(model, nameof(model)); var infoObject = await _context.InfoObjects.FirstOrDefaultAsync(x => x.Id == model.Id); if (infoObject == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update contentGroup if (Utility.IsModified(infoObject.ContentGroupId, model.ContentGroupId)) { var contentGroupExist = await _context.ContentGroups.AnyAsync(x => x.Id == model.ContentGroupId); if (contentGroupExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(model.ContentGroupId), $"ContentGroup not found with id: '{model.ContentGroupId}'.")); } infoObject.ContentGroupId = model.ContentGroupId; changed = true; } // update content if (Utility.IsModified(infoObject.Content, model.Content)) { infoObject.Content = model.Content; changed = true; } // update type if (model.Type != infoObject.Type) { infoObject.Type = model.Type; changed = true; } // update subOrder if (Utility.IsModified(infoObject.SubOrder, model.SubOrder)) { infoObject.SubOrder = model.SubOrder; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.InfoObjects.Update(infoObject); _context.History.Add(ChangeHistory.Create(TableName.InfoObject, ActionType.Modify)); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(infoObject); return(result); }
public async Task <ServiceResult> UpdateAsync(ShopItemDetail model) { Check.NotNull(model, nameof(model)); var shopItemDetail = await _context.ShopItemDetails.FirstOrDefaultAsync(x => x.Id == model.Id); if (shopItemDetail == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update shopItem if (Utility.IsModified(shopItemDetail.ShopItemId, model.ShopItemId)) { var shopItemExist = await _context.ShopItems.AnyAsync(x => x.Id == model.ShopItemId); if (shopItemExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), $"ShopItem not found with id: '{model.ShopItemId}'.")); } shopItemDetail.ShopItemId = model.ShopItemId; changed = true; } // update suborder if (Utility.IsModified(shopItemDetail.SubOrder, model.SubOrder)) { shopItemDetail.SubOrder = model.SubOrder; changed = true; } // update price if (Utility.IsModified(shopItemDetail.Price, model.Price)) { shopItemDetail.Price = model.Price; changed = true; } // update kind if (Utility.IsModified(shopItemDetail.Kind, model.Kind)) { shopItemDetail.Kind = model.Kind; changed = true; } // update quantity if (Utility.IsModified(shopItemDetail.Quantity, model.Quantity)) { shopItemDetail.Quantity = model.Quantity; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.ShopItemDetails.Update(shopItemDetail); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(shopItemDetail); return(result); }
public async Task <ServiceResult> UpdateAsync(ShopItem model) { Check.NotNull(model, nameof(model)); var shopItem = await _context.ShopItems.FirstOrDefaultAsync(x => x.Id == model.Id); if (shopItem == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update menuItem if (Utility.IsModified(shopItem.MenuItemId, model.MenuItemId)) { var menuItemExist = await _context.MenuItems.AnyAsync(x => x.Id == model.MenuItemId); if (menuItemExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), $"MenuItem not found with id: '{model.MenuItemId}'.")); } shopItem.MenuItemId = model.MenuItemId; changed = true; } // update title if (Utility.IsModified(shopItem.Title, model.Title)) { shopItem.Title = model.Title; changed = true; } // update description if (Utility.IsModified(shopItem.Description, model.Description)) { shopItem.Description = model.Description; changed = true; } // update imagepath if (Utility.IsModified(shopItem.ImagePath, model.ImagePath)) { shopItem.ImagePath = model.ImagePath; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.ShopItems.Update(shopItem); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(shopItem); return(result); }