public async Task <IActionResult> Edit(int id, BlockedUsers blockedUsers)
{
if (id != blockedUsers.BlockedUserId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(blockedUsers);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BlockedUsersExists(blockedUsers.BlockedUserId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PetAccountId"] = new SelectList(_context.PetAccounts, "PetAccountId", "PetAccountId", blockedUsers.BlockedUserId);
return(View(blockedUsers));
}
public void BlockUser(User logedUser, string blockedUser)
{
using (var Context = new BMSContext())
{
BlockedUsers bu = new BlockedUsers();
bu.BlockerUser = Context.Users.Where(u => u.Username == logedUser.Username).FirstOrDefault();
bu.BlockedUser = Context.Users.Where(u => u.Username == blockedUser).FirstOrDefault();
Context.BlockedUsers.Add(bu);
Context.SaveChanges();
}
}
private bool Filtered(ChatMessage message)
{
if (!SettingsHolder.ChatEnabled)
{
message.Dispose();
return(true);
}
if (BlockedUsers.Contains(message.Author) && !(message is LfgMessage))
{
message.Dispose();
return(true);
}
var pausedCount = _pauseQueue.Count;
for (var i = 0; i < SettingsHolder.SpamThreshold; i++)
{
if (i >= pausedCount + ChatMessages.Count)
{
continue;
}
if (Pass(message, i <= pausedCount - 1
? _pauseQueue.ElementAt(i)
: ChatMessages[i - pausedCount]))
{
continue;
}
message.Dispose();
return(true);
}
//if (ChatMessages.Count < SettingsHolder.SpamThreshold)
//{
// for (var i = 0; i < ChatMessages.Count - 1; i++)
// {
// var m = ChatMessages[i];
// if (Pass(message, m)) continue;
// message.Dispose();
// return false;
// }
//}
//else
//{
// for (var i = 0; i < SettingsHolder.SpamThreshold; i++)
// {
// if (i > ChatMessages.Count - 1) continue;
// var m = ChatMessages[i];
// if (Pass(message, m)) continue;
// message.Dispose();
// return false;
// }
//}
return(false);
}
public async Task <IActionResult> Create(BlockedUsers blockedUsers)
{
if (ModelState.IsValid)
{
_repo.BlockedUser.Create(blockedUsers);
_repo.Save();
return(View("Details"));
}
return(View("Details", blockedUsers));
}
public static void BlockUser(int id, DateTime date)
{
using (ForumDBEntities entities = new ForumDBEntities())
{
BlockedUsers user = new BlockedUsers()
{
UserId = id,
BlockTime = date
};
entities.BlockedUsers.Add(user);
entities.SaveChanges();
}
}
public bool IsUserInBlockList(string login)
{
if (!BlockedUsers.ContainsKey(login))
{
return(false);
}
DateTime expire = BlockedUsers[login];
if (expire >= DateTime.Now)
{
return(true);
}
BlockedUsers.Remove(login);
return(false);
}
public async Task BanUser(int ownerId, string userName)
{
var user = accountsRepository.GetAccountByUsername(userName);
if (user == null)
{
throw new Exception();
}
var blockedUser = new BlockedUsers()
{
AccountId = user.AccountId,
OwnerId = ownerId
};
await blockedUsersRepository.AddAsync(blockedUser);
}
// GET: BlockedUsers/Create
public IActionResult Create(int id)
{
BlockedUsers blockedUser = new BlockedUsers();
blockedUser.BlockedUserId = id;
var petAccountId = _repo.PetAccount.GetPetAccount(id);
blockedUser.Blockee = petAccountId.UserId;
blockedUser.BlockerId = _userManager.GetUserId(User);
_repo.BlockedUser.Create(blockedUser);
_repo.Save();
return(View("Details", blockedUser));
}
public void BlockUser_Should_Work_Correctly()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.SaveChanges();
//act
string currentUserName = user.UserName;
string toBeBlocked = userOne.UserName;
this.userService.BlockUser(currentUserName, toBeBlocked).GetAwaiter();
//assert
var blockedFromDb = new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne,
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
var blocked = this.Context.BlockedUsers.FirstOrDefault();
blocked.Should().NotBeNull()
.And.Subject.Should().BeEquivalentTo(blockedFromDb);
}
public void UnBlockUser_Should_Work_Correctly()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
var blocked = new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne,
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.BlockedUsers.Add(blocked);
this.Context.SaveChanges();
//act
string userId = user.Id;
string unblockId = userOne.Id;
this.userService.UnblockUser(userId, unblockId);
//assert
var blockedFromDb = this.Context.BlockedUsers;
blockedFromDb.Should().BeNullOrEmpty();
}
public async Task blockuser(string user)
{
if (!HasExecutePermission)
{
return;
}
if (Context.Message.MentionedUsers.Count == 0)
{
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = "who tf is that xD",
Description = "you didnt mention a valid user :/",
Color = Color.Red
}.Build());
return;
}
if (!BlockedUsers.Contains(Context.Message.MentionedUsers.First().Id))
{
BlockedUsers.Add(Context.Message.MentionedUsers.First().Id);
Global.SaveBlockedUsers();
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = $"Succes",
Description = $"{Context.Message.MentionedUsers.First()} cant make threads no more lmao <3",
Color = Color.Green
}.Build());
return;
}
else
{
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = "***wait'nt***",
Description = "looks like there blocked already :/",
Color = Color.Green
}.Build());
}
}
public void BlockUser_Should_Throw_Exception()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
var blocked = new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne,
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.BlockedUsers.Add(blocked);
this.Context.SaveChanges();
//act
string currentUserName = user.UserName;
string toBeBlocked = userOne.UserName;
Func <Task> act = async() => await this.userService.BlockUser(currentUserName, toBeBlocked);
//assert
act.Should().Throw <InvalidOperationException>()
.WithMessage(String.Format(GlobalConstants.AlreadyExistsInDb, typeof(BlockedUsers).Name));
}
public async Task unblock(string user)
{
if (!HasExecutePermission)
return;
if (Context.Message.MentionedUsers.Count == 0)
{
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = "who tf is that xD",
Description = "you didnt mention a valid user :/",
Color = Color.Red
}.Build());
return;
}
if (BlockedUsers.Contains(Context.Message.MentionedUsers.First().Id))
{
BlockedUsers.Remove(Context.Message.MentionedUsers.First().Id);
Global.SaveBlockedUsers();
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = $"Succes!",
Description = $"{Context.Message.MentionedUsers.First()} can make threads again",
Color = Color.Green
}.Build());
return;
}
else
{
await Context.Channel.SendMessageAsync("", false, new EmbedBuilder()
{
Title = "***wait'nt***",
Description = "looks like that user isnt blocked :/",
Color = Color.Green
}.Build());
}
}
public void CanSendMessage_Should_Return_False()
{
//arrange
var sender = new FanFictionUser
{
Id = "sender",
UserName = "******"
};
var receiver = new FanFictionUser
{
Id = "receiver",
UserName = "******"
};
var blocked = new BlockedUsers
{
BlockedUser = receiver,
BlockedUserId = receiver.Id,
FanFictionUser = sender,
FanfictionUserId = sender.Id
};
this.userManager.CreateAsync(receiver).GetAwaiter().GetResult();
this.userManager.CreateAsync(sender).GetAwaiter().GetResult();
this.Context.BlockedUsers.Add(blocked);
this.Context.SaveChanges();
//act
string sendername = sender.UserName;
string receivername = receiver.UserName;
var possible = this.messageService.CanSendMessage(sendername, receivername);
//assert
possible.Should().BeFalse();
}
public async Task BlockUser(string currentUser, string name)
{
var blockingUser = await this.UserManager.FindByNameAsync(currentUser);
var userTobeBlocked = await this.UserManager.FindByNameAsync(name);
var Blocked = new BlockedUsers
{
FanFictionUser = blockingUser,
BlockedUser = userTobeBlocked
};
bool alreadyBlocked = this.Context.BlockedUsers.Any(x =>
x.BlockedUser == userTobeBlocked && x.FanFictionUser == blockingUser);
if (alreadyBlocked)
{
throw new InvalidOperationException(string.Format(GlobalConstants.AlreadyExistsInDb,
typeof(BlockedUsers).Name));
}
this.Context.BlockedUsers.Add(Blocked);
this.Context.SaveChanges();
}
public Models.BlockedUser GetBlockedUser(string address, string blockedAddress)
{
return(BlockedUsers.FirstOrDefault(bu => bu.Address == address && bu.BlockedAddress == blockedAddress));
}
public ActionResult BlockedUsers()
{
if (_mu != null) _ua = new UserAccount(_mu.UserName);
if (_ua.UserAccountID == 0) return View();
_contacts = new UserAccounts();
var bus = new BlockedUsers();
if (_mu != null) bus.GetBlockedUsers(Convert.ToInt32(_mu.ProviderUserKey));
foreach (UserAccount ua1 in bus.Select(uc1 => new UserAccount(uc1.UserAccountIDBlocked)))
{
_contacts.Add(ua1);
}
ViewBag.BlockedUsers = _contacts.ToUnorderdList;
return View();
}
//public void NotifyOpacityChange()
//{
// ChatWindows.ToList().ForEach(x =>
// {
// //TODO: make this different per window
// x.VM.NotifyOpacityChange();
// });
//}
public void AddChatMessage(ChatMessage chatMessage)
{
//return;
if (!SettingsHolder.ChatEnabled)
{
chatMessage.Dispose();
return;
}
if (BlockedUsers.Contains(chatMessage.Author))
{
chatMessage.Dispose();
return;
}
if (ChatMessages.Count < SettingsHolder.SpamThreshold)
{
for (var i = 0; i < ChatMessages.Count - 1; i++)
{
var m = ChatMessages[i];
if (!Pass(chatMessage, m))
{
chatMessage.Dispose();
return;
}
}
}
else
{
for (var i = 0; i < SettingsHolder.SpamThreshold; i++)
{
if (i > ChatMessages.Count - 1)
{
continue;
}
var m = ChatMessages[i];
if (!Pass(chatMessage, m))
{
chatMessage.Dispose();
return;
}
}
}
chatMessage.SplitSimplePieces();
if (ChatWindows.All(x => !x.IsPaused))
{
ChatMessages.Insert(0, chatMessage);
//_cache.Add(chatMessage);
}
else
{
_queue.Enqueue(chatMessage);
}
NewMessage?.Invoke(chatMessage);
if (ChatMessages.Count > SettingsHolder.MaxMessages)
{
var toRemove = ChatMessages[ChatMessages.Count - 1];
toRemove.Dispose();
ChatMessages.RemoveAt(ChatMessages.Count - 1);
}
N(nameof(MessageCount));
}
public void GetUser_Should_Return_Correct_Model()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
var usertwo = new FanFictionUser
{
Nickname = "User",
UserName = "******"
};
var blockedOne = new BlockedUsers
{
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
var blockedTwo = new BlockedUsers
{
BlockedUserId = user.Id,
FanfictionUserId = usertwo.Id,
};
var storyType = new StoryType
{
Name = "fantasy"
};
var stories = new[]
{
new FanFictionStory
{
Id = 1,
CreatedOn = DateTime.Now.AddHours(2),
Type = storyType,
AuthorId = user.Id,
Summary = "someSummary1",
Title = "SomeTitle1"
},
new FanFictionStory
{
Id = 2,
CreatedOn = DateTime.Now,
Type = storyType,
AuthorId = user.Id,
Summary = null,
Title = "SomeTitle2"
},
new FanFictionStory
{
Id = 3,
CreatedOn = DateTime.Now.AddDays(-1),
Type = storyType,
AuthorId = userOne.Id,
Summary = "someSummary2",
Title = "SomeTitle3"
},
};
var comments = new[]
{
new Comment
{
CommentedOn = DateTime.Now,
FanFictionUser = user,
FanFictionStory = stories[0],
Id = 1,
Message = "some message"
},
new Comment
{
CommentedOn = DateTime.Now.AddHours(2),
FanFictionUser = user,
FanFictionStory = stories[1],
Id = 2,
Message = "some message2"
},
};
var followed = new[]
{
new UserStory
{
FanfictionUserId = user.Id,
FanFictionStoryId = stories[2].Id
},
new UserStory
{
FanfictionUserId = usertwo.Id,
FanFictionStoryId = stories[1].Id
},
};
var notice = new Notification
{
FanFictionUser = user,
Seen = false,
Message = "madmamda",
UpdatedStoryId = 3
};
var messages = new[]
{
new Message
{
SenderId = usertwo.Id,
IsReaden = true,
Text = "dadsdadsasa",
ReceiverId = user.Id,
Id = 1,
SendOn = DateTime.Now.AddHours(2)
},
new Message
{
SenderId = user.Id,
IsReaden = false,
Text = "dadsa",
ReceiverId = userOne.Id,
Id = 2,
SendOn = DateTime.Now
},
};
this.Context.Notifications.Add(notice);
this.Context.UsersStories.AddRange(followed);
this.Context.Messages.AddRange(messages);
this.Context.StoryTypes.Add(storyType);
this.Context.FictionStories.AddRange(stories);
this.Context.Comments.AddRange(comments);
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.userManager.CreateAsync(usertwo).GetAwaiter();
this.Context.BlockedUsers.AddRange(blockedOne);
this.Context.BlockedUsers.AddRange(blockedTwo);
this.Context.SaveChanges();
//act
string username = user.UserName;
var model = this.userService.GetUser(username);
var notifications = this.Context.Notifications
.Where(x => x.FanFictionUserId == user.Id)
.ProjectTo <NotificationOutputModel>().ToList();
var messagesUser = this.Context.Messages.Where(x => x.ReceiverId == user.Id || x.SenderId == user.Id)
.ProjectTo <MessageOutputModel>()
.ToList();
var followedStories = this.Context.UsersStories.Where(x => x.FanfictionUserId == user.Id)
.Select(x => x.FanFictionStory)
.ProjectTo <StoryOutputModel>().ToList();
var userStories = this.Context.FictionStories.Where(x => x.AuthorId == user.Id)
.ProjectTo <StoryOutputModel>().ToList();
var modelToCompare = new UserOutputViewModel
{
BlockedUsers = 1,
BlockedBy = 1,
Comments = 2,
Email = user.Email,
FollowedStories = followedStories,
Id = user.Id,
Username = user.UserName,
NickName = user.Nickname,
Messages = messagesUser,
MessagesCount = messagesUser.Count,
Notifications = notifications,
Role = GlobalConstants.DefaultRole,
UserStories = userStories,
Stories = userStories.Count,
};
model.Should().NotBeNull().And.Subject.Should().Equals(modelToCompare);
}
