/// <summary>
/// Gets a specific comment from the Snippet by Note ID
/// </summary>
/// <param name="_Config">The _ configuration.</param>
/// <param name="_Project">The _ projet.</param>
/// <param name="_Snippet">The _ snippet.</param>
/// <param name="_ID">The _ identifier.</param>
/// <returns></returns>
public static Note GetComment(Config _Config, Project _Project, Snippet _Snippet, int _ID)
{
string URI = _Config.APIUrl + "projects/" + _Project.id.ToString() + "/snippets/" + _Snippet.id.ToString() + "/notes/" + _ID.ToString();
HttpResponse <string> R = Unirest.get(URI)
.header("accept", "application/json")
.header("PRIVATE-TOKEN", _Config.APIKey)
.asString();
if (R.Code < 200 || R.Code >= 300)
{
throw new GitLabServerErrorException(R.Body, R.Code);
}
else
{
return(JsonConvert.DeserializeObject <Note>(R.Body));
}
}
public JsonRecipe GetRecipe(string ingredients)
{
// create url by passing in parameters
string url = "https://spoonacular-recipe-food-nutrition-v1.p.mashape.com/recipes/findByIngredients?";
string param_fillIngredients = "false";
string param_ingredients = ingredients;
string param_limitLicense = "false";
string param_number = "1";
string param_ranking = "1";
// Request query string.
var queryString = HttpUtility.ParseQueryString(string.Empty);
queryString["fillIngredients"] = param_fillIngredients;
queryString["ingredients"] = ingredients;
queryString["limitLicense"] = param_limitLicense;
queryString["number"] = param_number;
queryString["ranking"] = param_ranking;
var uri = url + queryString;
// "https://spoonacular-recipe-food-nutrition-v1.p.mashape.com/recipes/findByIngredients?fillIngredients=false&ingredients=apples%2Cflour%2Csugar&limitLicense=false&number=5&ranking=1"
// These code snippets use an open-source library.
HttpResponse <MemoryStream> responseAPI = Unirest.get(uri)
.header("X-Mashape-Key", APIKeys.Mashape_Key_Kevin)
.header("Accept", "application/json")
.asJson <MemoryStream>();
// System.IO.MemoryStream encoding to string
StreamReader reader = new StreamReader(responseAPI.Body);
string json = reader.ReadToEnd();
// Remove extra brackets on JSON string
// Unsure if API is returning extra brackets or if StreamReader is adding
json = json.TrimStart('[');
json = json.TrimEnd(']');
// Deserialize json string into an object instance
JsonRecipe recipeResult = new JsonRecipe();
JsonConvert.PopulateObject(json, recipeResult);
return(recipeResult);
}
// This code matches the HTTP Request that we included in our api controller
public async Task <bool> checkLogin(string username, string password)
{
var httpClient = new HttpClient();
// http://MainHost/api/UserCredentials/username=foo/password=foo. The api value and response value should match in order to return a true status code.
var response = await httpClient.GetAsync(LoginWebServiceUrl + "studentID=" + username + "/" + "password="******"studentID=" + username + "/" + "password=" + password)
.asJsonAsync <string>();
var obj = JsonConvert.DeserializeObject <Users>(response2.Result.Body);
SessionUserCredentials.Name = obj.Name;
SessionUserCredentials.Points = Convert.ToInt32(obj.Points);
SessionUserCredentials.Team = obj.Team;
SessionUserCredentials.Id = obj.Id;
}
return(response.IsSuccessStatusCode); // return either true or false
}
public async Task <bool> checkRegister(string username, string password, string name)
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(RegisterWebServiceUrl + "studentID=" + username + "/" + "password="******"/" + "name=" + name);
if (response.IsSuccessStatusCode)
{
Task <HttpResponse <string> > response2 = Unirest.get(LoginWebServiceUrl + "studentID=" + username + "/" + "password=" + password)
.asJsonAsync <string>();
var obj = JsonConvert.DeserializeObject <Users>(response2.Result.Body);
SessionUserCredentials.Name = obj.Name;
SessionUserCredentials.Points = Convert.ToInt32(obj.Points);
SessionUserCredentials.Team = obj.Team;
SessionUserCredentials.Id = obj.Id;
}
return(response.IsSuccessStatusCode);
}
/// <summary>
/// The listCountry operation allows you to search for countries available in the Voxbone coverage.
/// </summary>
/// <param name="pageNumber">Required parameter: The page number, starting at 0.</param>
/// <param name="pageSize">Required parameter: The page size (max number of entities that are displayed in the response).</param>
/// <param name="countryCodeA3">Optional parameter: The three letter identifier of the country.</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> ListCountryAsync(
string pageNumber,
string pageSize,
string countryCodeA3 = null)
{
//the base uri for api requests
string baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/services/rest/inventory/country");
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>()
{
{ "pageNumber", pageNumber },
{ "pageSize", pageSize },
{ "countryCodeA3", countryCodeA3 }
});
//validate and preprocess url
string queryUrl = APIHelper.CleanUrl(queryBuilder);
//prepare and invoke the API call request to fetch the response
HttpRequest request = Unirest.get(queryUrl)
//append request with appropriate headers and parameters
.header("User-Agent", "APIMATIC 2.0")
.header("Accept", "application/json")
.basicAuth(basicAuthUserName, basicAuthPassword);
//invoke request and get response
HttpResponse <String> response = await request.asStringAsync();
//Error handling using HTTP status codes
if ((response.Code < 200) || (response.Code > 206)) //[200,206] = HTTP OK
{
throw new APIException(@"HTTP Response Not OK", response.Code);
}
return(APIHelper.JsonDeserialize <dynamic>(response.Body));
}
private void playZingMp3(String zingUrl)
{
zingUrl = zingUrl.Replace(".html", "");
String musicId = zingUrl.Substring(zingUrl.LastIndexOf("/") + 1);
HttpResponse <String> response =
Unirest.get("http://api.mp3.zing.vn/api/mobile/song/getsonginfo?requestdata={%22id%22:%22" + musicId +
"%22}")
.asString();
JObject jsonResponse = JObject.Parse(response.Body);
String fileName = jsonResponse.GetValue("title").Value <String>();
JToken token = jsonResponse.GetValue("source");
String downloadUrl = JObject.Parse(token.ToString()).GetValue("320").Value <String>();
windowMedia.URL = downloadUrl;
windowMedia.Ctlcontrols.play();
}
public async Task Execute(object a, Message m)
{
var url = "http://www.runescape.com/player_count.js?varname=iPlayerCount&callback=jQuery000000000000000_0000000000&_=0";
HttpResponse <string> r = await Unirest.get(url)
.asStringAsync();
// Checking if the request was successful
if (r.Code < 200 || r.Code > 299)
{
await m.Channel.SendMessage($"Error code **{r.Code}** was returned from the server.");
return;
}
// Getting number
var jsonReadable = Regex.Match(r.Body, @"jQuery000000000000000_0000000000\((\d+?)\)").Groups[1].Value.ToInt();
await m.Channel.SendMessage($"**{jsonReadable.ToString("#,##0")}** players online");
}
public bool GetTokenAccess(string email, string password)
{
bool resultado = true;
string respuesta = string.Empty;
HttpResponse <string> response = Unirest.get("https://login.microsoftonline.com/common/login").basicAuth(email, password).asJson <string>();
if (response.Code == 200)
{
respuesta = response.Body;
}
else
{
resultado = false;
}
return(resultado);
}
public static void RebuildAlbum()
{
Cursor.Current = Cursors.WaitCursor;
album = ConfigurationSettings.AppSettings["Album"];
albumKey = ConfigurationSettings.AppSettings["AlbumKey"];
mashapeAuthKey = ConfigurationSettings.AppSettings["MashapeAuthKey"];
HttpResponse <string> response = Unirest.get("https://lambda-face-recognition.p.mashape.com/album_rebuild?album=" + album + "&albumkey=" + albumKey)
.header("X-Mashape-Authorization", mashapeAuthKey)
.asString();
JavaScriptSerializer jss = new JavaScriptSerializer();
var output = jss.Deserialize <dynamic>(response.Body);
Cursor.Current = Cursors.Default;
MessageBox.Show(response.Body);
}
public static string Get(string url, string myToken)
{
string body = "";
try {
HttpResponse <string> jsonReponse = Unirest.get(url)
.header("accept", "application/json")
.header("Authorization", "Bearer " + myToken)
.asJson <string>();
body = jsonReponse.Body.ToString();
return(body);
}
catch (Exception ex) {
//log.WriteLine(ex);
//log.Flush();
Console.WriteLine(ex);
return(body);
}
}
public static void Main(string[] args)
{
Console.WriteLine("Start ...");
//the added Wait() causes the thread to hold until the task is finished.
Task <HttpResponse <MyClass.RootObject> > response = Unirest.get("https://api-nba-v1.p.rapidapi.com/gameDetails/5162")
.header("X-RapidAPI-Host", "api-nba-v1.p.rapidapi.com")
.header("X-RapidAPI-Key", "myKey")
.asJsonAsync <MyClass.RootObject>();
//if need to perform other logic while you are waiting
while (response.Status == TaskStatus.Running)
{
// perform other logic like gui here
}
var status = response.Status;
Console.WriteLine("End ....");
}
public List <Media> GetMedias(string username, int count = 20, string maxId = null)
{
string endpoint = Endpoints.ACCOUNT_MEDIAS.Replace("{username}", username).Replace("{count}", count.ToString());
List <Media> medias = new List <Media>();
bool isMoreAvailable = true;
while (isMoreAvailable)
{
// pass in maxId, if this is a loop from moreAvailable, the maxId will be the oldest post in the previous pass
HttpResponse <string> response = Unirest.get(endpoint.Replace("{max_id}", maxId)).asString();
// if http response is success, we will continue, if not, we cannot do much more so we will just say no more available
// and return whatever we currently have
if (response.Code == 200)
{
MediaResponse mediaResponse = JsonConvert.DeserializeObject <MediaResponse>(response.Body);
// the instagram response also has a status, if ok continue
if (mediaResponse.status == "ok")
{
medias.AddRange(mediaResponse.items);
// Assumption: more_available will be false if there are ever less than specified COUNT items returned
// as long as that variable is correctly set, we exit the loop
// If there is at least one entry, we will capture the oldest one's id and set that as maxId in case
// we need to do another pass in the while loop
if (mediaResponse.items.Count() > 0)
{
maxId = mediaResponse.items.OrderBy(i => i.CreateDate).First().Id;
}
}
isMoreAvailable = mediaResponse.more_available;
}
else
{
isMoreAvailable = false;
}
}
return(medias);
}
private List <string> GetVideos(int prodId)
{
string endpoint = Startup.SettingFactory()["IGDB:endpoint"];
string userkey = Startup.SettingFactory()["IGDB:user-key"];
List <string> retVal = new List <string>();
string url = "https://api-" + endpoint + ".apicast.io/games/";
Task <HttpResponse <string> > jsonResponse = Unirest.get(url + prodId + "?fields=videos")
.header("user-key", userkey)
.header("Accept", "application/json")
.asJsonAsync <string>();
var x = jsonResponse.Result.Body;
var model = JsonConvert.DeserializeObject <List <Root> >(jsonResponse.Result.Body);
if (model[0].videos != null && model[0].videos.Count() > 0)
{
retVal = model[0].videos.AsQueryable().Select(video => "https://www.youtube.com/embed/" + video.video_id).ToList();
}
return(retVal);
}
public static void Main(string[] args)
{
Console.WriteLine("Start of Program...");
HttpResponse <string> response = Unirest.get("https://api-nba-v1.p.rapidapi.com/gameDetails/9999")
.header("X-RapidAPI-Host", "api-nba-v1.p.rapidapi.com")
.header("X-RapidAPI-Key", "myKey")
.asJson <string>();
var result = response.Body;
JObject parsedString = JObject.Parse(result);
RootObject myGame = parsedString.ToObject <RootObject>();
// Get game id
Console.WriteLine(myGame.results[0].gameId);
Console.WriteLine("End of Program....");
}
private SpoonProductInformation GetSpoonItem(int spoonacularProductId)
{
string url = $"https://spoonacular-recipe-food-nutrition-v1.p.rapidapi.com/food/products/{spoonacularProductId}";
HttpResponse <string> response = Unirest.get(url)
.header("X-RapidAPI-Key", "aJW3b5eOp7mshOTu72ChE00lPeVPp1s0JOcjsntkWNySHxWWSj")
.asJson <string>();
if (response.Code == 404 || response.Code == 400)
{
string error = "Error: type an items name in the search bar or some sort of tag, such as drinks, candy, chips, etc.";
return(null);
}
else
{
var serializer = new JsonSerializer();
var info = JsonConvert.DeserializeObject <SpoonProductInformation>(response.Body);
return(info);
}
}
/// <summary>
/// Gets the price history for an item
/// </summary>
/// <param name="itemName">The name of the item</param>
/// <returns>The price history of the item</returns>
public static async Task <IDictionary <DateTime, int> > GetPriceHistory(string itemName, bool exactName = false)
{
if (!exactName)
{
itemName = (await FuzzyMatchName(itemName)).Name;
}
var data = await Unirest.get($"http://runescape.wikia.com/wiki/Module:Exchange/{itemName.UrlEncode()}/Data?action=raw")
.asStringAsync();
// Checking if response was okay
if (data.Code < 200 || data.Code > 299)
{
if (data.Code == 404)
{
throw new ControlledException($"Price history for item with the name \"{itemName}\" could not be found.");
}
throw new HttpRequestException($"Request returned {data.Code}.");
}
// Converting to json
var jsonReadable = data.Body
.Replace("'", "\"")
.Replace("return {", "[")
.Replace("}", "]");
var json = JsonConvert.DeserializeObject <string[]>(jsonReadable);
// Converting to price history
var dic = new Dictionary <DateTime, int>();
json.ForEach(h =>
{
var time = TimeUtil.FromUnixTime(h.Split(':')[0].ToUlong());
var price = h.Split(':')[1].ToInt();
dic[time] = price;
});
return(dic);
}
public WordDefinition getWordEntry(string word)
{
try
{
if (checkDailyLimit() == false)
{
throw new Exception("Daily API calls limit reached.");
}
HttpResponse <string> response = Unirest.get(endpointURL + word)
.header("X-Mashape-Key", apiKey)
.header("Accept", "application/json")
.asJson <string>();
if (response.Code == 404)
{
return(null);
}
else if (response.Code != 200)
{
throw new Exception($"WordAPI returned error {response.Code} - message:{response.Body}");
}
WordDefinition wdEntry = JsonConvert.DeserializeObject <WordDefinition>(response.Body, new JsonSerializerSettings
{
Error = HandleDeserializationError
});
if (!String.IsNullOrEmpty(missingPronunciation) && wdEntry.pronunciation == null)//populate manually
{
wdEntry.pronunciation = new Pronunciation();
wdEntry.pronunciation.all = missingPronunciation;
}
return(wdEntry);
}
catch (Exception ex)
{
throw ex;
}
}
public List <IngredientsJson> getRecipes(String LUISIngredients)
{
try
{
string url = $"https://spoonacular-recipe-food-nutrition-v1.p.mashape.com/recipes/findByIngredients?fillIngredients=true&ingredients={LUISIngredients}&limitLicense=true&number=5&ranking=2";
HttpResponse <string> response = Unirest.get(url)
.header("X-Mashape-Key", "waVWFXWmMEmshIIkFrNRfj8T1ii8p1AlRJrjsnkb9fZC0uN270")
.header("Accept", "application/json")
.asJson <string>();
String strResponse = response.Body;
List <IngredientsJson> lstRecipes = new List <IngredientsJson>();
lstRecipes = JsonConvert.DeserializeObject <List <IngredientsJson> >(strResponse);
return(lstRecipes);
}
catch (Exception e)
{
String strTextToWrite = DateTime.Now.ToString() + "Spoonacular.getRecipes Exception: " + e.Message;
File.AppendAllText(ASRFile, strTextToWrite + Environment.NewLine);
return(null);
}
}
public static void DownloadImages(DateTime start, int imageCount, TimeSpan delta)
{
String lastDate = "";
int counter = 1;
while (counter <= imageCount)
{
Console.WriteLine("trying date " + start.ToString(DATE_FORMAT));
var closestImageUrl = string.Format(HV_API, "getClosestImage", start.ToString(DATE_FORMAT));
var response = Unirest.get(closestImageUrl).asString();
if (response.Code != 200)
{
Console.WriteLine("error getting closest date: " + response.Code);
continue;
}
start += delta;
var date = JsonConvert.DeserializeObject <ClosestImageResponse>(response.Body).date;
Console.WriteLine("closest date: " + date);
if (date == lastDate)
{
Console.WriteLine("skipping, same as last");
continue;
}
lastDate = date;
var getImageUrl = string.Format(HV_API, "getJP2Image", DateTime.Parse(date).ToString(DATE_FORMAT));
HttpResponse <Stream> imgResponse = Unirest.get(getImageUrl).asBinary();
if (imgResponse.Code != 200)
{
Console.WriteLine("error getting image: " + imgResponse.Code);
continue;
}
using (var fileStream = File.Create(@"./" + counter + ".jp2"))
{
imgResponse.Body.CopyTo(fileStream);
}
Console.WriteLine("image downloaded\n");
counter++;
}
}
public String[] getInstructions(int recipeID, String strRecipeName)
{
try
{
string url = $"https://spoonacular-recipe-food-nutrition-v1.p.mashape.com/recipes/{recipeID}/analyzedInstructions?stepBreakdown=true";
HttpResponse <string> response = Unirest.get(url)
.header("X-Mashape-Key", "I4Gh7MsEkJmshjKplIePxRXXw3Ump1uEReajsnOwO3FLB2mMsS")
.header("Accept", "application/json")
.asJson <string>();
String strResponse = response.Body;
List <RecipeInstructJSON> lstInstructions = new List <RecipeInstructJSON>();
//List<String> lstSteps = new List<String>();
lstInstructions = JsonConvert.DeserializeObject <List <RecipeInstructJSON> >(strResponse);
String[] strSteps = new String[lstInstructions[0].steps.Count + 1];
List <String> lstIngredients = new List <string>();
//String strInstructions = "";
for (int i = 2; i <= lstInstructions[0].steps.Count; i++)
{
for (int k = 0; k < lstInstructions[0].steps[i - 2].ingredients.Count; k++)
{
lstIngredients.Add(lstInstructions[0].steps[i - 2].ingredients[k].name);
}
strSteps[i] = lstInstructions[0].steps[i - 2].step;
//strInstructions += lstInstructions[i].step + " ";
}
strSteps[0] = strRecipeName;
lstIngredients = lstIngredients.Distinct(StringComparer.OrdinalIgnoreCase).ToList <String>();
strSteps[1] = "The ingredients are " + String.Join(", ", lstIngredients) + ".";
return(strSteps);
}
catch (Exception e)
{
String strTextToWrite = DateTime.Now.ToString() + "Spoonacular.getInstructions Exception: " + e.Message;
File.AppendAllText(ASRFile, strTextToWrite + Environment.NewLine);
return(null);
}
}
static async Task <byte[]> GetGif(string tag)
{
// These code snippets use an open-source library. http://unirest.io/net
var response = Unirest.get("https://giphy.p.mashape.com/v1/gifs/random?api_key=dc6zaTOxFJmzC&tag=" + tag)
.header("X-Mashape-Key", "uNOgVxAHRemshRiAMi6C7GQ68qR4p1dEz8jjsn5eMK4qYLUwW1")
.header("Accept", "application/json")
.asJson <string>();
var json = (JObject)JsonConvert.DeserializeObject(response.Body);
if (!json["data"].HasValues)
{
return(null);
}
var data = json["data"]["fixed_height_downsampled_url"].Value <string>();
using (var client = new HttpClient())
{
var gif = await client.GetByteArrayAsync(data);
return(gif);
}
}
/// <summary>
/// Uses jagex's crappy API
/// </summary>
/// <param name="url">A endpoint of jagex's crappy API</param>
/// <returns>Data returned from jagex's crappy API</returns>
public static async Task <JObject> GetFromJCA(string url)
{
HttpResponse <string> data;
do
{
data = await Unirest.get(url).asStringAsync();
if (data.Code == 404)
{
return(null);
}
if (data.Code == 429 || data.Body == null || data.Body.Trim().IsNullOrEmpty())
{
Console.WriteLine($"Waiting... {url}");
await Task.Delay(4000);
}
} while (data.Body == null || data.Body.Trim().IsNullOrEmpty());
return(JsonConvert.DeserializeObject <JObject>(data.Body));
}
public string ReadOutLoudYoda(string yoda)
{
var handle = Insights.TrackTime("Time for API to connect");
handle.Start();
var response = Unirest.get("https://yoda.p.mashape.com/yoda?sentence=" + yoda)
.header("X-Mashape-Key", "jNdTUH1UxUmshWJ0duG9JGydgLqGp13bv6IjsnmZCuwlTEAK62")
.header("Accept", "text/plain")
.asString();
if (response.Code == 200)
{
return(response.Body);
}
handle.Stop();
string errorMessages = "Could not connect to API";
return(errorMessages);
}
public async Task <bool> getRandomQandA(int id)
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(GetRandomQuestionAndAnswerURL + "Id=" + id);
if (response.IsSuccessStatusCode)
{
Task <HttpResponse <string> > response2 = Unirest.get(GetRandomQuestionAndAnswerURL)
.asJsonAsync <string>();
var obj = JsonConvert.DeserializeObject <QandA>(response2.Result.Body);
SessionQandA.Question = obj.Question;
SessionQandA.ChoiceA = obj.ChoiceA;
SessionQandA.ChoiceB = obj.ChoiceB;
SessionQandA.ChoiceC = obj.ChoiceC;
SessionQandA.ChoiceD = obj.ChoiceD;
SessionQandA.Answer = obj.Answer;
}
return(response.IsSuccessStatusCode);
}
/// <summary>
/// Get SSHKey by numeric ID.
/// </summary>
/// <param name="_Config"></param>
/// <param name="_User"></param>
/// <param name="_id"></param>
/// <returns></returns>
public static SSHKey Get(Config _Config, User _User, int _id)
{
SSHKey RetVal;
try
{
string URI = _Config.APIUrl;
if (_User == null)
{
URI += "user/keys/";
}
else
{
URI += "users/" + _User.id.ToString() + "/keys/";
}
URI += _id.ToString();
HttpResponse <string> R = Unirest.get(URI)
.header("accept", "application/json")
.header("PRIVATE-TOKEN", _Config.APIKey)
.asString();
if (R.Code < 200 || R.Code >= 300)
{
throw new GitLabServerErrorException(R.Body, R.Code);
}
else
{
RetVal = JsonConvert.DeserializeObject <SSHKey>(R.Body.ToString());
}
}
catch (Exception ex)
{
throw ex;
}
return(RetVal);
}
/// <summary>
/// Get zero or more objects from table Customers
/// </summary>
/// <param name="filter">Optional parameter: Arbitrary search criteria</param>
/// <return>Returns the CustomersModel response from the API call</return>
public async Task <CustomersModel> GetCustomersAsync(
string filter = null)
{
//the base uri for api requests
string baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/Customers");
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>()
{
{ "filter", filter }
});
//validate and preprocess url
string queryUrl = APIHelper.CleanUrl(queryBuilder);
//prepare and invoke the API call request to fetch the response
HttpRequest request = Unirest.get(queryUrl)
//append request with appropriate headers and parameters
.header("User-Agent", "APIMATIC 2.0")
.header("Accept", "application/json");
//invoke request and get response
HttpResponse <String> response = await request.asStringAsync();
//Error handling using HTTP status codes
if ((response.Code < 200) || (response.Code > 206)) //[200,206] = HTTP OK
{
throw new APIException(@"HTTP Response Not OK", response.Code);
}
return(APIHelper.JsonDeserialize <CustomersModel>(response.Body));
}
private void btnTranslate_Click(object sender, RoutedEventArgs e)
{
//using (var client = new HttpClient())
//{
// client.BaseAddress = new Uri("https://yoda.p.mashape.com/");
// client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("X-Mashape-Key", "zVcTJBa3H3mshvcot6As86uycEnep1ZKEkdjsnL8GBGUY6UWMF");
// client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/plain"));
// var response= client.GetAsync("yoda?sentence="+ txtWords.Text.Trim().ToString()).Result;
// string json = new JavaScriptSerializer().Serialize(jsonResult.Data);
//}
try
{
Task <HttpResponse <string> > response = Unirest.get("https://yoda.p.mashape.com/yoda?sentence=" + txtWords.Text.Trim().ToString())
.header("X-Mashape-Key", "zVcTJBa3H3mshvcot6As86uycEnep1ZKEkdjsnL8GBGUY6UWMF")
.header("Accept", "text/plain").asStringAsync();
}
catch (Exception ex)
{
throw ex;
}
}
// Get gameInfo
public async Task <object> gameInfo(int GameId)
{
// These code snippets use an open-source library. http://unirest.io/net
Task <HttpResponse <object> > response = Unirest.get("http://store.steampowered.com/api/appdetails?appids=" + GameId + "&l=spanish")
.asJsonAsync <object>();
await response;
string json = response.Result.Body.ToString();
Dictionary <string, object> sData = JsonConvert.DeserializeObject <Dictionary <string, object> >(json);
string result = sData[GameId.ToString()].ToString();
RootObject rootObject = null;
if (!string.IsNullOrEmpty(result))
{
rootObject = JsonConvert.DeserializeObject <RootObject>(result);
}
return(rootObject);
}
public WordUsageExample getWordUsage(string word)
{
try
{
StringBuilder fullQuery = new StringBuilder(endpointURL);
//q: word to search, l=languge english, size:max results
fullQuery.AppendFormat("q={0}&key={1}&l=en&size=4&format=json", word, apiKey);
HttpResponse <string> response = Unirest.get(fullQuery.ToString())
.header("Accept", "application/json")
.asJson <string>();
if (response.Code != 200)
{
throw new Exception($"WordAPI return error code{response.Code} - message:{response.Body}");
}
return(JsonConvert.DeserializeObject <WordUsageExample>(response.Body));
}
catch (Exception ex)
{
throw ex;
}
}
public string GetStringFromApi(string sentence)
{
string errorMsg = "";
try
{
var response = Unirest.get("https://yoda.p.mashape.com/yoda?sentence=" + sentence)
.header("X-Mashape-Key", "GED6XhwlBhmshzR1JzaQqkQpqhBtp13gS5qjsnkCIIZHIXrNa7")
.header("Accept", "text/plain")
.asString();
if (response.Code == 200)
{
return(response.Body);
}
errorMsg = "Error";
return(errorMsg);
}
catch (Exception ex)
{
return(errorMsg = "Error");
}
}
