public UnregisterStatus Unregister(string Username)
{
GetUsersResponse resp = api.Helix.Users.GetUsersAsync(logins: new List <string>()
{
Username
}).Result;
List <UserResponse> user = resp.Users.Select(t => new UserResponse(t)).ToList();
if (user.Count == 0)
{
return(UnregisterStatus.UserNotFound);
}
if (!Tracking.Contains(user[0].Id))
{
return(UnregisterStatus.NotTracking);
}
Tracking.Remove(user[0].Id);
UserDatabase.Remove(user[0].Id);
Offline.Remove(user[0].Id);
Online.Remove(user[0].Id);
return(UnregisterStatus.Success);
}
public async Task PostBroadcasterConfigAsync_NotFound()
{
const int channelId = 123;
const string broadcaster = "broadcaster";
_Log.Setup(s => s.LogInformation($"Checking that broadcaster '{broadcaster}' exists."));
const string endpoint = "https://twitch.tv/users";
const string clientId = "kdrgvhidhfskljecsemphgdhdfgfls";
const string accept = "application/json";
var getUserResponse = new GetUsersResponse {
Users = new List <User>()
};
_TwitchWrapper.Setup(s => s.GetUsers(endpoint, clientId, accept, broadcaster)).ReturnsAsync(getUserResponse);
var errorMessage = $"Could not find streamer '{broadcaster}'.";
_Log.Setup(s => s.LogInformation(errorMessage));
var inputContainer = new BroadcasterConfigContainer();
var result = await _Helper.PostBroadcasterConfigAsync(endpoint, clientId, accept, channelId, broadcaster, inputContainer);
_Log.VerifyAll();
_TwitchWrapper.VerifyAll();
_Context.VerifyAll();
Assert.That(result.ErrorMessage, Is.EqualTo(errorMessage));
Assert.That(result.ChannelConfigContainer, Is.Null);
}
public UserResponse?GetUser(string Username)
{
Username = Username.ToLower();
foreach (KeyValuePair <long, UserResponse> Pair in UserDatabase)
{
if (Pair.Value.LoginUsername.ToLower() == Username)
{
return(Pair.Value);
}
}
GetUsersResponse resp = api.Helix.Users.GetUsersAsync(logins: new List <string>()
{
Username
}).Result;
List <UserResponse> user = resp.Users.Select(t => new UserResponse(t)).ToList();
if (user.Count == 0)
{
return(null);
}
else
{
return(user[0]);
}
}
public async Task PostBroadcasterConfigAsync()
{
const int channelId = 123;
const string broadcaster = "broadcaster";
_Log.Setup(s => s.LogInformation($"Checking that broadcaster '{broadcaster}' exists."));
const string endpoint = "https://twitch.tv/users";
const string clientId = "kdrgvhidhfskljecsemphgdhdfgfls";
const string accept = "application/json";
const string displayName = "BrOaDcAsTeR";
var getUserResponse = new GetUsersResponse {
Users = new List <User> {
new User {
DisplayName = displayName
}
}
};
_TwitchWrapper.Setup(s => s.GetUsers(endpoint, clientId, accept, broadcaster)).ReturnsAsync(getUserResponse);
_Log.Setup(s => s.LogInformation($"Found broadcaster '{broadcaster}' with display name '{displayName}'."));
_Log.Setup(s => s.LogInformation($"Posting broadcaster config for channel '{channelId}' broadcaster '{displayName}'."));
var inputContainer = new BroadcasterConfigContainer();
var outputContainer = new ChannelConfigContainer();
_Context.Setup(s => s.SetBroadcasterConfigAsync(channelId, displayName, inputContainer)).ReturnsAsync(outputContainer);
_Log.Setup(s => s.LogInformation($"Posted broadcaster config for channel '{channelId}' broadcaster '{displayName}'."));
var result = await _Helper.PostBroadcasterConfigAsync(endpoint, clientId, accept, channelId, broadcaster, inputContainer);
_Log.VerifyAll();
_TwitchWrapper.VerifyAll();
_Context.VerifyAll();
Assert.That(result.ErrorMessage, Is.Null.Or.Empty);
Assert.That(result.ChannelConfigContainer, Is.EqualTo(outputContainer));
}
public void GetUsers()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
Assert.AreEqual(HttpStatusCode.OK, addUserResponse.Status);
GetUsersResponse getUsersResponse = usersFacade.GetUsers();
Assert.AreEqual(HttpStatusCode.OK, getUsersResponse.Status);
Assert.IsNotNull(getUsersResponse.Users.Find(u => u.UserId == addUserResponse.UserId));
using (helpdesksystemContext context = new helpdesksystemContext())
{
var users = context.User.ToList();
Assert.IsNotNull(users);
}
}
public override async Task <GetUsersResponse> List(GetUsersRequest request, ServerCallContext context)
{
_logger.LogInformation("Received incoming RPC to UserService.List");
try
{
var users = await _provider.GetAsync();
var res = new GetUsersResponse();
res.Users.AddRange(users?.Select(x => new GetUserResponse
{
Id = x.Id,
Firstname = x.Firstname,
Lastname = x.Lastname,
Email = x.Email
}));
return(res);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(new GetUsersResponse {
Error = e.Message
});
}
}
public void TestGetUsers()
{
int userId = 1;
GetUsersResponse response = new GetUsersResponse();
response.Users.Add(new UserListDTO()
{
Id = userId, UserName = "******"
});
Expect.Once.On(service).Method("GetUsersByCriteria").Will(Return.Value(response));
IList <UserListDTO> users = serviceFacade.GetUsersByRole("FakeRole");
Assert.AreEqual(1, users.Count);
Assert.AreEqual(users.First().Id, userId);
Expect.Once.On(service).Method("GetUsersByCriteria").Will(Return.Value(response));
users = serviceFacade.GetUsersByName("FakeName");
Assert.AreEqual(1, users.Count);
Assert.AreEqual(users.First().Id, userId);
Expect.Once.On(service).Method("GetUsersByCriteria").Will(Return.Value(response));
users = serviceFacade.GetAllUsers();
Assert.AreEqual(1, users.Count);
Assert.AreEqual(users.First().Id, userId);
}
public GetUsersResponse GetUsers()
{
var response = new GetUsersResponse();
try
{
if (_userService.AuthenticateSession(Request.Headers["Authorization"].ToString()) == false)
{
response.AddError("The authorization credentails were invalid", ErrorCode.SESSION_INVALID);
return(response);
}
ActiveUser user = _userService.GetUserInformationFromAuthHeader(Request.Headers["Authorization"].ToString());
if (user.HouseId == 0)
{
response.AddError("You must belong to a household to get users", ErrorCode.USER_NOT_IN_HOUSEHOLD);
return(response);
}
response.People = _peopleRepository.GetAllPeople(user.HouseId);
}
catch (ErrorCodeException exception)
{
response.AddError($"An unexpected exception occured: {exception}", exception.Code);
}
catch (Exception exception)
{
response.AddError($"An unexpected exception occured: {exception}");
}
return(response);
}
public override Task <GetUsersResponse> GetUsers(EmptyMessagee request, ServerCallContext context)
{
var regiterUsers = _userRepository.GetUsers();
var getUsersResponse = new GetUsersResponse();
foreach (User user in regiterUsers)
{
ICollection <ImageProto> images = new List <ImageProto>();
IEnumerable <CommentProto> comments = new List <CommentProto>().ToArray();
foreach (Image image in user.Images)
{
comments = image.Comments.Select(c => new CommentProto
{
Text = c.Text,
UserEmail = c.UserEmail,
});
var imageToSave = new ImageProto
{
Name = image.Name
};
imageToSave.Comments.AddRange(comments);
images.Add(imageToSave);
}
;
var userToSave = new UserProto {
UserEmail = user.Email,
Password = user.Password,
};
userToSave.Images.AddRange(images);
getUsersResponse.Users.Add(userToSave);
}
_logSenderService.SendMessages("registered users are requested");
return(Task.FromResult(getUsersResponse));
}
public async Task IdentifyRecipientsBasedOnSupportRadiusMiles_ReturnsCorrectUsers()
{
int?recipientUserId = null;
int?jobId = null;
int?groupId = null;
int?requestId = null;
List <UserDetails> userDetails = new List <UserDetails>();
userDetails.Add(new UserDetails()
{
SupportRadiusMiles = 1d,
UserID = 1
});
userDetails.Add(new UserDetails()
{
SupportRadiusMiles = 2d,
UserID = 2
});
userDetails.Add(new UserDetails()
{
UserID = 3
});
_getUsersResponse = new GetUsersResponse();
_getUsersResponse.UserDetails = userDetails;
var result = await _classUnderTest.IdentifyRecipients(recipientUserId, jobId, groupId, requestId, null);
Assert.AreEqual(userDetails.Count(x => x.SupportRadiusMiles.HasValue), result.Count);
}
/// <summary>
/// This method is responsible for retrieving all users from the helpdesk system
/// </summary>
/// <returns>The response that indicates if the operation was a success,
/// and the list of users</returns>
public GetUsersResponse GetUsers()
{
s_logger.Info("Getting users...");
GetUsersResponse response = new GetUsersResponse();
try
{
var dataLayer = new UsersDataLayer();
List <UserDTO> users = dataLayer.GetUsers();
response.Users = users;
response.Status = HttpStatusCode.OK;
}
catch (NotFoundException ex)
{
s_logger.Error(ex, "No users found!");
response.Status = HttpStatusCode.NotFound;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.NotFound, "No users found!"));
}
catch (Exception ex)
{
s_logger.Error(ex, "Unable to get users!");
response.Status = HttpStatusCode.InternalServerError;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.InternalServerError, "Unable to get users!"));
}
return(response);
}
public async Task <ServiceResponse <GetUsersResponse> > GetUsersAsync(GetUsersRequest request)
{
bool isQueryIncluded = !string.IsNullOrWhiteSpace(request.Query);
var dbQuery = Context.Users.Where(u => u.IsDeleted == false);
if (isQueryIncluded)
{
string queryToLower = request.Query.ToLower();
dbQuery = dbQuery.Where(u => u.Email.ToLower().Contains(queryToLower) ||
u.LastName.ToLower().Contains(queryToLower) ||
u.FirstName.ToLower().Contains(queryToLower) ||
u.UserName.ToLower().Contains(queryToLower));
}
dbQuery = AdminQuerySorter.GetUsersSortQuery(dbQuery, request.OrderBy);
var totalNumberOfItems = await dbQuery.CountAsync();
var users = await dbQuery.Skip((request.PageNumber - 1) *request.PageSize).Take(request.PageSize).ToListAsync();
var usersWithRoles = Mapper.Map <List <ApplicationUser>, List <UserForGetUsersResponse> >(users);
foreach (var user in users)
{
var currentUserDto = usersWithRoles.Single(u => u.Id == user.Id);
var roles = await UserManager.GetRolesAsync(user);
currentUserDto.Roles = roles.ToList();
}
var response = new GetUsersResponse(request, usersWithRoles, totalNumberOfItems, request.OrderBy ?? GetUsersOrderBy.LastNameAsc);
return(new ServiceResponse <GetUsersResponse>(HttpStatusCode.OK, response));
}
public IActionResult Get(GetUsersRequest request)
{
var searchText = request.SearchText;
var pageIndex = request.PageIndex ?? 1;
var pageSize = request.PageSize ?? 9;
var sortCol = request.SortCol;
var sortOrder = request.SortOrder;
var users = _context.Users.Where(t => string.IsNullOrWhiteSpace(searchText) ||
t.Username.ToLower().Contains(searchText) ||
t.FullName.ToLower().Contains(searchText) ||
t.Email.ToLower().Contains(searchText));
var totalPageCount = (users.Count() + pageSize - 1) / pageSize;
if (sortOrder == "-")
{
if (sortCol == "username")
{
users = users.OrderByDescending(t => t.Username);
}
if (sortCol == "fullName")
{
users = users.OrderByDescending(t => t.FullName);
}
if (sortCol == "email")
{
users = users.OrderByDescending(t => t.Email);
}
}
else
{
if (sortCol == "username")
{
users = users.OrderBy(t => t.Username);
}
if (sortCol == "fullName")
{
users = users.OrderBy(t => t.FullName);
}
if (sortCol == "email")
{
users = users.OrderBy(t => t.Email);
}
}
users = users.Skip(pageSize * (pageIndex - 1)).Take(pageSize);
var response = new GetUsersResponse
{
Success = true,
TotalPageCount = totalPageCount,
Users = users.Select(t => new UserInfoDto {
Id = t.Id, Username = t.Username, FullName = t.FullName, Email = t.Email
}).ToList()
};
return(Ok(response));
}
public override Task <GetUsersResponse> GetUsers(Empty request, ServerCallContext context)
{
var response = new GetUsersResponse();
response.Users.AddRange(usersList);
return(Task.FromResult(response));
}
public async Task <GetUsersResponse> GetAllUsers()
{
var response = new GetUsersResponse();
var users = await _dataLogic.GetAll();
response.Users = Mapper.Map <List <UserResponseItem> >(users);
return(response);
}
public async Task <GetUsersResponse> GetUsersByQuery(string query)
{
var response = new GetUsersResponse();
var users = await _dataLogic.GetUsersByQuery(query);
response.Users = Mapper.Map <List <UserResponseItem> >(users);
return(response);
}
public async Task <GetUsersResponse> GetUsersAsync(GetUsersRequest request)
{
var result = new GetUsersResponse
{
Data = await this.userRepository.GetUsersAsync()
};
return(result);
}
public GetUsersResponse GetUsers(GetUsersRequest request)
{
var users = DataContext.Users.Include(u => u.Role).ToList();
var response = new GetUsersResponse();
response.Users = users.MapTo <GetUsersResponse.User>();
return(response);
}
/// <summary>
/// GetUsers's Logic
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <GetUsersResponse> GetUsers(GetUsersRequest request)
{
var response = new GetUsersResponse()
{
Success = true,
Data = UsersData.UsersDataInMem.ToList()
};
return(await Task.FromResult(response));
}
public override Task <GetUsersResponse> GetUsers(PagingRequest request, ServerCallContext context)
{
var pagingResult = _userDao.GetUserPaging(request.PageIndex, request.PageSize);
var res = new GetUsersResponse();
res.TotalCount = pagingResult.TotalCount;
res.Users.AddRange(pagingResult.List.Select(u => _mapper.Map <UserDTO>(u)));
return(Task.FromResult(res));
}
public override async Task <GetUsersResponse> GetUsers(GetUsersRequest request, ServerCallContext context)
{
List <User> foundUsers;
Guid id;
Guid customerId;
if (request.Id != null)
{
if (!Guid.TryParse(request.Id.Value, out id))
{
throw new RpcException(
Status.DefaultCancelled,
$"Could not parse {nameof(request.Id)}"
);
}
}
if (request.CustomerId != null)
{
if (!Guid.TryParse(request.CustomerId.Value, out customerId))
{
throw new RpcException(
Status.DefaultCancelled,
$"Could not parse {nameof(request.CustomerId)}"
);
}
}
using (var dbContext = new SecurityDbContext(this.securityDbContextOptions))
{
foundUsers = dbContext.Users.ToList();
}
var response = new GetUsersResponse
{
Users =
{
foundUsers.Select(x => new Security.API.User
{
Id = new Security.API.UUID{
Value = x.Id.ToString()
},
Username = x.Username,
Firstname = x.Firstname,
Lastname = x.Lastname,
CustomerId = new Security.API.UUID{
Value = x.CustomerId.ToString()
},
StatusId = x.StatusId,
})
}
};
return(await Task.FromResult(response));
}
public async Task GetUsers_ReturnsAllUsers()
{
// Arrange
var client = new Users.UsersClient(this.Channel);
// Act
GetUsersResponse response = await client.GetUsersAsync(new Empty());
// Assert
response.Users.Count.Should().Be(0);
}
public GetUsersResponse GetUsersByCriteria(GetUsersRequest request)
{
GetUsersResponse response = new GetUsersResponse();
SecurityBusinessComponent bc = DependencyInjectionHelper.GetSecurityBusinessComponent();
IQueryable <User> users = bc.GetUsersByCriteria(request.SearchType, request.Username, request.Rolename);
response.Users = SecurityAdapter.UsersToDtos(users);
return(response);
}
public async Task GetUsers_WhenUsersDoNotExist_ShouldReturnEmptyCollection()
{
// Arrange
var service = new UserHandlerV1(this._mockLogger.Object);
// Act
GetUsersResponse response = await service.GetUsers(new Empty(), TestServerCallContext.Create());
// Asserts
response.Users.Should().BeEmpty();
}
protected void Page_Load(object sender, EventArgs e)
{
try {
string action = Request ["action"];
int id;
if (!string.IsNullOrEmpty(action))
{
switch (action)
{
case "delete":
if (int.TryParse(Request ["id"], out id))
{
WebServiceResponse rsp = Master.WebService.DeleteUser(Master.WebServiceLogin, id);
if (rsp.Exception != null)
{
lblMessage.Text = Utils.FormatException(response.Exception.Message);
}
else
{
Response.Redirect("Users.aspx", false);
return;
}
}
else
{
lblMessage.Text = "Invalid id";
}
break;
}
}
response = Master.WebService.GetUsers(Master.WebServiceLogin);
if (response.Exception != null)
{
lblMessage.Text = Utils.FormatException(response.Exception.Message);
}
else if (response.Users != null)
{
foreach (DBPerson person in response.Users)
{
tblUsers.Rows.Add(Utils.CreateTableRow(
string.Format("<a href='User.aspx?username={0}'>{0}</a>", HttpUtility.HtmlEncode(person.login)),
HttpUtility.HtmlEncode(person.fullname),
HttpUtility.HtmlEncode(person.roles),
HttpUtility.HtmlEncode(person.password),
string.Format("<a href='Users.aspx?id={0}&action=delete'>Delete</a>", person.id)));
}
}
} catch (Exception ex) {
lblMessage.Text = Utils.FormatException(ex);
}
}
private async void HandleChangeTitleCmd(object sender, OnChatCommandReceivedArgs e)
{
if (!(sender is TwitchClient senderClient))
{
return;
}
if (!Extensions.IsHost(senderClient.TwitchUsername))
{
return;
}
string newTitle = e.Command.ArgumentsAsString;
if (newTitle == null || newTitle.Length <= 0)
{
return;
}
GetUsersResponse resp = await LeTwitchBot.BotAPI.Helix.Users.GetUsersAsync(null, new List <string> {
senderClient.TwitchUsername
});
if (resp.Users.Length <= 0)
{
return;
}
User user = resp.Users[0];
if (!user.DisplayName.ToLower().Equals(LeTwitchBot.HostChannelName.ToLower()))
{
return;
}
GetChannelInformationResponse existingInfo = await LeTwitchBot.BotAPI.Helix.Channels.GetChannelInformationAsync(user.Id);
if (existingInfo.Data.Length <= 0)
{
return;
}
ChannelInformation info = existingInfo.Data[0];
ModifyChannelInformationRequest changeReq = new ModifyChannelInformationRequest();
changeReq.BroadcasterLanguage = info.BroadcasterLanguage;
changeReq.Title = newTitle;
changeReq.GameId = info.GameId;
await LeTwitchBot.BotAPI.Helix.Channels.ModifyChannelInformationAsync(user.Id, changeReq, LeTwitchBot.Secrets.HostChannelUserToken);
LeTwitchBot.TwitchClient.SendHostChannelMessage($"Broadcaster {user.DisplayName} has changed the title of the stream to '{newTitle}' CoolCat CoolCat CoolCat CoolCat");
}
public async Task <IActionResult> GetUser(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "users")] HttpRequest req)
{
var result = await _usersService.GetUsersAsync();
var response = new GetUsersResponse
{
Users = result.Select(p => p.MapToUsersViewModel()).ToList()
};
return(new OkObjectResult(response));
}
public async Task <GetUsersResponse> GetUsers()
{
var response = new GetUsersResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
response.Users = await uow.UserRepo.GetUsers();
uow.Commit();
return(response);
}
}
public static GetUsersWebResponse AsWebResponse(this GetUsersResponse response)
{
var result = new GetUsersWebResponse
{
Errors = response.Errors,
Message = response.Message,
StatusCode = response.StatusCode,
IsSuccessful = response.IsSuccessful,
Data = response.Data
};
return(result);
}
private void FollowerServiceOnOnNewFollowersDetected(object sender, OnNewFollowersDetectedArgs eventArgs)
{
List <string> newFollowers = eventArgs.NewFollowers
.Where(f => f.FollowedAt > StartUpTime)
.Select(x => x.FromUserId)
.ToList();
if (newFollowers.Any())
{
GetUsersResponse getUsersResponse =
_twitchApi.Helix.Users.GetUsersAsync(newFollowers).Result;
OnNewFollower?.Invoke(sender, getUsersResponse.ToNewFollowerEventArgs());
}
}
public GetUsersResponse GetUsers(GetUsersRequest request)
{
var response = new GetUsersResponse();
try
{
response.Users = this.unitOfWork.UserRepository.Get(q => q.Select(x => new UserDto
{
UserName = x.UserName,
FirstName = x.FirstName,
LastName = x.LastName,
Email = x.Email
}));
response.Status = StatusCode.OK;
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Status = StatusCode.InternalServerError;
}
return response;
}
public GetUsersResponse SearchUsers(GetUsersRequest input)
{
GetUsersResponse response = new GetUsersResponse();
if (!this.ModelState.IsValid)
{
response.Status = new Status
{
Code = Status.INTERNAL_MESSAGE_CODE,
Message = this.ModelState.Values.First().Errors.First().ErrorMessage
};
return response;
}
if (input == null)
{
response.Status = Status.MISSING_PARRAMETERS;
return response;
}
////check for register user by Token
User currentUser = null;
try
{
currentUser = this.Users.SingleOrDefault(a => a.Token == input.Token); ////TOKEN must be unique
if (currentUser == null)
{
response.Status = Status.INVALID_TOKEN;
return response;
}
}
catch (Exception)
{
response.Status = Status.INTERNAL_ERROR;
return response;
}
List<User> allUsers = this.Users.Where(a => a.FanApps == currentUser.FanApps).AsQueryable().ToList();
List<UserModel> usersResponseList = new List<UserModel>();
foreach (User item in allUsers)
{
usersResponseList.Add(new UserModel
{
FirstName = item.FirstName,
LastName = item.LastName,
Email = item.Email
});
}
response.Status = Status.SUCCESS_FETCH_USERS;
response.Users = usersResponseList;
response.FanAppName = currentUser.FanApps;
return response;
}
