public async Task GivenValidationPipelineSetUp_WhenQueryWithoutValidatorWasSent_ThenQueryIsNotValidatedAndHandledByQueryHandler()
{
//Given
var services = new ServiceCollection();
services.AddDDD();
services.AddValidationPipeline();
services.AddSingleton(new DataContext {
Users = new List <string> {
"John Doe"
}
});
services.RegisterQueryHandler <GetAllUsers, IReadOnlyList <string>, UserQueryHandler>();
using (var sp = services.BuildServiceProvider())
{
var queryBus = sp.GetService <IQueryBus>();
var query = new GetAllUsers();
//When
var result = await queryBus.SendAsync <GetAllUsers, IReadOnlyList <string> >(query);
//Then
result.Should().HaveCount(1);
result[0].Should().Be("John Doe");
}
}
public void Invoke_ValidDataReturnsUserList()
{
// prepare
var userFromDb = new DataAccess.Models.User()
{
Id = 1
};
var userList = new List <DataAccess.Models.User> {
userFromDb
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetAll()).
Returns(userList.AsQueryable);
var action = new GetAllUsers(mockedUserRepository.Object);
// action
var list = action.Invoke();
// check
Assert.Equal(1, list.FirstOrDefault(x => x.Id == 1).Id);
Assert.Equal(1, list.Count);
}
public Task <IEnumerable <RequestedUser> > Handle(GetAllUsers query, CancellationToken cancellationToken)
{
var users = repo.GetAll();
var response = users.Select(u => mapper.Map <RequestedUser>(u));
return(Task.FromResult(response));
}
ICollection <GetAllUsers> GetAllUsers()
{
ICollection <GetAllUsers> model = new List <GetAllUsers>();
using (ApplicationDbContext db = new ApplicationDbContext())
{
var list = db.Users.Include("Ban").ToList();
foreach (var el in list)
{
GetAllUsers u = new GetAllUsers();
u.user = el;
if (el.Ban != null)
{
u.ban = el.Ban;
if (el.Ban.IsPermanent || el.Ban.ToDate > DateTime.Now || UserManager.IsInRole(el.Id, "Banned") == true)
{
u.isBanned = true;
}
}
model.Add(u);
}
return(model);
}
}
public void User_was_persisted()
{
var user = new GetAllUsers().Execute().Single();
Assert.AreEqual(_user.Email, user.Email);
Assert.AreEqual(_user.FirstName, user.FirstName);
Assert.AreEqual(_user.LastName, user.LastName);
}
public void GetAllUsers_Action_Fails()
{
// Arrange
GenericServiceResponse <IEnumerable <UserDto> > fakeResponse = null;
mockClientServicesProvider.Setup(x => x.Logger).Returns(mockLogger.Object).Verifiable();
mockClientServicesProvider.Setup(x => x.UserService.GetAllUsers()).Returns(fakeResponse).Verifiable();
var viewModel = new GenericListViewModel <UserDto>();
var action = new GetAllUsers <GenericListViewModel <UserDto> >(mockClientServicesProvider.Object)
{
OnComplete = model => viewModel = model
};
// Act
var result = action.Invoke();
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(GenericListViewModel <UserDto>));
Assert.IsNotNull(result.Notifications);
Assert.IsInstanceOfType(result.Notifications, typeof(NotificationCollection));
Assert.IsTrue(result.Notifications.Count() == 1);
Assert.IsTrue(result.HasErrors);
Assert.IsNotNull(result.Items);
Assert.IsTrue(result.Items.Count() == 0);
Assert.IsInstanceOfType(result.Items, typeof(IEnumerable <UserDto>));
Assert.IsTrue(result.Items.ToList().Count() == 0);
}
public void Should_Return_All_From_Table()
{
var db = new GetAllUsers();
var allUsers = db.Execute();
Assert.AreEqual(2, allUsers.Count<User>());
}
public async Task <IActionResult> GetUsers()
{
var getAllUsers = new GetAllUsers();
var result = await _queryProcessor.ExecuteQueryAsync <GetAllUsers, IEnumerable <UserDtoItem> >(getAllUsers);
return(Ok(result));
}
public object Any(GetAllUsers request)
{
var users = Db.Select <User>();
return(new GetAllUsersResponse {
Users = new ArrayOfUser(users)
});
}
public async Task <List <GetAllUsersResponse> > Handle(GetAllUsers request, CancellationToken cancellationToken)
{
var users = await _context.Users.Include(x => x.Badges).Include(x => x.MakerSpaces).AsNoTracking().ToListAsync();
var response = new List <GetAllUsersResponse>();
users.ForEach(x => response.Add(GetAllUsersResponse.CreateResponse(x)));
return(response);
}
public async Task <IEnumerable <UserDTO> > HandleAsync(GetAllUsers query)
{
var users = await _context.Users
.Skip(query.Page *query.PerPage)
.Take(query.PerPage)
.ToListAsync();
return(users
.Select(x => new UserDTO(x))
.AsEnumerable());
}
public async Task Returns_All_Users()
{
// Arrange
var expectedUsers = new List <User>
{
new User
{
UserId = 1,
FirstName = "John",
LastName = "Doe",
DateCreated = DateTime.UtcNow,
Accounts = new List <Account>
{
new Account
{
AccountId = 1,
UserId = 1,
DateCreated = DateTime.UtcNow
}
}
},
new User
{
UserId = 2,
FirstName = "Papa",
LastName = "John",
DateCreated = DateTime.UtcNow,
Accounts = new List <Account>
{
new Account
{
AccountId = 2,
UserId = 2,
DateCreated = DateTime.UtcNow
}
}
}
};
var mockService = new Mock <IUserService>();
mockService.Setup(service => service.GetAllAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedUsers);
var handler = new GetAllUsersHandler(mockService.Object);
//Act
var request = new GetAllUsers();
var result = await handler.HandleAsync(request);
//Assert
Assert.NotNull(result);
Assert.Equal(expectedUsers, result);
}
public async Task <IEnumerable <UsuarioDTO> > Handle(GetAllUsers request, CancellationToken cancellationToken)
{
return(_repository.List <Usuario>(t => t.Rol).Where(u => u.RolId == Constants.RolIdUsuario).Select(u => new UsuarioDTO
{
Id = u.Id,
Nombre = u.Nombre,
Apellido = u.Apellido,
Correo = u.Correo,
Rol = u.Rol?.Nombre,
Sexo = u.Sexo,
Fecha = u.Fecha,
Image_URL = u.Image_URL
}));
}
public static string UsersReport(GetAllUsers users, world world)
{
string result = string.Empty;
StringBuilder sb = new StringBuilder();
// Users is pretty boring unless we add some other information. Manager or agent would be good.
foreach (var user in users.Result.Data)
{
// user.Name
}
return(result);
}
// GET: api/Customer
public IEnumerable <string> Get()
{
var query = new GetAllUsers();
var queryResult = _queryExecutor.Execute(query);
if (queryResult == null)
{
//TODO: log error
return(Enumerable.Empty <string>());
}
var customers = ((GetAllUsersResult)queryResult).Customers;
return(customers);
}
public GetAllUsers FactoryUser(UserProfile user, User bufUser)
{
bool flag = CheckUser(user);
var userToAdmin = new GetAllUsers
{
Id = user.Id,
image = user.UrlPhoto,
isBlocked = bufUser.LockoutEnabled,
role = user.Role,
onCheck = flag,
scanImage = getScan(flag, user),
email = bufUser.Email,
userName = bufUser.UserName,
};
return(userToAdmin);
}
public void Invoke_EmptyDataReturnsEmptyList()
{
// prepare
var userList = new List <DataAccess.Models.User>();
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetAll()).
Returns(userList.AsQueryable);
var action = new GetAllUsers(mockedUserRepository.Object);
// action
var list = action.Invoke();
// check
Assert.Equal(0, list.Count);
}
public GetAllUsers GetAllUsersFromDataBase()
{
var models = _userRepository.GetAllUsers();
var returnModels = models.Select(model => new GetSingleUser
{
Id = model.Id,
Username = model.UserName,
Active = model.Active,
Role = model.Role
})
.ToList();
var returnModel = new GetAllUsers
{
AllUsers = returnModels
};
return(returnModel);
}
private async Task <ImmutableList <GetAllUsers.ResultUserModel> > GetAllUsersAsync()
{
var getter = new GetAllUsers(new Application.CallContext(memCheckDbContext, new MemCheckTelemetryClient(telemetryClient), new FakeStringLocalizer(), roleChecker));
var page = 1;
var result = new List <GetAllUsers.ResultUserModel>();
while (true)
{
var getterResult = await getter.RunAsync(new GetAllUsers.Request(runningUserId, 2, page, ""));
if (getterResult.Users.Any())
{
result.AddRange(getterResult.Users);
page++;
}
else
{
break;
}
}
return(result.ToImmutableList());
}
public object Any(GetAllUsers request)
{
var users = Db.Select<User>();
return new GetAllUsersResponse { Users = new ArrayOfUser(users) };
}
public Result <IEnumerable <UserDto> > Handle(GetAllUsers query)
{
return(Result.Success(_userRepository.GetUsers()
.Select(user => DomainToDtoConverters.ConvertToUserDto(user))));
}
public RequestAllUsers(GetAllUsers getAllUsers)
{
_getAllUsers = getAllUsers;
}
public ActionResult GetAllUsers(GetAllUsers command)
{
var response = mediator.Send(command);
return(Ok(response));
}
private IEnumerable <UserModel> ExecuteQuery(GetAllUsers query)
{
return(ReadModelStore.Query <UserModel>().ToList());
}
public async Task <IEnumerable <UserDto> > Handle(GetAllUsers request, CancellationToken cancellationToken)
{
var users = await _usersRepository.Find();
return(users.AsDto());
}
public object Get(GetAllUsers request)
{
return(WithDb(db => Logic.GetAll()));
}
#pragma warning disable CC0061 // Asynchronous method can be terminated with the 'Async' keyword.
public async Task <IEnumerable <User> > Handle(GetAllUsers message, CancellationToken cancellationToken = default)
#pragma warning restore CC0061 // Asynchronous method can be terminated with the 'Async' keyword.
{
return(await Model.GetEntriesAsync(cancellationToken).ConfigureAwait(false));
}
void Listen_server(object socket)
{
Socket connectionSocket = socket as Socket;
while (true)
{
try
{
object serverMessage;
{
byte[] serverData = new byte[10000];
if (connectionSocket.Receive(serverData) == 0)
{
Console.WriteLine("00000000");
return;
}
serverMessage = Functions.Deserialize(serverData);
Console.WriteLine("Получен ответ");
}
if (serverMessage is MessageFromServer)
{
MessageFromServer message = (serverMessage as MessageFromServer);
if (message.Message.IndexOf("Пользователь") != -1)
{
Dispatcher.Invoke(() =>
{
if (!OnlineAndAllCheckBox.IsChecked.Value)
{
_getUsersOnline.BeginInvoke(null, null);
}
});
}
else
{
MessageBox.Show(message.Message);
}
Console.WriteLine("Пришло простое сообщение от сервера");
}
if (serverMessage is GetUsersOnline)
{
GetUsersOnline usersInform = serverMessage as GetUsersOnline;
Console.WriteLine("Пришёл список пользователей");
Dispatcher.Invoke(() =>
{
if (OnlineAndAllCheckBox.IsChecked.Value)
{
return;
}
UsersListBox.Items.Clear();
foreach (AccountInformation t in usersInform.AccountsInformation)
{
UsersListBox.Items.Add(new Correspondence(t));
}
});
}
if (serverMessage is GetMessages)
{
Console.WriteLine("Пришла переписка с пользователем");
Dispatcher.Invoke(() =>
{
listMessagesStackPanel.Children.Clear();
foreach (Message message in (serverMessage as GetMessages).Messages)
{
DrawingMessage(message);
message.WhetherRead = true;
Functions.SerializeAndSend(message, _connectionSocket);
}
});
}
if (serverMessage is Message)
{
Message message = (serverMessage as Message);
Console.WriteLine("Сообщение: " + message.TextMessage);
Dispatcher.Invoke(() =>
{
Correspondence correspondence1 = UsersListBox.SelectedItem as Correspondence;
if (correspondence1 != null && correspondence1.Interlocutor.Id == message.SenderId)
{
DrawingMessage(message);
//прочитано сообщение
}
else
{
for (int index = 0; index < UsersListBox.Items.Count; index++)
{
Correspondence correspondence = (UsersListBox.Items[index] as Correspondence);
if (correspondence.Interlocutor.Id != message.SenderId)
{
continue;
}
correspondence.NumberOfUnreadMessages++;
//usersOnlineListBox.Items.Insert(index, correspondence);
}
UsersListBox.UpdateLayout();
}
});
}
if (serverMessage is GetAllUsers)
{
GetAllUsers usersInform = (serverMessage as GetAllUsers);
Console.WriteLine("Пришёл список пользователей");
Dispatcher.Invoke(() =>
{
UsersListBox.Items.Clear();
foreach (AccountInformation t in usersInform.AccountsInformation)
{
UsersListBox.Items.Add(new Correspondence(t));
}
});
}
if (serverMessage is UserDisconnect)
{
UserDisconnect ud = (serverMessage as UserDisconnect);
Dispatcher.Invoke(() =>
{
if (!OnlineAndAllCheckBox.IsChecked.Value)
{
for (int i = 0; i < UsersListBox.Items.Count; i++)
{
if ((UsersListBox.Items[i] as Correspondence).Interlocutor.Id ==
ud.ThisAccountInforamtion.Id)
{
UsersListBox.Items.RemoveAt(i);
}
}
}
});
}
}
catch (Exception ex)
{
//connectionSocket.Disconnect(false);
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
return;
}
}
}
public IActionResult All()
{
var result = new GetAllUsers(Repository).Execute();
return(Ok(result));
}
public Task <IReadOnlyList <string> > Handle(GetAllUsers query, CancellationToken cancellationToken)
{
return(Task.FromResult <IReadOnlyList <string> >(context.Users));
}
public async Task <IEnumerable <ChangeUserData> > HandleAsync(GetAllUsers message)
{
var users = await notificationUserRepository.GetAllUsers();
return(mapper.Map(users));
}
public async Task <IEnumerable <User> > Handle(GetAllUsers request, CancellationToken cancellationToken) => await repository.GetUsersAsync();
public async Task <IEnumerable <User> > HandleAsync(GetAllUsers request, CancellationToken ct = default)
{
return(await _userService.GetAllAsync(ct));
}
