private static UserSearchParams ConverToVkUserSearchParams(FilterModel filter)
{
var userSearchParams = new UserSearchParams()
{
AgeFrom = filter.Years != null ? (ushort)filter.Years.Min : default(ushort?),
AgeTo = filter.Years != null ? (ushort)filter.Years.Max : default(ushort?),
Country = GetCountryId(filter.Coutry), //!string.IsNullOrEmpty(filter.Coutry) ? GetCountryId(filter.Coutry) : default(int?),
City = GetCityId(filter.City), // !string.IsNullOrEmpty(filter.City) ? GetCityId(filter.City) : default(int?),
Sex = filter.Sex.HasValue ? (VkNet.Enums.Sex)filter.Sex : Sex.Unknown,
HasPhoto = filter.HasPhoto,
Online = filter.IsOnline,
Offset = (uint)filter.Offset,
Status = filter.FamilyStatus.HasValue
? (MaritalStatus)((int)filter.FamilyStatus.Value)
: default(MaritalStatus?),
Count = 1000,
};
if (filter.SortBy != SearchSortBy.None)
{
userSearchParams.Sort = filter.SortBy == SearchSortBy.ByDate? UserSort.ByRegDate : UserSort.ByPopularity;
}
return(userSearchParams);
}
private bool CheckIfOk(User user, UserSearchParams param)
{
bool isOk = true;
if (param.Username != null && param.Username != "")
{
if (!user.Username.ToLower().Equals(param.Username.ToLower()))
{
isOk = false;
}
}
if (param.Name != null && param.Name != "")
{
if (!param.Name.ToLower().Equals(user.Name.ToLower()))
{
isOk = false;
}
}
if (param.LastName != null && param.LastName != "")
{
if (!user.LastName.ToLower().Equals(param.LastName.ToLower()))
{
isOk = false;
}
}
return(isOk);
}
public ReadOnlyCollection<User> Search(out int itemsCount, UserSearchParams @params)
{
var response = _vk.Call("users.search", @params);
itemsCount = response["count"];
return response["items"].ToReadOnlyCollectionOf<User>(r => r);
}
public ReadOnlyCollection <User> Search(out int itemsCount, UserSearchParams @params)
{
var response = _vk.Call("users.search", @params, true);
itemsCount = response["count"];
return(response["items"].ToReadOnlyCollectionOf <User>(r => r));
}
public ReadOnlyCollection <User> Search(out int itemsCount, UserSearchParams @params)
{
var response = Search(@params);
itemsCount = Convert.ToInt32(response.TotalCount);
return(response.ToReadOnlyCollection());
}
public async Task <List <UserExtended> > Search(UserSearchParams parameters)
{
using (var api = _apiFactory.CreateVkApi())
{
var searchResult = await api.Users.SearchAsync(parameters);
return(searchResult.Select(x => new UserExtended(x)).ToList());
}
}
public ReadOnlyCollection <User> Search(out int itemsCount, UserSearchParams @params)
{
if (string.IsNullOrWhiteSpace(@params.Query))
{
throw new ArgumentException("Query can not be null or empty.");
}
var response = _vk.Call("users.search", @params);
itemsCount = response["count"];
return(response["items"].ToReadOnlyCollectionOf <User>(r => r));
}
public async Task <IActionResult> Search(string username, string name, string lastName)
{
if (string.IsNullOrWhiteSpace(username) && string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(lastName))
{
return(BadRequest(new { Message = "Invalid parameters supplied." }));
}
var param = new UserSearchParams {
LastName = lastName, Name = name, Username = username
};
var ret = await service.Search(param);
return(Ok(mapper.Map <IEnumerable <UserResource> >(ret)));
}
public ReadOnlyCollection <User> Search(out int itemsCount, UserSearchParams @params)
{
if (string.IsNullOrWhiteSpace(@params.Query))
{
throw new ArgumentException("Query can not be null or empty.");
}
var parameters = new VkParameters
{
{ "q", @params.Query },
{ "sort", @params.Sort },
{ "offset", @params.Offset },
{ "count", @params.Count },
{ "fields", @params.Fields },
{ "city", @params.City },
{ "country", @params.Country },
{ "hometown", @params.Hometown },
{ "university_country", @params.UniversityCountry },
{ "university", @params.University },
{ "university_year", @params.UniversityYear },
{ "university_faculty", @params.UniversityFaculty },
{ "university_chair", @params.UniversityChair },
{ "sex", @params.Sex },
{ "status", @params.Status },
{ "age_from", @params.AgeFrom },
{ "age_to", @params.AgeTo },
{ "birth_day", @params.BirthDay },
{ "birth_month", @params.BirthMonth },
{ "birth_year", @params.BirthYear },
{ "online", @params.Online },
{ "has_photo", @params.HasPhoto },
{ "school_country", @params.SchoolCountry },
{ "school_city", @params.SchoolCity },
{ "school_class", @params.SchoolClass },
{ "school", @params.School },
{ "school_year", @params.SchoolYear },
{ "religion", @params.Religion },
{ "interests", @params.Interests },
{ "company", @params.Company },
{ "position", @params.Position },
{ "group_id", @params.GroupId },
{ "from_list", @params.FromList }
};
var response = _vk.Call("users.search", parameters);
itemsCount = response["count"];
return(response["items"].ToReadOnlyCollectionOf <User>(r => r));
}
private static async Task <List <UserExtended> > GetUsersFromCityForBackgroundWork()
{
var cityId = _cityIds.FirstOrDefault();
var param = new UserSearchParams
{
Sex = Sex.Male,
City = cityId,
Sort = UserSort.ByRegDate,
Fields = GetProfileFields(),
Count = 1000,
AgeFrom = MinAge,
AgeTo = MaxAge
};
var res = await _userService.Search(param);
res = res.Where(x => !x.BlackListed()).Select(x => x).ToList();
return(res);
}
public AddWindow(Client user)
{
clientId = user.Id;
InitializeComponent();
var api = new VkApi();
context = new MyDbContext();
api.Authorize(new ApiAuthParams
{
ApplicationId = 123456,
Login = "******",
Password = "******",
Settings = Settings.All
});
searchParam = new UserSearchParams();
vk = api;
searchUsers = new BindingList <User>();
}
private async Task <List <UserExtended> > SearchUsers(AgeRange ageRange, int cityId)
{
var searchParams = new UserSearchParams
{
AgeFrom = (ushort?)ageRange.Min,
AgeTo = (ushort?)ageRange.Max,
Status = MaritalStatus.Single,
Sex = Sex.Female,
HasPhoto = true,
Sort = UserSort.ByRegDate,
Fields = GetFields(),
Count = 1000,
Country = 1,
City = cityId
//Online = true
};
var users = await _userService.Search(searchParams);
return(users);
}
public async Task <IEnumerable <BookingAppBackend.Model.Users.User> > Search(UserSearchParams param)
{
return(await repo.Search(param));
}
public VkCollection <User> Search(UserSearchParams @params)
{
return(_vk.Call("users.search", @params, false).ToVkCollectionOf <User>(r => r));
}
public VkCollection <User> Search(UserSearchParams @params)
{
return(_vk.Call(methodName: "users.search", parameters: @params).ToVkCollectionOf <User>(selector: r => r));
}
/// <inheritdoc />
public Task <VkCollection <User> > SearchAsync(UserSearchParams @params)
{
return(TypeHelper.TryInvokeMethodAsync(func: () => _vk.Users.Search(@params: @params)));
}
public static List <PersonModel> GetPersons(FilterModel filter)
{
UserSearchParams userSearchParams = ConverToVkUserSearchParams(filter);
userSearchParams.Fields = ProfileFields.All | ProfileFields.Counters;
var peoples = api.Users.Search(userSearchParams);
var unbannedUsers = peoples.Where(x => !Bans.Contains(x.Domain));
var canWrite = unbannedUsers.Where(x => x.CanWritePrivateMessage && !x.Blacklisted);
var niceGrills = canWrite.Where(x => IsNormalGrill(x));
var myFilteredPeople = niceGrills.ToList();
// Если не задали условия по количеству друзей и падпинчикиов.
if (filter.FriendsCount == null && filter.SubsCount == null)
{
return(myFilteredPeople.Select(x => new PersonModel(x)).ToList());
}
// Иначе молиться Богам, чтобы нас не зобанили.
var userCounters = new Dictionary <User, Counters>();
foreach (var ppl in myFilteredPeople)
{
var counters = api.Users.Get(new long[] { ppl.Id }, ProfileFields.Counters).FirstOrDefault().Counters;
userCounters.Add(ppl, counters);
}
foreach (var userCounter in userCounters)
{
userCounter.Key.Counters = userCounter.Value;
}
myFilteredPeople = userCounters.Keys.ToList();
IEnumerable <User> users = myFilteredPeople;
if (filter.FriendsCount != null)
{
users = users.Where(x =>
x.Counters.Friends.HasValue
? x.Counters.Friends.Value >= filter.FriendsCount.Min
: true);
users = users.Where(x =>
x.Counters.Friends.HasValue
? x.Counters.Friends.Value <= filter.FriendsCount.Max
: true);
}
if (filter.SubsCount != null)
{
users = users.Where(x =>
x.Counters.Followers.HasValue
? x.Counters.Followers.Value >= filter.SubsCount.Min
: true);
users = users.Where(x =>
x.Counters.Followers.HasValue
? x.Counters.Followers.Value <= filter.SubsCount.Max
: true);
}
return(users.Select(x => new PersonModel(x)).ToList());
}
public VkCollection<User> Search(UserSearchParams @params)
{
return _vk.Call("users.search", @params, false).ToVkCollectionOf<User>(r => r);
}
public async Task <IEnumerable <User> > Search(UserSearchParams param)
{
var temp = await context.RegisteredUsers.ToListAsync();
return(temp.Where(i => CheckIfOk(i, param)));
}
public ReadOnlyCollection<User> Search(out int itemsCount, UserSearchParams @params)
{
if (string.IsNullOrWhiteSpace(@params.Query))
{
throw new ArgumentException("Query can not be null or empty.");
}
var response = _vk.Call("users.search", @params);
itemsCount = response["count"];
return response["items"].ToReadOnlyCollectionOf<User>(r => r);
}
