/// <summary>
/// Gets last 20 users
/// </summary>
/// <param name="search">Search string</param>
/// <returns>TwitterUserInfo list</returns>
public List <TwitterUserInfo> FindUsers(string search)
{
const int pageRowCount = 20;
const int pageNumber = 0;
try
{
Twitterizer.OAuthTokens tokens = GetOAuthTokens();
UserSearchOptions options = new UserSearchOptions();
options.Page = pageNumber;
options.NumberPerPage = pageRowCount;
TwitterResponse <TwitterUserCollection> userResponse = TwitterUser.Search(tokens, search, options);
if (userResponse.Result == RequestResult.Success)
{
TwitterUserCollection collection = userResponse.ResponseObject;
return(MapUsers(userResponse.ResponseObject));
}
else
{
throw CreateException(userResponse.Result, userResponse.ErrorMessage);
}
}
catch (Exception ex)
{
log.Error(ex);
throw;
}
}
public List <UserSearchResult> Match(User client, UserSearchOptions options)
{
List <UserSearchResult> results = new List <UserSearchResult>();
int age = client.Age;
List <User> users = _repository.Users.GetAllUsers().Where(x => (x.Country == options.Country || options.Country == "all") &&
(x.City == options.City || options.City == "Всі") && (options.MinAge <= age && age <= options.MaxAge) && x.TelephoneNumber != client.TelephoneNumber &&
(x.Sex == options.Sex || options.Sex == "all")).ToList();
if (options.Interests == null)
{
foreach (var user in users)
{
results.Add(Calculate(client, user));
}
return(results);
}
foreach (var user in users)
{
if (FilterInterests(user, options.Interests))
{
results.Add(Calculate(client, user));
}
}
return(results);
}
public async Task <UserSearchResponse[]> SearchAsync(UserSearchOptions options)
{
string url = apiUrl + USER_URL + options.GetSearchPartAddress();
string json = await GetSearchResponseAsync(url);
return(UserSearchResponse.FromJson(json));
}
/// <summary>
/// Initializes a new instance of the <see cref="UserSearchCommand"/> class.
/// </summary>
/// <param name="tokens">The request tokens.</param>
/// <param name="query">The query.</param>
/// <param name="options">The options.</param>
public UserSearchCommand(OAuthTokens tokens, string query, UserSearchOptions options)
: base(HttpMethod.Get, "users/search.json", tokens, options)
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException("query");
}
this.Query = query;
}
/// <inheritdoc />
public async Task <List <User> > Search(UserSearchOptions searchOptions)
{
var users = await Table.Where(user =>
(!searchOptions.Id.HasValue || user.Id == searchOptions.Id) &&
(String.IsNullOrWhiteSpace(searchOptions.Email) || searchOptions.Email == user.Email)
).ToListAsync();
return(users);
}
public IActionResult SearchPotentials(string num, [FromBody] UserSearchOptions options)
{
User user = _repository.Users.GetByNumber(num);
if (user == null)
{
return(NotFound());
}
var results = _matcher.Match(user, options);
return(Ok(results));
}
/// <summary>
/// Initializes a new instance of the <see cref="UserSearchCommand"/> class.
/// </summary>
/// <param name="tokens">The request tokens.</param>
/// <param name="query">The query.</param>
/// <param name="options">The options.</param>
public UserSearchCommand(OAuthTokens tokens, string query, UserSearchOptions options)
: base(HTTPVerb.GET, "users/search.json", tokens, options)
{
if (tokens == null)
{
throw new ArgumentNullException("tokens");
}
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException("query");
}
this.Query = query;
}
/// <summary>
/// Initializes the command.
/// </summary>
public override void Init()
{
this.RequestParameters.Add("q", this.Query);
UserSearchOptions options = this.OptionalProperties as UserSearchOptions;
if (options == null)
{
this.RequestParameters.Add("page", "1");
return;
}
if (options.NumberPerPage > 0)
{
this.RequestParameters.Add("per_page", options.NumberPerPage.ToString(CultureInfo.InvariantCulture));
}
this.RequestParameters.Add("page", options.Page > 0 ? options.Page.ToString(CultureInfo.InvariantCulture) : "1");
}
public async Task <SearchResult <User> > SearchUsersAsync(UserSearchOptions searchOptions)
{
var searchResult = new SearchResult <User>();
try
{
if (searchOptions == null)
{
return(searchResult);
}
var userQuery = _appDbContext.Users.AsQueryable();
if (searchOptions.Name.HasValue())
{
userQuery = userQuery.Where(x =>
x.FirstName.ToLowerInvariant().Contains(searchOptions.Name) ||
x.MiddleName.ToLowerInvariant().Contains(searchOptions.Name) ||
x.LastName.ToLowerInvariant().Contains(searchOptions.Name));
}
userQuery = userQuery.OrderBy(x => x.LastName);
searchResult.Page = searchOptions.Page;
searchResult.PageSize = searchOptions.PageSize;
searchResult.TotalResult = await userQuery.CountAsync();
searchResult.Result = UserEntityMapper.MapUsers(await userQuery.TakeItems(searchOptions.Page, searchOptions.PageSize).ToListAsync());
}
catch (Exception ex)
{
_logger.LogError(ex, $"[{ErrorCode.UserService003}] {ex.Message}");
}
return(searchResult);
}
public void InitializeUsers(IEnumerable <ForecastUserDto> newUsers)
{
UserSearchOptions.InitializeUsers(newUsers);
}
public async Task <IActionResult> Post([FromBody] UserSearchOptions userSearchOptions)
{
using (var repository = new Repository(HttpContext.GetUserGuid()))
{
if (!AuthorizeService.HashRight(repository.ServiceUser?.Role, Rights.ViewPlayer))
{
return(Forbid());
}
var query = repository.Context.Users.Include(x => x.Role).AsNoTracking();
if (!string.IsNullOrWhiteSpace(userSearchOptions.Search))
{
query = query.Where(x => x.Name.Contains(userSearchOptions.Search) || x.Email.Contains(userSearchOptions.Search));
}
if (userSearchOptions.IsVerified.HasValue)
{
var isVerified = userSearchOptions.IsVerified.Value;
query = query.Where(x => x.IsVerified == isVerified);
}
if (userSearchOptions.IsDisabled.HasValue)
{
var isDisabled = userSearchOptions.IsDisabled.Value;
query = query.Where(x => x.IsDisabled == isDisabled);
}
if (userSearchOptions.Role != null)
{
query = query.Where(x => x.Role.Guid == userSearchOptions.Role.Guid);
}
var totalCount = query.Count();
// default order by
if (string.IsNullOrWhiteSpace(userSearchOptions.OrderBy))
{
userSearchOptions.OrderBy = "Name";
}
var orderByType = QueryHelper.GetPropertyType <UserModel>(userSearchOptions.OrderBy);
if (orderByType != null)
{
if (orderByType == typeof(string))
{
var orderByExpression = QueryHelper.GetPropertyExpression <UserModel, string>(userSearchOptions.OrderBy);
query = userSearchOptions.ReverseOrder ? query.OrderByDescending(orderByExpression) : query.OrderBy(orderByExpression);
}
if (orderByType == typeof(int))
{
var orderByExpression = QueryHelper.GetPropertyExpression <UserModel, int>(userSearchOptions.OrderBy);
query = userSearchOptions.ReverseOrder ? query.OrderByDescending(orderByExpression) : query.OrderBy(orderByExpression);
}
if (orderByType == typeof(DateTime))
{
var orderByExpression = QueryHelper.GetPropertyExpression <UserModel, DateTime>(userSearchOptions.OrderBy);
query = userSearchOptions.ReverseOrder ? query.OrderByDescending(orderByExpression) : query.OrderBy(orderByExpression);
}
if (orderByType == typeof(bool))
{
var orderByExpression = QueryHelper.GetPropertyExpression <UserModel, bool>(userSearchOptions.OrderBy);
query = userSearchOptions.ReverseOrder ? query.OrderByDescending(orderByExpression) : query.OrderBy(orderByExpression);
}
}
userSearchOptions.PageSize = Math.Min(50, userSearchOptions.PageSize);
var userModels = await query.Skip((userSearchOptions.PageNumber - 1) *userSearchOptions.PageSize)
.Take(userSearchOptions.PageSize)
.ToListAsync();
var result = new ResultList <User>(userModels.Select(x => x.FromDal(true)).ToList())
{
TotalItems = totalCount,
SearchOptions = userSearchOptions
};
return(Ok(result));
}
}
public async Task <User> GetAsync(Action <UserSearchOptions> searchOptionsBuilder)
{
UserSearchOptions searchOptions = new UserSearchOptions();
searchOptionsBuilder(searchOptions);
IQueryable <User> users = userDbSet.AsQueryable <User>();
if (searchOptions.WithRole)
{
users = users.Include(u => u.Role);
}
if (searchOptions.WithRequests)
{
users = users.Include(u => u.Requests);
}
if (searchOptions.WithRequestImages)
{
users = users.Include(u => u.Requests).ThenInclude(r => r.Images);
}
if (searchOptions.WithRequestResponses)
{
users = users.Include(u => u.Requests).ThenInclude(r => r.Response);
}
if (searchOptions.WithResponseImages)
{
users = users.Include(u => u.Requests).ThenInclude(r => r.Response).ThenInclude(r => r.Images);
}
users = users.Select(u => new User()
{
UserId = u.UserId,
Email = u.Email,
Nickname = u.Nickname,
Role = u.Role,
Requests = u.Requests,
Password = searchOptions.WithPassword ? u.Password : null
});
User user = null;
switch (searchOptions.SearchType)
{
case UserSearchTypes.ById:
user = await users.FirstOrDefaultAsync(u => u.UserId == searchOptions.UserId);
if (user == null)
{
throw new UserNotFoundException($"Not found user with id equal {searchOptions.UserId}.");
}
break;
case UserSearchTypes.ByEmail:
user = await users.FirstOrDefaultAsync(u => u.Email == searchOptions.Email);
if (user == null)
{
throw new UserNotFoundException($"Not found user with email equal {searchOptions.Email}.");
}
break;
case UserSearchTypes.ByNickname:
user = await users.FirstOrDefaultAsync(u => u.Nickname == searchOptions.Nickname);
if (user == null)
{
throw new UserNotFoundException($"Not found user with nickname equal {searchOptions.Nickname}.");
}
break;
case UserSearchTypes.WithoutProperty:
break;
}
if (searchOptions.FromRequest.HasValue)
{
user.Requests = user.Requests.OrderByDescending(r => r.RequestId).Skip(searchOptions.FromRequest.Value).ToList();
}
if (searchOptions.RequestsCount.HasValue)
{
user.Requests = user.Requests.OrderByDescending(r => r.RequestId).Take(searchOptions.RequestsCount.Value).ToList();
}
return(user);
}
