public void BlockUser(BlockUser request)
{
var users = GetList <User>(x => request.userId.Contains(x.D_User_Id));
users.ForEach(x => x.PlatnostDo = request.date);
UpdateAllData(users);
}
public static BlockUserDocument AsDocument(this BlockUser entity)
=> new BlockUserDocument
{
Id = entity.Id,
BlockedUserId = entity.BlockedUserId,
UserId = entity.UserId,
CreatedAt = entity.CreatedAt
};
public async Task <IActionResult> Block(string username)
{
var command = new BlockUser
{
Username = username
};
var result = await _userService
.BlockUserAsync(command)
.OrFailAsync();
return(Ok(result));
}
public async Task HandleAsync(Block command)
{
var blockedUser = await _userRepository.GetByUserNameAsync(command.UserName);
if (blockedUser is null)
{
_logger.LogError($"User not found: {command.UserName}");
throw new UserNotFoundException(command.UserName);
}
var blockUser = new BlockUser(Guid.NewGuid(), blockedUser.Id, _userContext.Id, DateTime.Now);
await _repository.AddAsync(blockUser);
}
public async Task <IHttpActionResult> BlockUser([FromBody] BlockUserViewModel model)
{
var myUser = GetUserLogin();
var blockUser = context.BlockUsers.FirstOrDefault(t => t.UserID.Equals(myUser.Id) && t.UserBlockId.Equals(model.IdUser));
if (blockUser == null)
{
BlockUser block = new BlockUser()
{
UserID = myUser.Id,
UserBlockId = model.IdUser
};
context.BlockUsers.Add(block);
await context.SaveChangesAsync();
}
return(Ok());
}
public async Task <ActionResult> BlockUser(string username)
{
var sourceUserId = User.GetUserId();
var blockedUser = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
var sourceUser = await _unitOfWork.blockRepository.GetUserWithBlock(sourceUserId);
if (blockedUser == null)
{
return(NotFound());
}
if (sourceUser.UserName == username)
{
return(BadRequest("You cannot block yourself"));
}
var userBlock = await _unitOfWork.blockRepository.GetBlockedUser(sourceUserId, blockedUser.Id);
if (userBlock != null)
{
return(BadRequest("You already blocked this user "));
}
else
{
userBlock = new BlockUser
{
SourceUserId = sourceUserId,
BlockedUserId = blockedUser.Id
};
sourceUser.BlockedUsers.Add(userBlock);
if (await _unitOfWork.Complete())
{
return(Ok());
}
return(BadRequest("Failed to block user"));
}
}
public async Task BlockAsync(BlockUser command)
{
var loginHash = _hashManager.CalculateDataHash(command.Login);
var emailHash = _hashManager.CalculateDataHash(command.Email);
var user = await _context.Users.SingleOrDefaultAsync(x => x.Login == loginHash && x.UserEmail == emailHash);
if (user == null)
{
throw new CorruptedOperationException("Invalid data");
}
if (user.IsActive == false)
{
throw new CorruptedOperationException("Invalid operation.");
}
user.IsActive = false;
user.Update();
_context.Users.Update(user);
await _context.SaveChangesAsync();
}
public void BlockUser(BlockUserHelper blockUser)
{
var blockerUser = _offlineMessagingDbContext.CustomUsers.Where(x => x.UserName == blockUser.blockerUserName).FirstOrDefault();
var blockedUser = _offlineMessagingDbContext.CustomUsers.Where(x => x.UserName == blockUser.blockedUserName).FirstOrDefault();
if (blockerUser != null && blockedUser != null)
{
var dataExist = _offlineMessagingDbContext.BlockUser.Where(x => x.BlockerUser == blockerUser && x.BlockedUser == blockedUser).FirstOrDefault();
if (dataExist != null)
{
return;
}
BlockUser blockUserObj = new BlockUser();
blockUserObj.BlockerUser = blockerUser;
blockUserObj.BlockedUser = blockedUser;
blockUserObj.BlockedDate = DateTime.Now;
_offlineMessagingDbContext.BlockUser.Add(blockUserObj);
_offlineMessagingDbContext.SaveChanges();
}
}
public void Any(BlockUser request)
{
Repository.BlockUser(request);
}
public async Task <IActionResult> AddToBlackList(Guid userId)
{
if (!await _userApplication.IsExist(userId))
{
return(NotFound(new
{
Message = "Not found User"
}));
}
var userInfo = _sessionService.GetDataFromToken();
if (userId == userInfo.UserId)
{
return(BadRequest(new
{
Message = "Can not block yourself"
}));
}
var follow = await _context.Follows
.Where(x => (x.FromUserId == userId && x.ToUserId == userInfo.UserId) ||
(x.FromUserId == userInfo.UserId && x.ToUserId == userId))
.ToListAsync();
var block = await _context.BlockUsers
.Where(x => x.FromUserId == userInfo.UserId && x.ToUserId == userId)
.FirstOrDefaultAsync();
if (block == null)
{
block = new BlockUser()
{
FromUserId = userInfo.UserId,
ToUserId = userId,
IsLock = true
};
var user1 = await _userApplication.GetById(userInfo.UserId);
user1.UpdatedAt = DateTime.Now;
_context.Users.Update(user1);
_context.BlockUsers.Add(block);
await _context.SaveChangesAsync();
await _userApplication.UpdateSimilarityScores(userInfo.UserId);
return(Ok(new
{
Message = "Locked"
}));
}
var Message = "Unlocked";
if (!block.IsLock)
{
Message = "Locked";
}
block.IsLock = !block.IsLock;
var user = await _userApplication.GetById(userInfo.UserId);
user.UpdatedAt = DateTime.Now;
_context.Follows.RemoveRange(follow);
_context.Users.Update(user);
_context.BlockUsers.Update(block);
await _context.SaveChangesAsync();
await _userApplication.UpdateSimilarityScores(userInfo.UserId);
return(Ok(new
{
Message = Message
}));
}
public async Task <Response <UserDto> > BlockUserAsync(BlockUser command)
=> await PutAsync <UserDto>($"api/users/{command.Username}/block", command);
public void UnblockUser(BlockUser blockUser)
{
_context.Blocked.Remove(blockUser);
}
public Task AddAsync(BlockUser blockUser) => _repository.AddAsync(blockUser.AsDocument());
