public async Task <UserListResponse> ExecuteAsync()
{
Log.Information("Recuperando lista de Usuarios...");
var userListResponse = new UserListResponse();
try
{
var user = (await Repository.GetAllAsync("users"))?.ToArray();
if (user == null || !user.Any())
{
var exception = new Exception("No hay usuarios devueltos.");
Log.Error(exception, EXCEPTION_MESSAGE_TEMPLATE, exception.Message);
HandleErrors(userListResponse, exception, 404);
}
else
{
userListResponse = new UserListResponse
{
Users = user,
StatusCode = 200
};
var count = user.Length;
Log.Information("Devuelto [{Count}] Usuarios.", count);
}
}
catch (Exception exception)
{
Log.Error(exception, "Error al obtener la lista de todos los usuarios.");
HandleErrors(userListResponse, exception);
}
return(userListResponse);
}
public void GetUserList_Return_OK()
{
//Arrange
var mockDb = new Mock <IDataBaseManager>();
UserListResponse userListResponse = new UserListResponse {
FullName = "Frank", Id = 255, Login = "******", Email = "*****@*****.**", Phone = "+38099999999"
};
mockDb.Setup(db => db.GetUserList(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).Returns(new UserListResponse[] {
new UserListResponse {
FullName = "Frank", Id = 255, Login = "******", Email = "*****@*****.**", Phone = "+38099999999"
}
});
var mockLogger = new Mock <ILogger>();
mockLogger.Setup(db => db.Debug(It.IsAny <string>()));
var mockSessionState = new Mock <ISessionStateManager>();
var mockMapper = new Mock <IMapper>();
var manager = new UserManager(mockDb.Object, mockLogger.Object, mockSessionState.Object, mockMapper.Object);
//Act
var result = manager.GetUserList("Moderator", 2, "fr", out Errors statusCode);
//Assert
Assert.AreEqual(userListResponse.Id, result[0].Id);
Assert.AreEqual(userListResponse.Login, result[0].Login);
Assert.AreEqual(userListResponse.FullName, result[0].FullName);
Assert.AreEqual(userListResponse.Email, result[0].Email);
Assert.AreEqual(userListResponse.Phone, result[0].Phone);
Assert.AreEqual(Errors.OK, statusCode);
}
public ActionResult <UserListResponse> Search([FromQuery] UserSearchRequest searchRequest)
{
var users = _users.Search(searchRequest);
var userCount = _users.Count(searchRequest);
return(UserListResponse.Create(searchRequest, users, userCount));
}
public async Task <UserListResponse> getUsersAsync(ListDTO listDTO)
{
try
{
UserListResponse userListResponse = new UserListResponse();
userListResponse.Users = new List <UserRow>();
var lst = Context.Users.Select(a => new UserRow {
Id = a.Id, UserName = a.UserName, Email = a.Email
}).AsQueryable();
if (listDTO.Filter != null && listDTO.Filter != string.Empty)
{
lst = new LinqSearch().ApplyFilter(lst, listDTO.Filter);
}
userListResponse.LstCount = await lst.CountAsync();
userListResponse.Users = await lst.Skip((listDTO.PageNum - 1) *listDTO.PageSize).Take(listDTO.PageSize).ToListAsync();
userListResponse.ToSuccess <UserListResponse>();
return(userListResponse);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Gets the list of all users.
/// </summary>
/// <returns>The users.</returns>
public UserListResponse GetUsers()
{
var response = new UserListResponse();
var users = new List <User>();
var sMgmt = LdapQueryManager.Instance;
var resps = sMgmt.ExecuteSearch("", LdapSearchType.User);
int results = 0;
response.UserNames = new List <string>();
foreach (var entry in resps)
{
var u = ConvertfromLdap(entry);
response.UserNames.Add(u.Name);
users.Add(u);
results++;
}
logger.Debug("User search executed results:{result}", results);
response.Users = users;
response.SearchType = "User";
response.SearchMethod = LdapSearchMethod.Simple;
return(response);
}
public UserListResponse Sync(SyncUserRequest request)
{
UserListResponse response = new UserListResponse();
List <UserViewModel> users = new List <UserViewModel>();
try
{
if (request.LastUpdatedAt != null)
{
var users2 = unitOfWork.GetUserRepository()
.GetUsersNewerThan(request.CompanyId, (DateTime)request.LastUpdatedAt)
?.ConvertToUserViewModelList() ?? new List <UserViewModel>();
users.AddRange(users2);
}
else
{
var users2 = unitOfWork.GetUserRepository()
.GetUsers(request.CompanyId)
?.ConvertToUserViewModelList() ?? new List <UserViewModel>();
users.AddRange(users2);
}
response.Users = users;
response.Success = true;
}
catch (Exception ex)
{
response.Users = new List <UserViewModel>();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public UserListResponse GetUsersNewerThan(int companyId, DateTime?lastUpdateTime)
{
UserListResponse response = new UserListResponse();
try
{
if (lastUpdateTime != null)
{
response.Users = unitOfWork.GetUserRepository()
.GetUsersNewerThan(companyId, (DateTime)lastUpdateTime)
.ConvertToUserViewModelList();
}
else
{
response.Users = unitOfWork.GetUserRepository()
.GetUsers(companyId)
.ConvertToUserViewModelList();
}
response.Success = true;
}
catch (Exception ex)
{
response.Users = new List <UserViewModel>();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <UserListResponse> GetUserList(int pageno)
{
UserListResponse userResponse = new UserListResponse();
try
{
using (var client = new CustomRestClient(_serviceURL, _token))
{
var response = await client.GetAsync <ServiceMainResponse>($"/users?page={pageno}");
if (response.Code == 200)
{
userResponse.IsSuccess = true;
userResponse.UserInfoList = ((JArray)response.Data).ToObject <List <UserInfo> >();
userResponse.Meta = response.Meta;
}
else if (response.Code == 404)
{
userResponse.IsSuccess = false;
userResponse.ErrorInfo = ((JObject)response.Data).ToObject <MessageData>().Message;
}
};
}
catch
{
userResponse.IsSuccess = false;
userResponse.ErrorInfo = Resource.Messages.ErrorMessage;
}
return(userResponse);
}
public UserListResponse GetUsers(int start, int end)
{
var response = new UserListResponse();
var users = new List <User>();
var sMgmt = LdapQueryManager.Instance;
int results = 0;
var resps = sMgmt.ExecuteLimitedSearch("", LdapSearchType.User, start, end);
foreach (var entry in resps)
{
users.Add(ConvertfromLdap(entry));
results++;
}
logger.Debug("User search executed results:{result}", results);
response.Users = users;
response.SearchType = "User";
response.SearchMethod = LdapSearchMethod.Paged;
return(response);
}
public static UserListResponse GetUserList(TodoListDBContext db, long userId)
{
UserListResponse response = new UserListResponse();
var list = from ul in db.UserList
join l in db.List
on ul.ListId equals l.Id
join lt in db.ListType
on l.Type equals lt.Id
where ul.UserId == userId &&
ul.Status == (byte)StatusType.Active &&
l.Status == (byte)StatusType.Active
select new List()
{
TypeName = lt.Name,
CreatedDate = l.CreatedDate,
Description = l.Description,
EndsAt = l.EndsAt,
Id = l.Id,
ModifierBy = l.ModifierBy,
OwnerBy = l.OwnerBy,
Priority = l.Priority,
StartsAt = l.StartsAt,
Status = l.Status,
Title = l.Title,
Type = l.Type,
UpdatedDate = l.UpdatedDate
};
response.List = list.ToList();
response.UserId = userId;
return(response);
}
public void UserList()
{
var client = this.fixture.UserClient;
UserListResponse actual = null;
using (var sync = new InSync(nameof(SlackClient.UserLookup)))
{
client.GetUserList(response =>
{
actual = response;
sync.Proceed();
});
}
Assert.True(actual.ok, "Error while fetching user list.");
Assert.True(actual.members.Any());
var someMember = actual.members.First();
Assert.NotNull(someMember.id);
Assert.NotNull(someMember.color);
Assert.NotNull(someMember.real_name);
Assert.NotNull(someMember.name);
Assert.NotNull(someMember.team_id);
Assert.NotNull(someMember.tz);
Assert.NotNull(someMember.tz_label);
}
public void UserList()
{
var client = this.fixture.UserClient;
UserListResponse actual = null;
using (var sync = new InSync(nameof(SlackClient.UserLookup)))
{
client.GetUserList(response =>
{
actual = response;
sync.Proceed();
});
}
Assert.True(actual.ok, "Error while fetching user list.");
Assert.True(actual.members.Any());
// apparently deleted users do indeed have null values, so if the first user returned is deleted then there are failures.
var someMember = actual.members.Where(x => !x.deleted).First();
Assert.NotNull(someMember.id);
Assert.NotNull(someMember.color);
Assert.NotNull(someMember.real_name);
Assert.NotNull(someMember.name);
Assert.NotNull(someMember.team_id);
Assert.NotNull(someMember.tz);
Assert.NotNull(someMember.tz_label);
}
public UserListResponse GetUser()
{
UserListResponse response = new UserListResponse();
try
{
throw new Exception();
var result = new UserCRUD().GetUsers();
if (result.Count == 0)
{
response.NoContent();
}
else
{
response.OK();
response.User = result;
}
}
catch (Exception es)
{
logger.Error("GetUser " + es.StackTrace);
response.InternalServerError();
}
return(response);
}
public UserListResponse GetUsers(string term)
{
var response = new UserListResponse();
var users = _userRepository.GetUsers(term);
response.Users = users.Select(x => UserDtoBuilder.ToDto(x));
return(response);
}
public UserListResponse Execute(UserListRequest request)
{
UserListResponse userListResponse = new UserListResponse();
IPagedList <UserInfo> pagedUsers = ServiceHelper.LoadService <IUserService>().GetPagedUsers(request.PageNumber, request.PageSize);
IList <UserModel> userModelList = ServiceHelper.LoadService <IUserService>().BuildUserModels((IEnumerable <UserInfo>)pagedUsers);
userListResponse.Users = new PagedData <UserModel>((IEnumerable <UserModel>)userModelList, (IPagedList)pagedUsers);
return(userListResponse);
}
public ActionResult AddMultipleList([FromBody] List[] listArray)
{
try
{
var token = new ClaimPrincipal(HttpContext.User);
UserListResponse response = new UserListResponse();
User user = db.User.FirstOrDefault(u => u.UserName == token.NameIdentifier);
if (user == null)
{
response.Message = "The user not found!";
return(NotFound(response));
}
foreach (var list in listArray)
{
//Create list
var newList = new List()
{
CreatedDate = Utils.GetUnixTimeNow(),
Description = list.Description,
EndsAt = list.EndsAt,
ModifierBy = user.UserName,
OwnerBy = user.UserName,
Priority = list.Priority,
StartsAt = list.StartsAt,
Status = (byte)StatusType.Active,
Title = list.Title,
Type = list.Type,
UpdatedDate = Utils.GetUnixTimeNow()
};
db.List.Add(newList);
db.SaveChanges();
//Create user list
var userList = new UserList()
{
ListId = newList.Id,
ModifierBy = user.UserName,
OwnerBy = user.OwnerBy,
Status = (byte)StatusType.Active,
UpdatedDate = Utils.GetUnixTimeNow(),
CreatedDate = Utils.GetUnixTimeNow(),
UserId = user.Id
};
db.UserList.Add(userList);
db.SaveChanges();
}
response = ListService.GetUserList(db, user.Id);
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
/// <summary>
/// Return a string list of the users DNs
/// </summary>
/// <returns>The list.</returns>
public UserListResponse GetList(string attribute = "", string filter = "", string cookie = "")
{
var response = new UserListResponse();
var users = new List <String>();
var sMgmt = LdapQueryManager.Instance;
int results = 0;
string formatedFilter = "";
if (filter != "")
{
if (attribute != "")
{
formatedFilter = attribute + "=" + filter;
}
else
{
formatedFilter = "cn=" + filter;
}
}
List <LdapEntry> resps;
var presp = sMgmt.ExecutePagedSearch("", LdapSearchType.User, formatedFilter, cookie);
response.Cookie = presp.Cookie;
resps = presp.Entries;
foreach (var entry in resps)
{
if (attribute == "")
{
users.Add(entry.GetAttribute("distinguishedName").StringValue);
}
else
{
users.Add(entry.GetAttribute(attribute).StringValue);
}
results++;
}
response.UserNames = users;
response.SearchType = "User";
response.SearchMethod = LdapSearchMethod.Paged;
logger.Debug("User search executed results:{result}", results);
return(response);
}
public ApiContext()
{
baseUri = new Uri("https://reqres.in/api/");
response = new HttpResponseMessage();
user = new User();
userListResponse = new UserListResponse();
userQueryResponse = new UserQueryResponse();
loginToken = new LoginToken();
loginError = new LoginError();
}
public void RefreshData()
{
UserListResponse userListResponse = LocalApi.Execute(new UserListRequest()
{
PageNumber = this.pager.PageNumber, PageSize = 10
});
this.pager.Setup(userListResponse.Users);
this.dataGrid.ItemsSource = userListResponse.Users;
}
public void CheckAllActiveUsersInRoom()
{
var ulResponse = new UserListResponse
{
UsersList = Users.Select(user => user.UserName).ToList(),
UsersListGenerated = DateTime.Now
};
var userListBytes = _messageHandler.ObjectToByteArray(ulResponse);
SendToAllUsers(userListBytes);
}
public async Task <ActionResult> List([FromQuery] UserListRequest rq)
{
try
{
UserListResponse rs = await(new UserListService(Context, _userRepo)).RunAsync(rq);
return(new ApiActionResult(Context.Request, rs));
}
catch (Exception ex)
{
return(new ApiActionResult(Context.Request, ex));
}
}
public UserServiceTests()
{
_mapper = new Mock <IMapper>();
_repository = new Mock <IGenericRepository <User> >();
_userAuthenticateRequest = new UserAuthenticateRequest();
_user = new User();
_userResponse = new UserListResponse();
_userListResponses = new List <UserListResponse>();
_users = new List <User>();
_configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
sut = new UserService(_configuration, _repository.Object, _mapper.Object);
}
private void UserListProcess(MessageReceivedEventArgs message)
{
var userListRequest = _serializerService.Deserialize <UserListReq>(message.Message);
List <CommonUsers> allUsers = _commonUserListService.GetUsers();
var userListResponse = new UserListResponse();
userListResponse.Users = new List <User>();
foreach (User user in _currentUsers.Keys.Where(u => u.Login != userListRequest.Login))
{
userListResponse.Users.Add(user);
}
foreach (CommonUsers user in allUsers)
{
if (user.Login != userListRequest.Login)
{
if (!userListResponse.Users.Any(u => u.Login == user.Login))
{
userListResponse.Users.Add(new User {
Login = user.Login, Status = PresenceStatus.Offline
});
}
}
}
QueueServerService.SendData(message.TopicSender, ConfigurationService.ExchangeName, userListResponse);
QueueingBasicConsumer consumer =
_queueManagerService.CreateConsumerForClient(string.Format("archive.{0}", userListRequest.Login));
while (true)
{
BasicDeliverEventArgs basicDeliverEventArgs;
consumer.Queue.Dequeue(50, out basicDeliverEventArgs);
if (basicDeliverEventArgs == null)
{
break;
}
var messageReq = _serializerService.Deserialize <MessageReq>(basicDeliverEventArgs.Body);
_currentUsers.Where(u => u.Key.Login == userListRequest.Login)
.ToList()
.ForEach(
topic => topic.Value.TopicList.ToList()
.ForEach(
t => QueueServerService.SendData(t, ConfigurationService.ExchangeName, messageReq)));
_queueManagerService.SendAck(basicDeliverEventArgs.DeliveryTag);
}
}
public void GetAll_Called_ReturnsUserResponse()
{
// Given
var response = new UserListResponse { Results = new List<User> { new User { Id = 1 } } };
_client.Setup(b => b.Get<UserListResponse>(It.IsAny<Uri>())).Returns(response);
var userResource = new UserResource(_client.Object);
// When
var result = userResource.GetAll(new List<long> { 4321, 3456, 6789 });
// Then
Assert.That(result, Is.EqualTo(response));
}
public ActionResult AddTypeToList(long listId, int typeId)
{
try
{
var token = new ClaimPrincipal(HttpContext.User);
UserListResponse response = new UserListResponse();
User user = db.User.FirstOrDefault(u => u.UserName == token.NameIdentifier);
if (user == null)
{
response.Message = "The user not found!";
return(NotFound(response));
}
//Check user list
var userList = db.UserList.FirstOrDefault(ul => ul.UserId == user.Id && ul.ListId == listId);
if (userList == null)
{
response.Message = "Unauthorized!";
return(Unauthorized(response));
}
//Check the list
var currentList = db.List.FirstOrDefault(l => l.Id == listId);
if (currentList == null)
{
response.Message = "The list not found!";
return(NotFound(response));
}
//Get list type
var listType = db.ListType.FirstOrDefault(l => l.Id == typeId && l.Status == (byte)StatusType.Active);
if (listType == null)
{
response.Message = "The list type not found!";
return(NotFound(response));
}
currentList.ModifierBy = user.UserName;
currentList.UpdatedDate = Utils.GetUnixTimeNow();
currentList.Type = listType.Id;
db.SaveChanges();
response = ListService.GetUserList(db, user.Id);
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <UserListResponse> Login([FromBody] UserLoginRequest user)
{
UserListResponse userListResponse = new UserListResponse();
if (ModelState.IsValid)
{
userListResponse.Users = new List <UserRow>();
UserRow userRow = new UserRow();
var existingUser = await _userManager.FindByNameAsync(user.UserName);
if (existingUser == null)
{
return(userListResponse.ToInvalidUserNameOrPassword <UserListResponse>());
}
var isCorrect = await _userManager.CheckPasswordAsync(existingUser, user.Password);
if (isCorrect)
{
Constants.LoginUserName = user.UserName;
var jwtToken = GenerateJwtToken(existingUser.Id);
userRow.Token = jwtToken;
}
else
{
return(userListResponse.ToInvalidUserNameOrPassword <UserListResponse>());
}
var roles = _aspNetUserRolesService.getUserRolesByUserIdAsync(existingUser.Id);
if (roles != null)
{
userRow.Roles = new List <RoleRow>();
userRow.Roles = roles.Result.Roles;
}
var claim = _aspNetUserRolesService.getUserClaimsByUserIdAsync(existingUser.Id);
if (claim != null)
{
userRow.Claims = new List <ClaimsRow>();
userRow.Claims = claim.Result.Claims;
}
userRow.UserName = user.UserName;
userRow.Id = existingUser.Id;
userRow.Email = existingUser.Email;
userListResponse.Users.Add(userRow);
userListResponse.ToSuccess <UserListResponse>();
return(userListResponse);
}
return(userListResponse.ToIncompleteInput <UserListResponse>());
}
/// <summary>
/// Gets the list. Limited to a start and end number based on the total colection sorted by the name
/// </summary>
/// <returns>The list.</returns>
/// <param name="start">Start.</param>
/// <param name="end">End.</param>
/// <param name="attribute">The attribute name to appear on the list</param>
public UserListResponse GetList(int start, int end, string attribute = "", string filter = "")
{
var response = new UserListResponse();
var users = new List <String>();
var sMgmt = LdapQueryManager.Instance;
int results = 0;
string formatedFilter = "";
if (filter != "")
{
if (attribute != "")
{
formatedFilter = attribute + "=" + filter;
}
else
{
formatedFilter = "cn=" + filter;
}
}
var resps = sMgmt.ExecuteLimitedSearch("", LdapSearchType.User, start, end, formatedFilter);
foreach (var entry in resps)
{
string u = "";
if (attribute == "")
{
u = entry.GetAttribute("distinguishedName").StringValue;
}
else
{
u = entry.GetAttribute(attribute).StringValue;
}
users.Add(u);
results++;
}
response.SearchType = "User";
response.SearchMethod = LdapSearchMethod.Limited;
response.UserNames = users;
logger.Debug("User search executed results:{result}", results);
return(response);
}
public UserListResponse Search(long id, SearchRequest req)
{
UserListResponse resp = new UserListResponse();
try
{
if (ValidateRequest.SearchRequest(req))
{
var userCrud = new UserCRUD();
if (userCrud.IsUserExists(id))
{
List <string> states = req.Filters.Where(x => x.Filters == EFilters.States).Select(x => x.Values).FirstOrDefault();
List <string> homeType = req.Filters.Where(x => x.Filters == EFilters.HomeType).Select(x => x.Values).FirstOrDefault();
List <string> homeZipCode = req.Filters.Where(x => x.Filters == EFilters.HomeZipCode).Select(x => x.Values).FirstOrDefault();
List <string> numberOfKids = req.Filters.Where(x => x.Filters == EFilters.NumberOfKids).Select(x => x.Values).FirstOrDefault();
int minAge = req.Filters.Where(x => x.Filters == EFilters.Age).Select(x => x.MinAge).FirstOrDefault();
int maxAge = req.Filters.Where(x => x.Filters == EFilters.Age).Select(x => x.MaxAge).FirstOrDefault();
bool isAgeFilterExists = req.Filters.Any(x => x.Filters == EFilters.Age);
var userList = userCrud.GetUsers(states, homeType, homeZipCode, numberOfKids, isAgeFilterExists, minAge, maxAge);
if (userList.Count > 0)
{
resp.User = userList;
resp.OK();
}
else
{
resp.NotFound();
}
}
else
{
resp.Conflict();
}
}
else
{
resp.BadRequest();
}
}
catch (Exception es)
{
string reqData = JsonConvert.SerializeObject(req);
logger.Error(string.Format("SearchRequest, UserID={0}, Req={1}", id, reqData));
logger.Error("SearchRequest " + es.StackTrace);
resp.InternalServerError();
}
return(resp);
}
private void AddUsers(UserListResponse response)
{
//ComboUser.Items.Clear();
responseUsers.Clear();
foreach (var user in response.members)
{
responseUsers.Add(ResponseUser.FromUser(user));
}
ComboUser.ItemsSource = null;
responseUsers.Insert(0, ResponseUser.GetAllUser()); // insert the All Users user on top
ComboUser.ItemsSource = responseUsers;
ComboUser.Items.Refresh();
ComboUser.SelectedIndex = 0;
SetStatus($"Userlist received. ({responseUsers.Count-1} users)");
}
private string HandleNPrintingUser(Model.User user)
{
UserListResponse nPrintingUser = _usersApi.UsersGet(user.Email);
//User already in NPrinting
if (nPrintingUser.Data.Items != null && nPrintingUser.Data.Items.Count > 0)
{
UserResponseDataItem npUser = nPrintingUser.Data.Items[0];
_npUserService.UpdateNpUser(npUser, user);
return(npUser.Id.ToString());
}
else
{
return(_npUserService.AddNewNpUser(user));
}
}
static async Task CheckStuff(SlackTaskClient slackClient, Channel channel, UserListResponse users)
{
await _semaphore.WaitAsync();
threadCount++;
//Console.WriteLine("Thread {0} starting", threadCount);
try {
var history = await slackClient.GetChannelHistoryAsync(channel, null, DateTime.Now.AddDays(-7), 1000);
if (history.messages == null)
{
Console.WriteLine("Rate Limited: Backing Off for 10s");
await Task.Delay(10000);
history = await slackClient.GetChannelHistoryAsync(channel, null, DateTime.Now.AddDays(-7), 1000);
if (history.messages == null)
{
throw new Exception("Something went bad. You was rate limited");
}
}
if (history.messages.Count() == 0)
{
return;
}
Console.WriteLine("{0}: Count: {1}, More Messages? : {2}", channel.name, history.messages.Count(), history.has_more);
foreach (var message in history.messages)
{
var user = users.members.FirstOrDefault(s => s.id == message.user);
var name = user != null ? user.name : "bot or unknown";
lock (key) {
peoples.Add(name);
}
}
}
catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
throw;
}
finally
{
//Console.WriteLine("Thread {0} finished", threadCount);
threadCount--;
_semaphore.Release();
}
}
