public void Should_get_a_messagge()
{
var contentType = "text/text";
var payload = "Hello!";
var message = new Message()
{
Id = Identity.Random(),
TopicId = Identity.Random(),
Payload = Encoding.ASCII.GetBytes(payload),
UtcReceivedOn = DateTime.UtcNow
};
message.Headers.Add("Content-Type", new[] { contentType });
var key = new MessageKey { MessageId = message.Id.Value, TopicId = message.TopicId };
messageByMessageKey
.Setup(r => r.Get(It.Is<MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
var client = new HttpClient(baseUri);
var url = baseUri + message.Id.Value.ToString() + "/topic/" + message.TopicId;
var result = client.Get(url);
messageByMessageKey.Verify(r => r.Get(It.Is<MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)));
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(payload, result.Content.ReadAsString());
Assert.AreEqual(contentType, result.Content.Headers.ContentType.MediaType);
}
static void Main(string[] args)
{
CookieContainer cookieContainer = new CookieContainer();
using (HttpClient client = new HttpClient("http://localhost:44857/")) {
HttpClientChannel clientChannel = new HttpClientChannel();
clientChannel.CookieContainer = cookieContainer;
client.Channel = clientChannel;
HttpContent loginData = new FormUrlEncodedContent(
new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("Username", "foo"),
new KeyValuePair<string, string>("Password", "bar")
}
);
client.Post("login", loginData);
}
string result = string.Empty;
using (HttpClient client = new HttpClient("http://localhost:44857/contact/")) {
HttpClientChannel clientChannel = new HttpClientChannel();
clientChannel.CookieContainer = cookieContainer;
client.Channel = clientChannel;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.Get("1");
result = response.Content.ReadAsString();
}
JavaScriptSerializer jsonDeserializer = new JavaScriptSerializer();
ContactDto contact = jsonDeserializer.Deserialize<ContactDto>(result);
Console.WriteLine(contact.Name);
Console.ReadLine();
}
public override bool ValidateAccessToken(string token)
{
string _auth = string.Format("{0}:{1}", CLIENT_ID, CLIENT_SECRET);
string _enc = Convert.ToBase64String(Encoding.UTF8.GetBytes(_auth));
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", _enc);
var response = client.Get(ValidateUrl + token);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(false);
}
client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
response = client.Get("https://api.github.com/user?access_token=" + token);
dynamic user = response.Content.ReadAs <JsonObject>();
SetMemberInfo(user);
return(true);
}
public virtual bool ValidateAccessToken(string token)
{
if (!IsProviderEnabled())
throw new ScrumFactory.Exceptions.AuthorizationProviderNotSupportedException();
System.Net.Http.HttpClientHandler handler = new System.Net.Http.HttpClientHandler();
handler.Proxy = System.Net.WebRequest.DefaultWebProxy;
System.Net.Http.HttpClient wc = new System.Net.Http.HttpClient(handler);
System.Net.Http.HttpResponseMessage msg = null;
try {
msg = wc.Get(new Uri(ValidateUrl + "?access_token=" + token));
}
catch (Exception ex) {
throw new System.ServiceModel.Web.WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
if (msg.StatusCode == HttpStatusCode.Unauthorized)
return false;
if (msg.StatusCode != HttpStatusCode.OK)
throw new System.ServiceModel.Web.WebFaultException<string>("Server failed to validate token: " + msg.StatusCode.ToString(), System.Net.HttpStatusCode.BadRequest);
dynamic info = msg.Content.ReadAs<JsonObject>();
SetMemberInfo(info);
return true;
}
public IApplicationState NextState(HttpClient client)
{
if (currentResponse.Content.Headers.ContentType.Equals(AtomMediaType.Feed))
{
var feed = currentResponse.Content.ReadAsObject<SyndicationFeed>(AtomMediaType.Formatter);
if (feed.Categories.Contains(new SyndicationCategory("encounter"), CategoryComparer.Instance))
{
return new ResolvingEncounter(currentResponse, applicationStateInfo);
}
return new Error(currentResponse, applicationStateInfo);
}
var entry = currentResponse.Content.ReadAsObject<SyndicationItem>(AtomMediaType.Formatter);
if (entry.Title.Text.Equals("Exit"))
{
return new GoalAchieved(currentResponse);
}
var exitLink = GetExitLink(entry, applicationStateInfo.History, "north", "east", "west", "south");
var newResponse = client.Get(new Uri(entry.BaseUri, exitLink.Uri));
var exitUri = applicationStateInfo.History.Contains(exitLink.Uri) ? null : exitLink.Uri;
return new Exploring(newResponse, applicationStateInfo.GetBuilder().AddToHistory(exitUri).Build());
}
public void WhenOrdering_ThenSucceeds()
{
var config = HttpHostConfiguration.Create();
config.Configuration.OperationHandlerFactory.Formatters.Insert(0, new JsonNetMediaTypeFormatter());
using (var ws = new HttpWebService<TestService>("http://localhost:20000", "products", config))
{
var client = new HttpClient("http://localhost:20000");
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/json"));
var context = new DataServiceContext(new Uri("http://localhost:20000"));
// We always specify how many to take, to be explicit.
var query = context.CreateQuery<Product>("products")
.Where(x => x.Owner.Name == "kzu")
.OrderBy(x => x.Id)
.ThenBy(x => x.Owner.Id)
.Skip(1)
.Take(1);
//var uri = ((DataServiceQuery)query).RequestUri;
var uri = new Uri(((DataServiceQuery)query).RequestUri.ToString().Replace("()?$", "?$"));
Console.WriteLine(uri);
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, "Failed : " + response.StatusCode + " " + response.ReasonPhrase);
var products = new JsonSerializer().Deserialize<List<Product>>(new JsonTextReader(new StreamReader(response.Content.ContentReadStream)));
Assert.Equal(1, products.Count);
}
}
//
// GET: /Home/
public ActionResult Index()
{
HttpClient client = new HttpClient();// {BaseAddress = uri};
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.Get(uri);
var donaldEpisodes = response.Content.ReadAs<List<DonaldEpisode>>();
return View(donaldEpisodes);
}
public IList<INosSession> GetUnplannedSessions()
{
using (HttpClient httpClient = new HttpClient(_baseAddress)) {
httpClient.DefaultRequestHeaders.Accept.Add(_json);
HttpResponseMessage response = httpClient.Get("sessions/unplanned");
List<NosSession> sessions = response.Content.ReadAs<List<NosSession>>(new List<MediaTypeFormatter>() { new JsonMediaTypeFormatter() });
return new List<INosSession>(sessions);
}
}
public async Task<List<GetClaimsResponseItem>> GetClaims(string accessToken)
{
var client = new HttpClient()
{
BaseAddress = new Uri(_baseUri)
};
client.DefaultRequestHeaders.Authorization = JwtAuthHeader.GetHeader(accessToken);
var response = await client.Get<List<GetClaimsResponseItem>>("values/claims");
return response.Data;
}
public void Validates_a_get_of_a_message_that_does_not_exist()
{
messageByMessageKey.Setup(s => s.Get(It.IsAny<MessageKey>())).Returns((Message)null);
var client = new HttpClient(baseUri);
var url = baseUri.ToString() + Identity.Random() + "/topic/" + Identity.Random();
var result = client.Get(url);
messageByMessageKey.Verify(r => r.Get(It.IsAny<MessageKey>()));
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode);
}
private static void basicAuthenticationSample()
{
var client = new HttpClient(Urls.Code)
{
Channel = new BasicAuthenticationChannel(new WebRequestChannel(),
_ => Tuple.Create("test", "changeit"),
new WebRequestChannel())
};
var response = client.Get("preprompt/wcf/banzai.txt");
response.EnsureSuccessStatusCode();
Console.WriteLine(response);
Console.WriteLine(response.Content.ReadAsString());
}
public void WhenGettingThenReturnsListOfPeopleAdded()
{
var peopleToSayHelloTo = new List<string>();
peopleToSayHelloTo.Add("Glenn");
HelloResource.Initialize(peopleToSayHelloTo);
using (var host = new HttpServiceHost(typeof(HelloResource), this.hostUri))
{
host.Open();
var client = new HttpClient();
var response = client.Get(this.hostUri);
Assert.AreEqual("Hello Glenn", response.Content.ReadAsString());
host.Close();
}
}
public ICollection<string> LoadCodeReps(Project project)
{
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
var response = client.Get("https://api.github.com/user/repos?access_token=" + authorizator.SignedMemberToken);
if(response.StatusCode!=System.Net.HttpStatusCode.OK)
return new string[0];
dynamic reposArray = response.Content.ReadAs<JsonArray>();
List<string> repos = new List<string>();
foreach (var repo in reposArray)
repos.Add((string)repo.svn_url);
return repos.ToArray();
}
public void Should_get_a_messagge_by_topic()
{
var key = new MessageKey {MessageId = Identity.Random(), TopicId = Identity.Random()};
messageKeysByTopic
.Setup(r => r.Get(key.TopicId, null, null, null))
.Returns(new[] {key});
var client = new HttpClient(baseUri);
var url = baseUri + "topic/" + key.TopicId;
var result = client.Get(url);
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
}
public void WhenHostingDisposableService_ThenDefaultActivatorFactoryDisposesIt()
{
using (var webservice = new HttpWebService<TestService>(
serviceBaseUrl: "http://localhost:20000",
serviceResourcePath: "test",
serviceConfiguration: HttpHostConfiguration.Create()))
{
var client = new HttpClient(webservice.BaseUri);
// Builds: http://localhost:2000/test/23
var uri = webservice.Uri("23");
var response = client.Get(uri);
}
Assert.True(TestService.IsDisposed);
}
public void WhenHostingSpecificServiceInstance_ThenGetsConfiguredResult()
{
var id = Guid.NewGuid();
using (var webservice = HttpWebService.Create(new TestService(id),
serviceBaseUrl: "http://localhost:20000",
serviceResourcePath: "test"))
{
var client = new HttpClient(webservice.BaseUri);
// Builds: http://localhost:2000/test
var uri = webservice.Uri("");
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, response.ToString());
Assert.True(response.Content.ReadAsString().Contains(id.ToString()));
}
}
public void WhenHostingService_ThenCanInvokeIt()
{
using (var webservice = new HttpWebService<TestService>(
serviceBaseUrl: "http://localhost:20000",
serviceResourcePath: "test",
serviceConfiguration: HttpHostConfiguration.Create()))
{
var client = new HttpClient(webservice.BaseUri);
// Builds: http://localhost:2000/test/23
var uri = webservice.Uri("23");
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, response.ToString());
Assert.True(response.Content.ReadAsString().Contains("23"));
}
}
public void ServiceHost_Works_With_OneWay_Operation()
{
ContractDescription cd = ContractDescription.GetContract(typeof(OneWayService));
HttpServiceHost host = new HttpServiceHost(typeof(OneWayService), new Uri("http://localhost/onewayservice"));
host.Open();
using (HttpClient client = new HttpClient())
{
client.Channel = new WebRequestChannel();
using (HttpResponseMessage actualResponse = client.Get("http://localhost/onewayservice/name"))
{
Assert.AreEqual(actualResponse.StatusCode, HttpStatusCode.Accepted, "Response status code should be Accepted(202) for one-way operation");
}
}
host.Close();
}
private static void TestWithContentType(string contentType, Func<HttpContent, JsonReader> readerFactory)
{
var config = HttpHostConfiguration.Create().UseJsonNet();
using (var webservice = new HttpWebService<TestService>("http://localhost:20000", "test", config))
{
var client = new HttpClient(webservice.BaseUri);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
var response = client.Get(webservice.Uri(25));
Assert.True(response.IsSuccessStatusCode, response.ToString());
var product = new JsonSerializer().Deserialize<Product>(readerFactory(response.Content));
Assert.Equal(25, product.Id);
Assert.Equal("kzu", product.Owner.Name);
}
}
public void WhenHostingCachedServiceInstance_ThenGetsSameResultAlways()
{
using (var webservice = new HttpWebService<TestService>(
cacheServiceInstance: true,
serviceBaseUrl: "http://localhost:20000",
serviceResourcePath: "test",
serviceConfiguration: HttpHostConfiguration.Create()))
{
var client = new HttpClient(webservice.BaseUri);
// Builds: http://localhost:2000/test/23
var uri = webservice.Uri("23");
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, response.ToString());
var content1 = response.Content.ReadAsString();
var content2 = client.Get(uri).Content.ReadAsString();
Assert.Equal(content1, content2);
}
}
public override bool ValidateAccessToken(string token)
{
if (!IsProviderEnabled())
{
throw new ScrumFactory.Exceptions.AuthorizationProviderNotSupportedException();
}
System.Net.Http.HttpClientHandler handler = new System.Net.Http.HttpClientHandler();
handler.Proxy = System.Net.WebRequest.DefaultWebProxy;
System.Net.Http.HttpClient wc = new System.Net.Http.HttpClient(handler);
wc.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
System.Net.Http.HttpResponseMessage msg = null;
try
{
msg = wc.Get(new Uri(ValidateUrl));
}
catch (Exception ex)
{
throw new System.ServiceModel.Web.WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
if (msg.StatusCode == HttpStatusCode.Unauthorized)
{
var err = msg.Content.ReadAsString();
return(false);
}
if (msg.StatusCode != HttpStatusCode.OK)
{
throw new System.ServiceModel.Web.WebFaultException <string>("Server failed to validate token: " + msg.StatusCode.ToString(), System.Net.HttpStatusCode.BadRequest);
}
dynamic info = msg.Content.ReadAs <JsonObject>();
SetMemberInfo(info);
return(true);
}
/// <summary>
/// Get land by earthwatcher
/// </summary>
/// <param name="tigUser"></param>
private static void GetLandByEarthwatcher(string tigUser)
{
// send a http get request
var httpClient = new HttpClient();
var response=httpClient.Get(Server+ "land/earthwatcher=" + tigUser).Content.ReadAsString();
// parse xml
var xdoc = XDocument.Load(new StringReader(response));
var land=(from d in xdoc.Elements("Land") select d).FirstOrDefault();
if (land != null)
{
// print the result
if (land.Element("Id") != null)
{
Console.Write("User " + tigUser + " has land id: " + land.Element("Id").Value);
}
else
{
Console.Write("User " + tigUser + " has no land yet");
}
}
}
public override bool ValidateAccessToken(string token)
{
string _auth = string.Format("{0}:{1}", CLIENT_ID, CLIENT_SECRET);
string _enc = Convert.ToBase64String(Encoding.UTF8.GetBytes(_auth));
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", _enc);
var response = client.Get(ValidateUrl + token);
if (response.StatusCode != System.Net.HttpStatusCode.OK) {
return false;
}
client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
response = client.Get("https://api.github.com/user?access_token=" + token);
dynamic user = response.Content.ReadAs<JsonObject>();
SetMemberInfo(user);
return true;
}
public void TrailingSlashMode_Redirects_By_Default()
{
HttpBehavior httpBehavior = new HttpBehavior();
string actualBaseAddress = null;
ServiceHost actualHost = GetServiceHost(typeof(TrailingSlashModeService), httpBehavior, new HttpBinding(), out actualBaseAddress);
using (HttpClient client = new HttpClient())
{
client.Channel = new WebRequestChannel();
using (HttpResponseMessage actualResponse = client.Get(actualBaseAddress + "/"))
{
Assert.AreEqual(actualResponse.RequestMessage.RequestUri.ToString(), actualBaseAddress, "The server should have redirected to the address without the trailing slash.");
}
}
actualHost.Close();
}
protected void GetId6_Click(object sender, EventArgs e)
{
int input = 0;
try
{
input = Convert.ToInt32(this.TextBox5.Text, CultureInfo.InvariantCulture);
}
catch (Exception)
{
this.TextBox5.Text = "Error: please enter an integer";
return;
}
string uri = string.Format("http://localhost:8300/contacts?$filter=Id eq {0}", TextBox5.Text);
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
var response = client.Get(uri);
var resultList = response.Content.ReadAs<List<Contact>>();
string result = string.Empty;
if (resultList.Count == 0)
{
result = "There is no contact with ID = " + input;
}
else
{
result = "Found a matched contact: ";
result += string.Format(CultureInfo.InvariantCulture, "\r\n Contact Name: {0}, Contact Id: {1}", resultList[0].Name, resultList[0].Id);
}
this.TextBox4.Text = uri;
this.Result.Text = result;
}
public bool LoadSettings(out string errorMessage)
{
errorMessage = null;
var client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "SF-Client");
var response = client.Get("https://api.github.com/user?access_token=" + authorizator.SignedMemberToken);
if (response.StatusCode != System.Net.HttpStatusCode.OK) {
errorMessage = "You must be signed in with a GitHub account.";
return false;
}
dynamic user = response.Content.ReadAs<JsonObject>();
RepositoryRoot = (string) user.html_url;
return true;
}
private Guid GetUserIdForApiKey(string apiKey)
{
if (string.IsNullOrWhiteSpace(apiKey)) { throw new ArgumentNullException("apiKey"); }
string baseUrl = Settings.Default.LocanServiceBaseUrl;
string url = string.Format(
"{0}/{1}/{2}",
baseUrl,
Consts.UrlRegiserUser,
apiKey);
var textHeader = new MediaTypeWithQualityHeaderValue(Consts.HeaderText);
using (HttpClient client = new HttpClient()) {
client.DefaultRequestHeaders.Accept.Add(textHeader);
HttpResponseMessage response = client.Get(url);
response.EnsureSuccessStatusCode();
string guidString = response.Content.ReadAsString();
// Result looks like: <?xml version="1.0" encoding="utf-8"?><guid>2158e8e5-ae6c-4b9a-a7ab-3169fff9750d</guid>
XDocument doc = XDocument.Parse(guidString);
Guid id = new Guid(doc.Root.Value);
return id;
}
}
public void Validates_a_get_with_invalid_data()
{
messageByMessageKey.Setup(s => s.Get(It.IsAny<MessageKey>())).Throws<ValidationException>();
var client = new HttpClient(baseUri);
var url = baseUri.ToString() + Identity.Random() + "/topic/" + Identity.Random();
var result = client.Get(url);
messageByMessageKey.Verify(r => r.Get(It.IsAny<MessageKey>()));
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
private SyndicationFeed GetFeedForMessage(Message message)
{
var messageId = message.Id.Value;
var topicId = message.TopicId;
var feedEntry = new FeedEntry() { MessageId = messageId, TimeStamp = DateTime.UtcNow };
var feed = new Feed()
{
Entries = new List<FeedEntry>(new[] { feedEntry }),
Id = Identity.Random(),
TopicId = topicId,
Updated = DateTime.UtcNow
};
var topic = new Topic()
{
Id = topicId,
Name = "Topic Name",
Description = "Topic Description",
GroupId = Identity.Random()
};
var key = new MessageKey { MessageId = messageId, TopicId = topicId };
messageByMessageKey
.Setup(r => r.Get(It.Is<MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
getWorkingFeedForTopic
.Setup(r => r.Execute(topicId))
.Returns(feed);
entityById
.Setup(r => r.Get<Topic>(topicId))
.Returns(topic);
var client = new HttpClient(baseUri);
var response = client.Get(topicId.ToString());
var formatter = new Atom10FeedFormatter();
using (var rdr = XmlReader.Create(response.Content.ContentReadStream))
{
formatter.ReadFrom(rdr);
return formatter.Feed;
}
}
public void TestGet()
{
using (var webservice = CreateRESTHttpService())
{
var client = new HttpClient();
client.BaseAddress = webservice.BaseUri;
// Builds: http://localhost:20259/RESTEmployeeService.svc/Get?id=1
var uri = webservice.Uri("Get?id=1");
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, response.ToString());
// Console.WriteLine(response.Content.ReadAsString());
Assert.True(response.Content.ReadAsString().Contains("1"));
}
}
public IApplicationState NextState(HttpClient client)
{
return new Exploring(client.Get(entryPointUri), applicationStateInfo.GetBuilder().AddToHistory(entryPointUri).Build());
}
/// <summary>
/// Get请求
/// </summary>
/// <param name="httpClient">http客户端</param>
/// <param name="url">URL</param>
/// <param name="customerOptions">自定义选项配置</param>
/// <returns>任务</returns>
public static Task <string> GetAsync(this HttpClient httpClient, string url, Action <ChannelCustomerOptions> customerOptions = null)
{
return(Task <string> .Run(() => httpClient.Get(url, customerOptions)));
}
public IApplicationState NextState(HttpClient client)
{
if (applicationStateInfo.Endurance < 1)
{
return new Defeated(currentResponse, applicationStateInfo);
}
if (currentResponse.Content.Headers.ContentType.Equals(AtomMediaType.Feed))
{
var feed = currentResponse.Content.ReadAsObject<SyndicationFeed>(AtomMediaType.Formatter);
if (feed.Categories.Contains(new SyndicationCategory("encounter"), CategoryComparer.Instance))
{
var form = Form.ParseFromFeedExtension(feed);
form.Fields.Named("endurance").Value = applicationStateInfo.Endurance.ToString();
var newResponse = client.Send(form.CreateRequest(feed.BaseUri));
if (newResponse.Content.Headers.ContentType.Equals(AtomMediaType.Entry))
{
var newContent = newResponse.Content.ReadAsObject<SyndicationItem>(AtomMediaType.Formatter);
var newForm = Form.ParseFromEntryContent(newContent);
var newEndurance = int.Parse(newForm.Fields.Named("endurance").Value);
return new ResolvingEncounter(newResponse, applicationStateInfo.GetBuilder().UpdateEndurance(newEndurance).Build());
}
}
return new Error(currentResponse, applicationStateInfo);
}
if (currentResponse.Content.Headers.ContentType.Equals(AtomMediaType.Entry))
{
var entry = currentResponse.Content.ReadAsObject<SyndicationItem>(AtomMediaType.Formatter);
if (entry.Categories.Contains(new SyndicationCategory("room"), CategoryComparer.Instance))
{
return new Exploring(currentResponse, applicationStateInfo);
}
var continueLink = entry.Links.FirstOrDefault(l => l.RelationshipType.Equals("continue"));
if (continueLink != null)
{
return new ResolvingEncounter(client.Get(new Uri(entry.BaseUri, continueLink.Uri)), applicationStateInfo);
}
var form = Form.ParseFromEntryContent(entry);
var newResponse = client.Send(form.CreateRequest(entry.BaseUri));
if (newResponse.Content.Headers.ContentType.Equals(AtomMediaType.Entry))
{
var newContent = newResponse.Content.ReadAsObject<SyndicationItem>(AtomMediaType.Formatter);
var newForm = Form.ParseFromEntryContent(newContent);
var newEndurance = int.Parse(newForm.Fields.Named("endurance").Value);
return new ResolvingEncounter(newResponse, applicationStateInfo.GetBuilder().UpdateEndurance(newEndurance).Build());
}
}
return new Error(currentResponse, applicationStateInfo);
}
