public Task <List <UserViewModel> > Handle(GetAllUsersRequest request, CancellationToken cancellationToken)
{
var users = GetAllEntitiesQuery.Execute <User>();
var userViewModels = Mapper.Map <List <UserViewModel> >(users);
return(Task.FromResult(userViewModels));
}
public virtual GetAllUsersResponse GetAllUsers(GetAllUsersRequest request)
{
var response = new GetAllUsersResponse();
try {
// Raise Initialization Event
var initialization = GetAllUsersInitialization;
if (initialization != null)
{
initialization(request, response);
}
// Raise Execute Event
var execute = GetAllUsersExecute;
if (execute != null)
{
response = execute(request);
}
// Raise Complete Event
var complete = GetAllUsersComplete;
if (complete != null)
{
complete(request, response);
}
}
catch (Exception exception) {
// Raise Error Event
var error = GetAllUsersError;
if (error != null)
{
error(request, response, exception);
}
}
return(response);
}
public string[] GetAllUsers()
{
GetAllUsersRequest inValue = new GetAllUsersRequest();
GetAllUsersResponse retVal = ((IPDAOrder)(this)).GetAllUsers(inValue);
return(retVal.GetAllUsersResult);
}
public async Task <IActionResult> GetAll()
{
var request = new GetAllUsersRequest();
var result = await _mediatorService.Send(request);
return(Ok(result));
}
public async Task <List <GetUserDto> > Handle(GetAllUsersRequest request, CancellationToken cancellationToken)
{
return(await _context
.Set <User>()
.ProjectTo <GetUserDto>(_mapper.ConfigurationProvider)
.ToListAsync());
}
public GetAllUsersResponse Process(GetAllUsersRequest request)
{
try
{
var users = new List <UserInfo>();
var userData = new UserInfoDao().GetAllUsers(true);
if (userData != null)
{
userData.ForEach(x => users.Add(UserInfoMapper.ToUserSummaryDto(x)));
}
return(new GetAllUsersResponse()
{
Token = request.Token, ResultType = ResultType.OK, Users = users
});
}
catch (Exception ex)
{
Log.Error(ex);
return(new GetAllUsersResponse()
{
Token = request.Token, ResultType = ResultType.Error
});
}
}
public List <UserInfo> QueryUsersByDevice(DeviceController device)
{
if (device == null)
{
return(null);
}
var deviceID = device.Code.ToInt32();
var deviceCode = device.Code.ToInt32();
var operation = new WebSocketOperation(deviceCode);
var getAllUsersRequest = new GetAllUsersRequest()
{
Token = operation.Token
};
string rawRequest = DataContractSerializationHelper.Serialize(getAllUsersRequest);
var rawResponse = operation.Execute(rawRequest);
if (string.IsNullOrWhiteSpace(rawResponse))
{
throw new Exception(string.Format("Query users from device id:[{0}]. Response is empty, maybe the device is not register to device system.", deviceID));
}
var response = DataContractSerializationHelper.Deserialize <GetAllUsersResponse>(rawResponse);
Log.InfoFormat("Query users from device id:[{0}], result:[{1}]", deviceID, response.ResultType);
return(response.ResultType == ResultType.OK ? response.Users.ToList() : null);
}
public List <DbUser> GetAllUsersController(
[FromServices] IRequestClient <GetAllUsersRequest> requestClient)
{
GetAllUsersRequest request = new GetAllUsersRequest();
var response = requestClient.GetResponse <GetAllUsersResponse>(request);
return(response.Result.Message.Users);
}
public async Task <IActionResult> GetUsers()
{
var request = new GetAllUsersRequest();
var result = await _mediator.Send(request);
return(StatusCodeResult(result));
}
public async Task<IEnumerable<User>> Get([FromUri] GetAllUsersRequest request)
{
// TODO: Investigate why doesn't it get initialized...
if (request == null)
{
request = new GetAllUsersRequest();
}
return await getAllHandler.HandleAsync(request);
}
public async Task<IEnumerable<UserPreviewDto>> Get([FromUri]RequestParamsDto reqParams)
{
var request = new GetAllUsersRequest()
{
RequestParams = reqParams
};
return await _mediator.ExecuteAsync(request).ConfigureAwait(false);
}
public async Task <IActionResult> GetAllUsers()
{
var request = new GetAllUsersRequest();
var model = new GetAllUsersQueryRequest
{
TransferObject = request
};
var result = await Mediator.Send(model);
return(HandleResponse(result, r => r));
}
public ActionResult Kasutajad()
{
var sessCheck = CheckContext();
if (sessCheck != null)
{ return sessCheck; }
KasutajadModel model = new KasutajadModel();
var request = new GetAllUsersRequest();
request.sessionHandle = GetCurrentContext().SessionHandle;
GetAllUsersResponse response;
try
{ response = PtServiceHelper.GetServiceInstance().GetAllUsers(request); }
catch (Exception exception)
{
model.UserMsg = new MsgModel.UserMessages();
model.UserMsg.Msg = exception.Message;
model.UserMsg.Pealkiri = "Graafiku pärimisel tekkis tehiline tõrge!";
model.UserMsg.MessageType = MsgModel.UserMessages.MsgType.Viga;
return View(model);
}
if (response == null)
{
model.UserMsg = new MsgModel.UserMessages();
model.UserMsg.Msg = "Graafikute pärimine ebaõnnestus kuna teenuselt ei õnnestunud vastust saada!";
model.UserMsg.Pealkiri = "Graafiku pärimisel tekkis tõrge!";
model.UserMsg.MessageType = MsgModel.UserMessages.MsgType.Viga;
return View(model);
}
if (response.GetAllUsersResult.AuthResponse.IsAuthenticated != true)
{
model.UserMsg = new MsgModel.UserMessages();
model.UserMsg.Msg = response.GetAllUsersResult.AuthResponse.AuthException.Message;
model.UserMsg.Pealkiri = "Kasutaja autenimisel tekkis tõrge!";
model.UserMsg.MessageType = MsgModel.UserMessages.MsgType.Viga;
return View(model);
}
if (response.GetAllUsersResult.Successful != true)
{
model.UserMsg = new MsgModel.UserMessages();
model.UserMsg.Msg = response.GetAllUsersResult.Exception.Message;
model.UserMsg.Pealkiri = "Graafikute pärimine ebaõnnestus!";
model.UserMsg.MessageType = MsgModel.UserMessages.MsgType.Viga;
return View(model);
}
UpdateAuthContext(response.GetAllUsersResult.AuthResponse);
model.AllKasutajad = response.GetAllUsersResult.AllUsers;
_allKasutajad = response.GetAllUsersResult.AllUsers;
return View(model);
}
public GetAllUsersResponse Get(GetAllUsersRequest request)
{
GetAllUsersResponse response = new GetAllUsersResponse();
try
{
response.Users = _brainManager.GetUsers();
}
catch (Exception ex)
{
throw ex;
}
return(response);
}
public async Task <Result <ListResult <UserResponse> > > Handle(GetAllUsersRequest request, CancellationToken cancellationToken)
{
try
{
var result = await _userRepository.GetAll();
var response = CreateListResponse(result.Records.ToList());
return(Result <ListResult <UserResponse> > .Ok(response));
}
catch (Exception e)
{
return(Result <ListResult <UserResponse> > .Failure(e.Message));
}
}
void AllUsersBrowser_Loaded(object sender, RoutedEventArgs e)
{
Core.Instance.DataClient.GetAllUsersCompleted += new EventHandler<SettleIn.DataServerInstance.GetAllUsersCompletedEventArgs>(DataServiceClient_GetAllUsersCompleted);
DataServerInstance.GetAllUsersRequest req = new GetAllUsersRequest();
Core.Instance.DataClient.GetAllUsersAsync(req);
/*
Server.Instance.Connect(new XmlUserCredentials("piet", "test"));
RequestAllPlayersAction getPlayers = new RequestAllPlayersAction();
getPlayers.Sender = new XmlUser("piet");
Server.Instance.SayAndClear("TestUser", getPlayers, false);
*/
// Update UI request has been sent
// do that here
}
public async Task <IActionResult> GetAllAsync([FromQuery] GetAllUsersRequest request)
{
// creating query from request
var query = MapToQuery <GetAllUsersQuery>(request);
// sending request query to handlers
var result = await SendAsync(query);
// mapping result to dto
var resultDto = result.Select(r => MapToDto <UserDto>(r));
return(Ok(new GetAllUsersResponse()
{
Data = resultDto
}));
}
public IHttpActionResult GetAll(GetAllUsersRequest request)
{
int userTenantId = (int)ActionContext.Request.Properties["UserTenantId"];
var data = _userManipulation.GetAllUsers(userTenantId, null);
if (data == null)
{
return(NotFound());
}
return(Ok(new GetAllUsersResponse()
{
Data = data,
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
public object Get(GetAllUsersRequest request)
{
var usersQuery = Db.From <UserAuth>().Where(p => p.FirstName != null && p.LastName != null && p.FirstName != "" && p.LastName != "")
.OrderBy(o => o.FirstName)
.ThenBy(o => o.LastName);
request.SetLimitIfNoPagingRequested(20);
var filter = request.Filter ?? "";
usersQuery = usersQuery.Where(p => p.FirstName.Contains(filter) || p.LastName.Contains(filter) || p.Email.Contains(filter)).Limit(request.Offset, request.PageSize);
var userAuths = this.Db.Select(usersQuery);
var count = this.Db.Count(usersQuery);
var result = userAuths.Select(s => s.ToDto()).ToList();
var response = this.CreatePagedResponse <UsersResponse>(request, Convert.ToInt32(count));
response.Users = result;
return(response);
}
GetAllUsersResponse IUserService.GetAllUsers(GetAllUsersRequest request)
{
var response = new GetAllUsersResponse()
{
Request = request,
ResponseToken = Guid.NewGuid()
};
try
{
response.Users = _repository.FindAll().MapToViews();
response.Success = true;
}
catch (Exception ex)
{
response.Message = ex.Message;
response.Success = false;
}
return(response);
}
public override GetAllUsersResponse OnGetAllUsersExecute(GetAllUsersRequest request)
{
GetAllUsersResponse response = new GetAllUsersResponse();
try
{
if (request != null)
{
var spec = new UsuariosAllSpec(request.Filter);
if (request.PageSize > 0)
{
var pagedOptions = new PagedOptions()
{
Direction = request.SortDirection, OrderBy = request.PropertyName, PageNumber = request.PageNumber, PageSize = request.PageSize, IncludeTotalCount = true
};
var repository = _usuarioRepository.QueryPaged(pagedOptions, spec);
response.PageResult = new PagedResult <UsuarioDto>(repository.PageNumber, repository.PageSize, repository.TotalCount, _mapperService.Map <List <UsuarioDto> >(repository.DataList));
}
else
{
var repository = _usuarioRepository.Query(spec, request.PropertyName, request.SortDirection);
response.PageResult = new PagedResult <UsuarioDto>(0, 0, repository.Count, _mapperService.Map <List <UsuarioDto> >(repository));
}
}
else
{
var usuarios = _usuarioRepository.Query(null);
response.PageResult = new PagedResult <UsuarioDto>(0, 0, usuarios.Count, _mapperService.Map <List <UsuarioDto> >(usuarios));
}
}
catch (Exception ex)
{
response.Exception = ex;
}
return(response);
}
public async Task <IEnumerable <UserDto> > HandleAsync(GetAllUsersRequest request)
{
var dbSet = _db.Users;
IQueryable <UserEntity> query = dbSet.OrderBy(e => e.Id);
switch (request.Sort)
{
case UserSortingOptions.FullNameAscending:
query = dbSet.OrderBy(e => e.FullName);
break;
case UserSortingOptions.FullNameDescending:
query = dbSet.OrderByDescending(e => e.FullName);
break;
case UserSortingOptions.RatingAscending:
query = dbSet.OrderBy(e => e.Rating);
break;
case UserSortingOptions.RatingDescending:
query = dbSet.OrderByDescending(e => e.Rating);
break;
}
if (request.Take > 0)
{
query = query
.Skip(request.Skip)
.Take(request.Take);
}
var result = (await query
.ToListAsync()
.ConfigureAwait(false)).Select(Mapper.Map <UserDto>);
return(result);
}
public IHttpActionResult GetAllUsers()
{
var loggedUserId = HttpContext.Current.GetOwinContext().GetUserId();
var request = new GetAllUsersRequest()
{
RequestToken = Guid.NewGuid(),
UserId = loggedUserId
};
var usersResponse = _userService.GetAllUsers(request);
if (!usersResponse.Success)
{
return(BadRequest(usersResponse.Message));
}
return(Ok(
new
{
authors = usersResponse.Users.MapToViewModels()
}
));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="responseStream"></param>
/// <param name="context"></param>
/// <returns></returns>
public override Task GetAllUsers(GetAllUsersRequest request, IServerStreamWriter <GetAllUsersReply> responseStream, ServerCallContext context)
{
//var users = _mediator.Send(new GetAllUsersQuery());
//foreach (var item in users.Result.usuarios)
//{
// await responseStream.WriteAsync(new GetAllUsersReply()
// {
// Usuario = new Usuario()
// {
// IdPer = item.ID_PER,
// Nombres = item.NOMBRES,
// ApPaterno = item.AP_PATERNO,
// ApMaterno = item.AP_MATERNO,
// Rut = (int)item.RUT,
// DigVer = item.DIG_VER,
// CorreoElectronico = item.CORREO_ELECTRONICO
// },
// //Error = (ErrorCode)users.Result.ERROR
// });
//}
return(Task.CompletedTask);
}
public GetAllUsersResponse GetAllUsers(GetAllUsersRequest request)
{
var response = new GetAllUsersResponse();
try
{
Guard.ArgNotNull(request, "request");
User[] results = _unitOfWork.UserRepository.Get(d => d.Id > 0).ToArray();
Guard.ArgNotNull(results, "results");
var quickInfoResults = new List<UserQuickInfo>(results.Count());
quickInfoResults.AddRange(results.Select(
user => new UserQuickInfo
{
Id = user.Id,
FormsAuthId = user.FormsAuthId,
Email = user.Email,
LoginName = user.LoginName
}));
response.Users = quickInfoResults.AsEnumerable();
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.FailureInformation = ex.Message;
Logger.LogError("GetAllUsers Method Failed", ex);
}
return response;
}
public async Task <IEnumerable <UserDto> > Get([FromUri] GetAllUsersRequest request)
{
return(await _mediator.ExecuteAsync(request).ConfigureAwait(false));
}
public Task <GetAllUsersResponse> GetAllUsers(GetAllUsersRequest request, int UserID)
{
throw new NotImplementedException();
}
public abstract GetAllUsersResponse OnGetAllUsersExecute(GetAllUsersRequest request);
public Task <List <UserViewModel> > Handle(GetAllUsersRequest request, CancellationToken _) => this.dbRepository.GetAllUsersAsync();
GetAllUsersResponse IPDAOrder.GetAllUsers(GetAllUsersRequest request)
{
return(base.Channel.GetAllUsers(request));
}
public Task <List <UserViewModel> > Get()
{
IRequest <List <UserViewModel> > getAllUsersRequest = new GetAllUsersRequest();
return(this.mediator.Send(getAllUsersRequest));
}
public async Task <IActionResult> GetALLUsers([FromQuery] GetAllUsersRequest request)
{
return(await this.HandleRequest <GetAllUsersRequest, GetAllUsersResponse>(request));
}
public Task <List <DTOs.User> > Handle(GetAllUsersRequest request, CancellationToken cancellationToken)
{
return(_service.GetAll());
}
public Task <IEnumerable <User> > Handle(GetAllUsersRequest request, CancellationToken cancellationToken)
{
return(ReadModel.UserRepository.GetAll());
}
