public ActionResult RemoveFriendship(string senderUsername, string recieverUsername)
{
var friendRep = new FriendshipRepository(context);
friendRep.RemoveFriendship(senderUsername, recieverUsername);
return(RedirectToAction("Friendship", new { username = User.Identity.Name, category = "Show all friends" }));
}
public async Task Add_ShouldAddFriendship()
{
// Arrange
Friendship friendship = new Friendship
{
RequesterId = 1, AddresseeId = 1
};
Mock <DbSet <Friendship> > friendshipDbSetMock = Enumerable
.Empty <Friendship>()
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.Friendships)
.Returns(friendshipDbSetMock.Object);
IFriendshipRepository repository = new FriendshipRepository(contextMock.Object);
// Act
await repository.Add(friendship);
// Assert
contextMock.Verify(m => m.Friendships.AddAsync(friendship, It.IsAny <CancellationToken>()));
}
public ActionResult sendFriendRequest(string username_sender, string username_reciever)
{
var rep = new FriendshipRepository(context);
rep.SendFriendRequest(username_sender, username_reciever);
return(RedirectToAction("FriendRequest"));
}
public async Task CombinationExists_ShouldReturnFalse_WhenIdsInCombinationDontExist()
{
// Arrange
const int requesterId = 4351;
const int addresseeId = 12;
IEnumerable <Friendship> expectedFriendship = new[]
{
new Friendship {
FriendshipId = 1, RequesterId = 1, AddresseeId = 3
},
new Friendship {
FriendshipId = 2, RequesterId = 2, AddresseeId = 1
},
new Friendship {
FriendshipId = 3, RequesterId = 1, AddresseeId = 5
},
new Friendship {
FriendshipId = 4, RequesterId = 4, AddresseeId = 1
},
};
await _context.Friendships.AddRangeAsync(expectedFriendship);
await _context.SaveChangesAsync();
IFriendshipRepository repository = new FriendshipRepository(_context);
// Act
bool exists = await repository.CombinationExists(requesterId, addresseeId);
// Assert
Assert.False(exists);
}
public async Task GetById_ShouldReturnEmptyQueryable_WhenIdDoesNotExist()
{
// Arrange
const int friendshipId = 21231;
IEnumerable <Friendship> expectedFriendship = new[]
{
new Friendship {
FriendshipId = 1
}
};
Mock <DbSet <Friendship> > friendshipDbSetMock = expectedFriendship
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.Friendships)
.Returns(friendshipDbSetMock.Object);
IFriendshipRepository repository = new FriendshipRepository(contextMock.Object);
// Act
IEnumerable <Friendship> friendships = await repository
.GetById(friendshipId)
.ToListAsync();
// Assert
Assert.Empty(friendships);
}
public ActionResult SendFriendRequest(string senderUser, string recieverUser)
{
var rep = new FriendshipRepository(context);
rep.SendFriendRequest(senderUser, recieverUser);
return(RedirectToAction("Profile", "SignedIn", new { username = recieverUser }));
}
public IHttpActionResult GetUsers()
{
var allUsers = this.DbContext.Users.ToList().Where(x => x.Id != this.UserToken.UserId).Select(WarsimClientUser.Map).ToList();
foreach (var user in allUsers)
{
var warsimUser = this.GameManager.UserManager.GetUserById(user.Id);
if (warsimUser != null)
{
user.IsConnected = true;
user.GameId = warsimUser.ActiveGameId;
}
}
var friendIds = new FriendshipRepository(this.DbContext).GetFriends(this.UserToken.UserId).Select(x => x.Id).ToList();
var response = new UsersResponse
{
AllUsers = allUsers,
FriendIds = friendIds
};
return this.Ok(response);
}
public async Task Exists_ShouldReturnTrue_WhenFriendshipExists()
{
// Arrange
const int friendshipId = 1;
IEnumerable <Friendship> expectedFriendship = new[]
{
new Friendship {
FriendshipId = 1
}
};
Mock <DbSet <Friendship> > friendshipDbSetMock = expectedFriendship
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.Friendships)
.Returns(friendshipDbSetMock.Object);
IFriendshipRepository repository = new FriendshipRepository(contextMock.Object);
// Act
bool exists = await repository.Exists(friendshipId);
// Assert
Assert.True(exists);
}
/// <summary>
/// init <see cref="Wechaty"/> with <see cref="WechatyOptions"/>
/// </summary>
/// <param name="options"></param>
/// <param name="loggerFactory"></param>
public Wechaty(WechatyOptions options, ILoggerFactory loggerFactory)
{
_options = options;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <Wechaty>();
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("constructor() WechatyOptions.profile DEPRECATED. use WechatyOptions.name instead.");
}
if (string.IsNullOrWhiteSpace(options.Name) && !string.IsNullOrWhiteSpace(options.Profile))
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("constructor()");
}
}
_memory = _options.Memory;
Id = Guid.NewGuid().ToString();
State = new StateSwitch("Wechaty", loggerFactory.CreateLogger <StateSwitch>());
_readyState = new StateSwitch("WechatyReady", loggerFactory.CreateLogger <StateSwitch>());
Contact = new ContactRepository(loggerFactory.CreateLogger <Contact>(), this, loggerFactory.CreateLogger <ContactRepository>());
Tag = new TagRepository(loggerFactory.CreateLogger <Tag>(), this, loggerFactory.CreateLogger <TagRepository>());
ContactSelf = new ContactSelfRepository(loggerFactory.CreateLogger <ContactSelf>(), this, loggerFactory.CreateLogger <ContactSelfRepository>());
Friendship = new FriendshipRepository(loggerFactory.CreateLogger <Friendship>(), this, loggerFactory.CreateLogger <FriendshipRepository>());
Message = new MessageRepository(loggerFactory.CreateLogger <Message>(), this, loggerFactory.CreateLogger <MessageRepository>());
Image = new ImageRepository(loggerFactory.CreateLogger <Image>(), this, loggerFactory.CreateLogger <ImageRepository>());
RoomInvitation = new RoomInvitationRepository(loggerFactory.CreateLogger <RoomInvitation>(), this, loggerFactory.CreateLogger <RoomInvitationRepository>());
Room = new RoomRepository(loggerFactory.CreateLogger <Room>(), this, loggerFactory.CreateLogger <RoomRepository>());
UrlLink = new UrlLinkRepository(this, loggerFactory.CreateLogger <UrlLinkRepository>());
MiniProgram = new MiniProgramRepository();
InstallGlobalPlugin();
}
public ActionResult ChangeCategory(string category, string username, string categoryFilter)
{
var rep = new FriendshipRepository(context);
var friendship = rep.GetFriendship(username, User.Identity.Name);
rep.UpdateCategory(category, User.Identity.Name, friendship);
return(RedirectToAction("Friendship", new { username = User.Identity.Name, category = categoryFilter }));
}
public ActionResult AcceptFriendRequest(string senderUsername, string recieverUsername)
{
var rep = new UserRepository(context);
var friendRep = new FriendshipRepository(context);
friendRep.AcceptFriendRequest(senderUsername, recieverUsername);
return(RedirectToAction("Friendship", new { username = recieverUsername, category = "Show all friends" }));
}
public FriendshipService(FriendshipRepository friendshipRepository,
UsersRepository usersRepository,
ILoggerProvider LoggerProvider)
{
FrienshipRepository = friendshipRepository;
UsersRepository = usersRepository;
Logger = LoggerProvider.CreateLogger(nameof(FriendshipService));
}
public UnitOfWork(DateMateContext context)
{
// The same context will be used for all repositories.
_context = context;
Users = new UserRepository(_context);
Messages = new MessageRepository(_context);
Friendships = new FriendshipRepository(_context);
Pictures = new PictureRepository(_context);
_context.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
}
public virtual void SetUp()
{
DataSetRepository = new DataSetRepository();
FriendshipRepository = new FriendshipRepository();
FriendsRepository = new FriendsRepository();
RepositoryFactory = new RepositoryFactoryTestUtility()
{
DataSets = DataSetRepository, Friendships = FriendshipRepository, Friends = FriendsRepository
};
}
public void RequestFriendship_WhenException_ShouldRollback()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
var friendshipRepo = new FriendshipRepository();
var mock = new Mock <IUserRepository>();
mock.SetupGet(s => s.HasErrors).Throws(new Exception("For Rollback"));
var service = new FriendshipServices(mock.Object, friendshipRepo);
service.RequestFriendship(friendship, "aFriend");
Assert.IsNull(friendshipRepo.GetFriendship(friendship.UserId, friendship.FriendName));
}
public UnitOfWork()
{
Users = new UserRepository(DataContext);
YearStatistic = new YearStatisticRepository(DataContext);
Notification = new NotificationRepository(DataContext);
Friendships = new FriendshipRepository(DataContext);
WatchedMoviesStats = new WatchedMoviesStatsRepository(DataContext);
PopularMovies = new PopularMoviesRepository(DataContext);
SavedMovies = new SavedMovieRepository(DataContext);
MoviesDetails = new MovieDetailsJMDBApiRepository(DataContext);
MoviesJMDBApi = new MovieJMDBApiRepository(DataContext);
WatchedMovies = new WatchedMovieRepository(DataContext);
}
public void RequestFriendship_WhenErrorDuringSave_ShouldRollback()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
var friendshipRepo = new FriendshipRepository();
var mock = new Mock <IUserRepository>();
mock.SetupGet(s => s.HasErrors).Returns(true);
mock.Setup(s => s.GetUserInfo(It.IsAny <string>())).Returns(() => null);
var service = new FriendshipServices(mock.Object, friendshipRepo);
service.RequestFriendship(friendship, "aFriend");
Assert.IsNull(friendshipRepo.GetFriendship(friendship.UserId, friendship.FriendName));
}
public UnitOfWork(DatabaseContext context)
{
_context = context;
Users = new UserRepository(_context);
UsersInfo = new UserInfoRepository(_context);
Roles = new RoleRepository(_context);
UsersHasRoles = new UserHasRoleRepository(_context);
Messages = new MessageRepository(_context);
Friendships = new FriendshipRepository(_context);
Games = new GameRepository(_context);
UsersGames = new UserHasGameRepository(_context);
}
public TestDataSeeder(IServiceScope scope)
{
citizenUserRepository = scope.ServiceProvider.GetService <CitizenUserRepository>();
roleRepository = scope.ServiceProvider.GetService <RoleRepository>();
friendshipRepository = scope.ServiceProvider.GetService <FriendshipRepository>();
userTaskRepository = scope.ServiceProvider.GetService <UserTaskRepository>();
messageRepository = scope.ServiceProvider.GetService <MessageRepository>();
if (citizenUserRepository == null || roleRepository == null || friendshipRepository == null ||
userTaskRepository == null || messageRepository == null)
{
throw new Exception("Cannot get services from ServiceProvider.");
}
}
public ActionResult Friendship(string username, string category)
{
var rep = new FriendshipRepository(context);
var userRep = new UserRepository(context);
var user = userRep.GetUserByUsername(username);
var pending = rep.GetAllPendingRecievedRequests(user);
var accepted = rep.GetAllAcceptedFriendships(user);
var model = new FriendshipsModel()
{
Friendships = accepted, PendingRecieved = pending, selectedCategory = category
};
return(View(model));
}
// public ApplicationUserRepository ApplicationUserRepository;
//public ProductKeyRepository ProductKeyRepository;
public UnitOfWork(DbContext dataContext)
{
DbContext = dataContext;
TreeRepository = new TreeRepository(dataContext);
FriendshipRepository = new FriendshipRepository(dataContext);
GenDiseasesRepository = new GenDiseasesRepository(dataContext);
HaveDiseaseRepository = new HaveDiseaseRepository(dataContext);
MemberRepository = new MemberRepository(dataContext);
ParentsRepository = new ParentsRepository(dataContext);
ChildsRepository = new ChildsRepository(dataContext);
MarriageRepository = new MarriageRepository(dataContext);
// ApplicationUserRepository = new ApplicationUserRepository(dataContext);
//ProductKeyRepository = new ProductKeyRepository(dataContext);
}
public void Delete_WhenErrorDuringDelete_ShouldRollBack()
{
var userRepo = new UserRepository();
var friendshipRepo = new FriendshipRepository();
var tripRepo = new UserTripRepository();
var user = ModelTestHelper.CreateUser(1, "DeleteUser");
var pwd = user.Password;
userRepo.SaveUser(user);
Assert.IsFalse(userRepo.HasErrors);
var secondUser = ModelTestHelper.CreateUser(2, "AFriend", "AFriendMail");
userRepo.SaveUser(secondUser);
Assert.IsFalse(userRepo.HasErrors);
var friendship = ModelTestHelper.CreateFriendship(user.Id, secondUser.Pseudo);
var otherFriendship = ModelTestHelper.CreateFriendship(secondUser.Id, user.Pseudo);
friendshipRepo.SaveFriendship(friendship);
friendshipRepo.SaveFriendship(otherFriendship);
Assert.IsFalse(friendshipRepo.HasErrors);
user.AddFriend(friendship);
secondUser.AddFriend(otherFriendship);
var trip = ModelTestHelper.CreateUserTrip(user.Id, "ATrip");
tripRepo.SaveUserTrip(trip);
Assert.IsFalse(tripRepo.HasErrors);
user.AddTrip(trip);
var mock = new Mock <IUserTripRepository>();
mock.Setup(s => s.DeleteUserTrip(trip)).Callback(() => tripRepo.DeleteUserTrip(trip));
mock.SetupGet(s => s.HasErrors).Returns(true);
var service = new UserServices(new UserRepository(), mock.Object, new FriendshipRepository());
service.DeleteUser(user);
service = new UserServices();
var dbUser = service.LoginByPseudo(user.Pseudo, pwd);
Assert.IsNotNull(dbUser);
Assert.AreEqual(1, dbUser.Friends.Count());
Assert.AreEqual(1, dbUser.Trips.Count());
Assert.AreEqual(1, service.GetUserTrips(user.Id).Count());
Assert.AreEqual(1, service.GetUserFriendships(user.Id).Count());
Assert.AreEqual(1, service.GetUserFriendships(secondUser.Id).Count(f => f.FriendName == user.Pseudo));
}
public async Task Add_ShouldAddFriendship()
{
// Arrange
Friendship friendship = new() { RequesterId = 1, AddresseeId = 1 };
IFriendshipRepository repository = new FriendshipRepository(_context);
// Act
await repository.Add(friendship);
// Assert
Assert.NotEqual(0, friendship.FriendshipId);
Friendship addedFriendship = await _context.Friendships.FindAsync(friendship.FriendshipId);
Assert.NotNull(addedFriendship);
}
public UnitOfWork(PokebookContext _context, IMapper mapper)
{
context = _context;
Chats = new ChatRepository(context, mapper);
Messages = new MessageRepository(context, mapper);
UserChats = new UserChatRepository(context, mapper);
Users = new UserRepository(context, mapper);
Friendships = new FriendshipRepository(context, mapper);
Pokemons = new PokemonRepository(context, mapper);
PokemonCatches = new PokemonCatchRepository(context, mapper);
Types = new TypeRepository(context, mapper);
Moves = new MoveRepository(context, mapper);
PokemonUsers = new PokemonUserRepository(context, mapper);
PokemonTypes = new PokemonTypeRepository(context, mapper);
PokemonMoveCatches = new PokemonMoveCatchRepository(context, mapper);
PokemonMoves = new PokemonMoveRepository(context, mapper);
PokemonCatchDeleted = new PokemonCatchDeletedRepository(context, mapper);
}
public async Task GetByUser_ShouldGetFriendships()
{
// Arrange
const int userId = 1;
IEnumerable <Friendship> friendships = new[]
{
new Friendship {
FriendshipId = 1, RequesterId = 1, AddresseeId = 2
},
new Friendship {
FriendshipId = 2, RequesterId = 3, AddresseeId = 1
},
new Friendship {
FriendshipId = 3, RequesterId = 3, AddresseeId = 2
},
new Friendship {
FriendshipId = 4, RequesterId = 2, AddresseeId = 4
},
};
Mock <DbSet <Friendship> > friendshipsDbSetMock = friendships
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.Friendships)
.Returns(friendshipsDbSetMock.Object);
FriendshipRepository repository = new FriendshipRepository(contextMock.Object);
// Act
IEnumerable <Friendship> actualFriendships = await repository
.GetByUser(userId)
.ToListAsync();
// Assert
Assert.Equal(2, actualFriendships.Count());
Assert.All(actualFriendships,
friendship => Assert.True(friendship.RequesterId == userId || friendship.AddresseeId == userId)
);
}
public IHttpActionResult GetGamesWithFilters(bool isPrivate, bool hasFriends, GameMode gameMode)
{
var friendIds = new FriendshipRepository(this.DbContext).GetFriends(this.WarsimUser.UserId).Select(x => x.Id);
var games = this.GameManager.GameHosts.Values
.Where(x => x.Map.IsPrivate == isPrivate);
if (gameMode != GameMode.All)
{
games = games.Where(x => x.Mode == gameMode);
}
if (hasFriends)
{
games = games.Where(x => x.Players.Values.Any(y => friendIds.Contains(y.UserId)));
}
return(this.Ok(games.Select(WarsimClientGame.Map)));
}
public async Task GetById_ShouldReturnNull_WhenIdDoesNotExist()
{
// Arrange
const int friendshipId = 21231;
Friendship expectedFriendship = new() { FriendshipId = 1 };
await _context.Friendships.AddAsync(expectedFriendship);
await _context.SaveChangesAsync();
IFriendshipRepository repository = new FriendshipRepository(_context);
// Act
Friendship friendship = await repository.GetByIdAsync(friendshipId);
// Assert
Assert.Null(friendship);
}
public async Task Exists_ShouldReturnFalse_WhenFriendshipDoesNotExist()
{
// Arrange
const int friendshipId = 9881641;
Friendship expectedFriendship = new() { FriendshipId = 1 };
await _context.Friendships.AddAsync(expectedFriendship);
await _context.SaveChangesAsync();
IFriendshipRepository repository = new FriendshipRepository(_context);
// Act
bool exists = await repository.Exists(friendshipId);
// Assert
Assert.False(exists);
}
public async Task GetById_ShouldReturnFriendship_WhenIdMatches()
{
// Arrange
const int friendshipId = 1;
Friendship expectedFriendship = new() { FriendshipId = 1 };
await _context.Friendships.AddAsync(expectedFriendship);
await _context.SaveChangesAsync();
IFriendshipRepository repository = new FriendshipRepository(_context);
// Act
Friendship friendship = await repository.GetByIdAsync(friendshipId);
// Assert
Assert.NotNull(friendship);
Assert.Equal(friendshipId, friendship.FriendshipId);
}
public async Task CombinationExists_ShouldReturnFalse_WhenIdsInCombinationDontExist()
{
// Arrange
const int requesterId = 4351;
const int addresseeId = 12;
IEnumerable <Friendship> expectedFriendship = new[]
{
new Friendship {
FriendshipId = 1, RequesterId = 1, AddresseeId = 3
},
new Friendship {
FriendshipId = 2, RequesterId = 2, AddresseeId = 1
},
new Friendship {
FriendshipId = 3, RequesterId = 1, AddresseeId = 5
},
new Friendship {
FriendshipId = 3, RequesterId = 4, AddresseeId = 1
},
};
Mock <DbSet <Friendship> > friendshipDbSetMock = expectedFriendship
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.Friendships)
.Returns(friendshipDbSetMock.Object);
IFriendshipRepository repository = new FriendshipRepository(contextMock.Object);
// Act
bool exists = await repository.CombinationExists(requesterId, addresseeId);
// Assert
Assert.False(exists);
}
public FriendsController(CloudContext context, FriendshipRepository repository)
{
Repository = repository;
CloudContext = context;
}
