private IEnumerator RequestToken(string keyword, SafeSearch safeSearch, Action <string> tokenCallback)
{
var requestUrl = $"{url}?q={keyword}";
// Debug.Log(requestUrl);
var ao = UnityWebRequest.Get(requestUrl).SendWebRequest();
yield return(new WaitUntil(() => ao.isDone));
if (ao.webRequest.isNetworkError || ao.webRequest.isHttpError)
{
Debug.LogError("Requesting Failed ! " + ao.webRequest.error);
tokenCallback.Invoke(null);
yield break;
}
Regex regex = new Regex(@"vqd=([\d-]+)\&");
var match = regex.Match(ao.webRequest.downloadHandler.text);
if (!match.Success)
{
Debug.LogError("Token Parsing Failed !");
tokenCallback.Invoke(null);
yield break;
}
var searchObj = match.Groups[1];
tokenCallback.Invoke(match.Groups[1].Value);
}
public static YoutubeSearch SafeSearch(this YoutubeSearch search, SafeSearch s)
{
var settings = search.Settings.Clone();
settings.SafeSearch = s;
return(Search(settings));
}
public async Task SearchNotEmptyTest(string keywords, SafeSearch filter)
{
// Act
var results = await DdgApi.SearchImagesAsync(keywords, filter);
// Assert
Assert.NotEmpty(results.Results);
}
public static void Search(string text, SafeSearch safeSearch, int pageNo, string location, Action <ImageSearchResult> onCompleted)
{
if (!instance)
{
instance = new GameObject("DuckDuckGoAPI").AddComponent <Arikan.Duckduckgo.Api.ImagesApi>();
}
if (string.IsNullOrWhiteSpace(location))
{
location = "us-en";
}
instance.SearchFromInstance(text, safeSearch, pageNo, location, onCompleted);
}
public string GetImageUrl(
string searchTerm,
int?height = null,
AspectRatio aspectRatio = AspectRatio.All,
SafeSearch safeSearch = SafeSearch.Moderate,
ImageType imageType = ImageType.Photo,
ImageSize imageSize = ImageSize.Medium,
ImageFreshness imageFreshness = ImageFreshness.Year)
{
//validate search term
if (string.IsNullOrWhiteSpace(searchTerm))
{
return(null);
}
//Construct the URI of the search request
var uriQuery = UriBase + "?count=1&offset=0" +
(height.HasValue ? $"&height={height}" : "") +
$"&aspect={aspectRatio}" +
$"&safeSearch={safeSearch}" +
$"&imageType={imageType}" +
$"&size={imageSize}" +
$"&freshness={imageFreshness}" +
$"&q={Uri.EscapeDataString(searchTerm)}";
//make a RESTful call to Bing...
using (var httpClient = new HttpClient())
{
//add subscription to header
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", SubscriptionKey);
//make request
var response = httpClient.GetAsync(uriQuery).Result;
//check status or throw exception
if (!response.IsSuccessStatusCode)
{
return(null);
}
//get response as JSON
var json = response.Content.ReadAsStringAsync().Result;
//deserialize the resulting json
var searchResult = JsonConvert.DeserializeObject <SearchResult>(json);
//get content URL
return(searchResult?.value?.ElementAtOrDefault(0)?.contentUrl);
}
}
private IEnumerator SearchCoRo(string keyword, SafeSearch safeSearch, int pageNo, string location, Action <ImageSearchResult> onCompleted)
{
string token = lastSearch.Value;
if (lastSearch.Key != keyword)
{
// Debug.Log("Requesting new Token...");
yield return(RequestToken(keyword, safeSearch, (t) => token = t));
lastSearch = new KeyValuePair <string, string>(keyword, token);
}
// Debug.Log("SrcOb:" + currentToken);
yield return(RequestSearchResult(keyword, token, safeSearch, pageNo, location, onCompleted));
}
public async Task <WebSearchResponse> SearchWeb(string query, SafeSearch safeSearch)
{
string endpoint = string.Format("{0}{1}&safeSearch={2}&count=5&mkt=en-US", "https://api.cognitive.microsoft.com/bing/v5.0/search?q=", query, safeSearch.ToString());
try
{
WebSearchResponse response = await _webRequest.MakeRequest <WebSearchResponse>(endpoint);
return(response);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(null);
}
/// <summary>
/// Safe search to string.
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public string SafeSearchToString(SafeSearch s)
{
switch (s)
{
case SafeSearch.active:
return("active");
case SafeSearch.moderate:
return("moderate");
case SafeSearch.off:
return("off");
default:
return(string.Empty);
}
}
public string ImageSearch(string apiKey, string term, SafeSearch safeSearch)
{
var client = new RestClient("https://api.datamarket.azure.com/Bing/Search/v1/")
{
Authenticator = new HttpBasicAuthenticator(apiKey, apiKey)
};
var action = new RestRequest("Image", Method.GET);
action.AddParameter("Query", "'" + term + "'")
.AddParameter("$format", "json")
.AddParameter("$top", "50")
.AddParameter("Adult", "'" + safeSearch + "'");
var result = client.Execute(action);
return result.Content;
}
private IEnumerator RequestSearchResult(string keyword, string token, SafeSearch safeSearch, int pageNo, string location, Action <ImageSearchResult> callback)
{
pageNo = Mathf.Clamp(pageNo, 1, int.MaxValue);
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ "l", location },
{ "o", "json" },
{ "q", keyword },
{ "vqd", token },
{ "f", ",,,,," },
{ "s", ((pageNo - 1) * 100).ToString() },
{ "p", safeSearch == SafeSearch.Off ? "-1" : "1" },
{ "v7exp", "a" },
};
string requestUrl = url
+ "i.js?"
+ string.Join("&", parameters.Select(kv => kv.Key + "=" + kv.Value));
// Debug.Log(requestUrl);
var request = UnityWebRequest.Get(requestUrl);
foreach (var kv in headers)
{
// Debug.Log(kv.Key);
request.SetRequestHeader(kv.Key, kv.Value);
}
var ao = request.SendWebRequest();
yield return(new WaitUntil(() => ao.isDone));
if (ao.webRequest.isNetworkError || ao.webRequest.isHttpError)
{
Debug.LogError("Searching Failed ! " + ao.webRequest.error);
isLastRequestSuccessfull = false;
callback.Invoke(null);
yield break;
}
isLastRequestSuccessfull = true;
// Debug.Log(ao.webRequest.downloadHandler.text);
var result = JsonUtility.FromJson <ImageSearchResult>(ao.webRequest.downloadHandler.text);
callback.Invoke(result);
}
public static async Task <DdgResponse> SearchImagesAsync(string keywords, SafeSearch filter = SafeSearch.Moderate)
{
if (keywords.Length > MaxLength)
{
throw new ArgumentOutOfRangeException(nameof(keywords), $"The query cannot be larger than {MaxLength}.");
}
string token = await GetTokenAsync(keywords);
string query = "?";
query += "l=us-en";
query += "&o=json";
query += $"&q={Uri.EscapeDataString(keywords)}";
query += $"&vqd={token}";
query += "&f=,,,";
query += $"&p={(filter == SafeSearch.Off ? "-1" : "1")}";
//query += $"&p={(filter == SafeSearch.Strict || filter == SafeSearch.Moderate ? "1" : "-1")}";
query += "&v7exp=a";
string content;
using (var requestMessage = GenerateRequestMessage(HttpMethod.Get, new Uri($"i.js{query}", UriKind.Relative)))
{
if (filter == SafeSearch.Strict)
{
requestMessage.Headers.Add("cookie", "p=1");
}
else if (filter == SafeSearch.Off)
{
requestMessage.Headers.Add("cookie", "p=-2");
}
var response = await _client.SendAsync(requestMessage);
response.EnsureSuccessStatusCode();
content = await response.Content.ReadAsStringAsync();
}
return(JsonConvert.DeserializeObject <DdgResponse>(content));
}
/// <summary>
/// Takes the various properties of this instance and adds them to a <see cref="Dictionary{K,V}"/> instanced passed in, ready for sending to Flickr.
/// </summary>
/// <param name="parameters">The <see cref="Dictionary{K,V}"/> to add the options to.</param>
public void AddToDictionary(Dictionary <string, string> parameters)
{
if (!string.IsNullOrEmpty(UserId))
{
parameters.Add("user_id", UserId);
}
if (!string.IsNullOrEmpty(GroupId))
{
parameters.Add("group_id", GroupId);
}
if (!string.IsNullOrEmpty(Text))
{
parameters.Add("text", Text);
}
if (!string.IsNullOrEmpty(Tags))
{
parameters.Add("tags", Tags);
}
if (TagMode != TagMode.None)
{
parameters.Add("tag_mode", UtilityMethods.TagModeToString(TagMode));
}
if (!string.IsNullOrEmpty(MachineTags))
{
parameters.Add("machine_tags", MachineTags);
}
if (MachineTagMode != MachineTagMode.None)
{
parameters.Add("machine_tag_mode", UtilityMethods.MachineTagModeToString(MachineTagMode));
}
if (MinUploadDate != DateTime.MinValue)
{
parameters.Add("min_upload_date", UtilityMethods.DateToUnixTimestamp(MinUploadDate).ToString());
}
if (MaxUploadDate != DateTime.MinValue)
{
parameters.Add("max_upload_date", UtilityMethods.DateToUnixTimestamp(MaxUploadDate).ToString());
}
if (MinTakenDate != DateTime.MinValue)
{
parameters.Add("min_taken_date", UtilityMethods.DateToMySql(MinTakenDate));
}
if (MaxTakenDate != DateTime.MinValue)
{
parameters.Add("max_taken_date", UtilityMethods.DateToMySql(MaxTakenDate));
}
if (Licenses.Count != 0)
{
var licenseArray = new List <string>();
foreach (var license in Licenses)
{
licenseArray.Add(license.ToString("d"));
}
parameters.Add("license", String.Join(",", licenseArray.ToArray()));
}
if (PerPage != 0)
{
parameters.Add("per_page", PerPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Page != 0)
{
parameters.Add("page", Page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Extras != PhotoSearchExtras.None)
{
parameters.Add("extras", ExtrasString);
}
if (SortOrder != PhotoSearchSortOrder.None)
{
parameters.Add("sort", SortOrderString);
}
if (PrivacyFilter != PrivacyFilter.None)
{
parameters.Add("privacy_filter", PrivacyFilter.ToString("d"));
}
if (BoundaryBox != null && BoundaryBox.IsSet)
{
parameters.Add("bbox", BoundaryBox.ToString());
}
if (Accuracy != GeoAccuracy.None)
{
parameters.Add("accuracy", Accuracy.ToString("d"));
}
if (SafeSearch != SafetyLevel.None)
{
parameters.Add("safe_search", SafeSearch.ToString("d"));
}
if (ContentType != ContentTypeSearch.None)
{
parameters.Add("content_type", ContentType.ToString("d"));
}
if (HasGeo != null)
{
parameters.Add("has_geo", HasGeo.Value ? "1" : "0");
}
if (Latitude != null)
{
parameters.Add("lat", Latitude.Value.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Longitude != null)
{
parameters.Add("lon", Longitude.Value.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Radius != null)
{
parameters.Add("radius", Radius.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (RadiusUnits != RadiusUnit.None)
{
parameters.Add("radius_units", (RadiusUnits == RadiusUnit.Miles ? "mi" : "km"));
}
if (Contacts != ContactSearch.None)
{
parameters.Add("contacts", (Contacts == ContactSearch.AllContacts ? "all" : "ff"));
}
if (WoeId != null)
{
parameters.Add("woe_id", WoeId);
}
if (PlaceId != null)
{
parameters.Add("place_id", PlaceId);
}
if (IsCommons)
{
parameters.Add("is_commons", "1");
}
if (InGallery)
{
parameters.Add("in_gallery", "1");
}
if (IsGetty)
{
parameters.Add("is_getty", "1");
}
if (MediaType != MediaType.None)
{
parameters.Add("media", UtilityMethods.MediaTypeToString(MediaType));
}
if (GeoContext != GeoContext.NotDefined)
{
parameters.Add("geo_context", GeoContext.ToString("d"));
}
if (Faves)
{
parameters.Add("faves", "1");
}
if (PersonId != null)
{
parameters.Add("person_id", PersonId);
}
if (Camera != null)
{
parameters.Add("camera", Camera);
}
if (JumpTo != null)
{
parameters.Add("jump_to", JumpTo);
}
}
/// <summary>
/// Search web pages with Bing service
/// </summary>
public async Task <BingWebSearchResult> SearchWebAsync(string query, int count = 10, int offset = 0, string market = "en-us", SafeSearch safeSearch = SafeSearch.Strict)
{
if (string.IsNullOrEmpty(query) == true)
{
return(default(BingWebSearchResult));
}
else if (query.Length > MAX_QUERY_LENGTH)
{
query = query.Substring(0, MAX_QUERY_LENGTH);
}
query = WebUtility.UrlEncode(query);
// Get request uri
string searchUrl = string.Format(this.BaseServiceUrl + "search?q={0}&count={1}&offset={2}&mkt={3}&safesearch={4}", query, count, offset, market, safeSearch);
Uri requestUri = new Uri(searchUrl);
// Get response
BingWebSearchResult result = await HttpClientUtility.GetAsync <BingWebSearchResult>(requestUri, this.RequestHeaders);
return(result);
}
private void SearchFromInstance(string text, SafeSearch safeSearch, int pageNo, string location, Action <ImageSearchResult> onCompleted)
{
StartCoroutine(SearchCoRo(text, safeSearch, pageNo, location, onCompleted));
}
