public static void AddAlbumXml(HttpClient client)
{
client.DefaultRequestHeaders.Accept.Add(new
MediaTypeWithQualityHeaderValue("application/xml"));
Console.WriteLine("Enter album title");
string title = Console.ReadLine();
Console.WriteLine("Enter album year");
int year = int.Parse(Console.ReadLine());
Console.WriteLine("Enter producer");
string producer = Console.ReadLine();
Album album = new Album { AlbumTitle = title, AlbumYear = year, Producer = producer };
HttpResponseMessage response =
client.PostAsXmlAsync("api/albums", album).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Album added");
}
else
{
Console.WriteLine("{0} ({1})",
(int)response.StatusCode, response.ReasonPhrase);
}
}
/// <summary>
/// Save order on web api.
/// </summary>
/// <param name="newOrder">New Order to be saved.</param>
/// <returns>Tuple of bool and string, bool == true when API succeded, bool == false when API did not succeed, string == fail message.</returns>
public Tuple<bool,string> PostOrderAsync(NewOrderInfo newOrder)
{
using (var client = new HttpClient())
{
try
{
client.BaseAddress = _baseAddress;
var response = client.PostAsXmlAsync("api/order/create", newOrder, new CancellationToken()).Result;
if (response.IsSuccessStatusCode)
{
var answer = new Tuple<bool, string>(true, response.StatusCode.ToString());
return answer;
}
else //do failure thing
{
var answer = new Tuple<bool, string>(false, "Could not save the created order: Error from Web api: " + response.StatusCode.ToString() + ": " + response.ReasonPhrase);
return answer;
}
}
catch (Exception ex)
{
throw;
}
}
}
internal static async void ProcessPostRequests(HttpClient client)
{
ResponseAlbumModel album = new ResponseAlbumModel
{
Title = "Xml added",
ProducerName = "Xml Produer",
Year = 2000
};
var httpResponse = await client.PostAsXmlAsync("api/albums", album);
Console.WriteLine(httpResponse.ReasonPhrase.ToString() + " from albums");
}
public void PostAsXmlAsync_String_WhenUriIsNull_ThrowsException()
{
Assert.Throws <InvalidOperationException>(
() => _client.PostAsXmlAsync((string)null, new object()),
"An invalid request URI was provided. The request URI must either be an absolute URI or BaseAddress must be set."
);
}
public static void AddArtistXml(HttpClient client)
{
client.DefaultRequestHeaders.Accept.Add(new
MediaTypeWithQualityHeaderValue("application/xml"));
Console.WriteLine("Enter artist name");
string name = Console.ReadLine();
Console.WriteLine("Enter artist country");
string country = Console.ReadLine();
Console.WriteLine("Enter artist birth date");
DateTime birthDate = DateTime.ParseExact(Console.ReadLine(), "dd.MM.yyyy", new CultureInfo("en-US"));
Artist artist = new Artist { Name = name, Country = country, DateOfBirth = birthDate };
HttpResponseMessage response =
client.PostAsXmlAsync("api/artists", artist).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Artist added");
}
else
{
Console.WriteLine("{0} ({1})",
(int)response.StatusCode, response.ReasonPhrase);
}
}
public static void AddSongXml(HttpClient client)
{
client.DefaultRequestHeaders.Accept.Add(new
MediaTypeWithQualityHeaderValue("application/xml"));
Console.WriteLine("Enter song title");
string title = Console.ReadLine();
Console.WriteLine("Enter song year");
int year = int.Parse(Console.ReadLine());
Console.WriteLine("Enter song genre code");
Genre genre = (Genre)int.Parse(Console.ReadLine());
Console.WriteLine("Enter song description");
string description = Console.ReadLine();
Console.WriteLine("Enter song artist id");
int id = int.Parse(Console.ReadLine());
Song song = new Song { SongTitle = title, SongYear = year, SongGenre = genre, Description = description, ArtistId = id };
HttpResponseMessage response =
client.PostAsXmlAsync("api/songs", song).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Song added");
}
else
{
Console.WriteLine("{0} ({1})",
(int)response.StatusCode, response.ReasonPhrase);
}
}
public async Task <T> PostAsync <P, T>(string relativePath, P submittingData, string mediaType = "application/json")
{
using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaType));
HttpResponseMessage response = null;
if (submittingData.GetType() == typeof(FormUrlEncodedContent))
{
response = await client.PostAsync(relativePath, ((FormUrlEncodedContent)Convert.ChangeType(submittingData, typeof(FormUrlEncodedContent))));
}
else if ((mediaType?.ToLower()).Contains("xml"))
{
response = await client.PostAsXmlAsync <P>(relativePath, submittingData);
}
else
{
response = await client.PostAsJsonAsync <P>(relativePath, submittingData);
}
response.EnsureSuccessStatusCode();
T result = await response.Content.ReadAsAsync <T>();
return(result);
}
}
public void PostAsXmlAsync_String_WhenClientIsNull_ThrowsException()
{
HttpClient client = null;
Assert.ThrowsArgumentNull(
() => client.PostAsXmlAsync("http://www.example.com", new object()),
"client"
);
}
public async void PostCanRespondInXml()
{
var message = new MessageDto
{
Text = "This is XML"
};
var client = new HttpClient(_server);
var response = await client.PostAsXmlAsync(Url + "hello", message);
var result = await response.Content.ReadAsAsync<MessageDto>(new [] {new XmlMediaTypeFormatter() });
Assert.Equal(message.Text, result.Text);
}
public static async Task NotifySites()
{
BlogConfigurationDto configuration = configurationDataService.GetConfiguration();
IEnumerable<Uri> pingSites = pingDataService.GetPingSites();
foreach (Uri pingSite in pingSites)
{
using (HttpClient client = new HttpClient())
{
await client.PostAsXmlAsync(pingSite.ToString(), GetRequest(pingSite, configuration));
}
}
}
public static void Post <TRequest, TResponse>(this HttpClient httpClient, string requestUri, TRequest content, DataFormat dataFormat,
out HttpResponseMessage httpResponseMessage,
out string responseString,
out TResponse response) where TResponse : class where TRequest : class
{
httpClient.DefaultRequestHeaders.Accept.Clear();
switch (dataFormat)
{
case DataFormat.Xml:
{
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
httpResponseMessage = httpClient.PostAsXmlAsync(requestUri, content).Result;
responseString = httpResponseMessage.Content.ReadAsStringAsync().Result;
try
{
response = responseString.ToXml <TResponse>();
}
catch
{
response = null;
}
}
break;
default:
{
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpResponseMessage = httpClient.PostAsJsonAsync(requestUri, content).Result;
responseString = httpResponseMessage.Content.ReadAsStringAsync().Result;
try
{
response = JsonConvert.DeserializeObject <TResponse>(responseString);
}
catch
{
response = null;
}
}
break;
}
}
internal static Song AddNewSongAsXML(HttpClient Client, string title, int year, string genre, Artist artist)
{
var album = new Song() { Title = title, Year = year, Genre = genre, Artist = artist };
var response = Client.PostAsXmlAsync("api/Songs", album).Result;
Song resultSong = response.Content.ReadAsAsync<Song>().Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Song added!");
return resultSong;
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
return new Song();
}
internal static Album AddNewAlbumAsXml(HttpClient Client, string title, int year, string producer, ICollection<Song> songs, ICollection<Artist> artists)
{
var album = new Album() { Title = title, Year = year, Producer = producer, Songs = songs, Artists = artists };
var response = Client.PostAsXmlAsync("api/Albums", album).Result;
Album resultAlbum = response.Content.ReadAsAsync<Album>().Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Album added!");
return resultAlbum;
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
return new Album();
}
internal static Artist AddNewArtistAsXml(HttpClient Client, string name, string country, DateTime dateOfBirth)
{
var artist = new Artist { Name = name, Country = country, DateOfBirth = dateOfBirth };
var response = Client.PostAsXmlAsync("api/Artists", artist).Result;
Artist resultArtist = response.Content.ReadAsAsync<Artist>().Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Artist added!");
return resultArtist;
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
return new Artist();
}
public static void AddSong(HttpClient client, Song song)
{
HttpResponseMessage response;
if (client.DefaultRequestHeaders.Accept.Contains(new MediaTypeWithQualityHeaderValue("application/json")))
{
response = client.PostAsJsonAsync("api/songs", song).Result;
}
else
{
response = client.PostAsXmlAsync("api/songs", song).Result;
}
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Artist {0} added successfully", song.Title);
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
}
public static async Task Notify(ItemDto item, Uri uri)
{
SiteUrl itemUrl = item is PostDto
? urlBuilder.Post.Permalink(item)
: urlBuilder.Page.Permalink(item);
using (HttpClient client = new HttpClient())
{
HttpResponseMessage response = await client.GetAsync(uri);
KeyValuePair<string, IEnumerable<string>> header = response.Headers.SingleOrDefault(h => h.Key.Equals("x-pingback", StringComparison.OrdinalIgnoreCase) || h.Key.Equals("pingback", StringComparison.OrdinalIgnoreCase));
string urlToPing = header.Value.FirstOrDefault();
if (string.IsNullOrEmpty(urlToPing))
{
return;
}
var xmlRequest = GetXmlRequest(itemUrl, uri);
await client.PostAsXmlAsync(urlToPing, xmlRequest);
}
}
private Uri SaveInfoToWebApi <U>(string path, U model)
{
var httpClient = new System.Net.Http.HttpClient
{
BaseAddress = new Uri(baseUri + path),
Timeout = TimeSpan.FromSeconds(8),
};
try
{
var response = httpClient.PostAsXmlAsync("", model).Result;
response.EnsureSuccessStatusCode();
if (response.IsSuccessStatusCode)
{
// Get the URI of the created resource.
return(response.Headers.Location);
}
}
catch (Exception ex)
{
}
return(null);
}
/// <summary>
/// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
/// as XML.
/// </summary>
/// <remarks>
/// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
/// </remarks>
/// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
/// <param name="client">The client used to make the request.</param>
/// <param name="requestUri">The Uri the request is sent to.</param>
/// <param name="value">The value that will be placed in the request's entity body.</param>
/// <returns>A task object representing the asynchronous operation.</returns>
public static Task <HttpResponseMessage> PostAsXmlAsync <T>(this HttpClient client, Uri requestUri, T value)
{
return(client.PostAsXmlAsync(requestUri, value, CancellationToken.None));
}
public static async void Add(HttpClient httpClient, SongApiModel song)
{
var response = await httpClient.PostAsXmlAsync("song", song);
Console.WriteLine("Done!");
}
public void When_POST_typed_XML_content_can_be_read()
{
var reqModel = new SomeModel
{
AnInteger = 2,
AString = "hello"
};
var client = new HttpClient();
client.PostAsXmlAsync(_baseAddress + "Test", reqModel);
TestController.OnPost(req =>
{
var recModel = req.Content.ReadAsAsync<SomeModel>().Result;
Assert.Equal(reqModel.AnInteger, recModel.AnInteger);
Assert.Equal(reqModel.AString, recModel.AString);
return new HttpResponseMessage();
});
}
public void PostVPN()
{
string baseAddress = "http://localhost:6000/";
var request_payload = new SendRequest() { VPNKey = "vpn1", Topic = "A/B", Message = "msg1", CorrelationID = 123 };
using (Microsoft.Owin.Hosting.WebApp.Start<VpnStartup>(url: baseAddress))
{
using (var client = new System.Net.Http.HttpClient())
{
var response = client.PostAsXmlAsync(baseAddress + "api/vpn", request_payload).Result;
Assert.AreEqual<string>("vpn1", VpnController.received_request.VPNKey);
Assert.AreEqual<string>("A/B", VpnController.received_request.Topic);
Assert.AreEqual<string>("msg1", VpnController.received_request.Message);
Assert.AreEqual<uint>(123, VpnController.received_request.CorrelationID );
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.AreEqual<System.Net.HttpStatusCode>(System.Net.HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual<string>("OK", response.ReasonPhrase);
string response_xml = response.Content.ReadAsStringAsync().Result;
Assert.IsTrue(response_xml.Length > 0);
var response_doc = XDocument.Parse(response_xml);
XNamespace ns = "http://schemas.datacontract.org/2004/07/ContractLib";
Assert.IsNotNull(response_doc.Root);
Assert.IsTrue(response_doc.Root.HasElements);
Assert.AreEqual<int>(3, response_doc.Root.Elements().Count());
var correlationID = response_doc.Root.Element(ns + "CorrelationID");
Assert.IsNotNull(correlationID);
var status = response_doc.Root.Element(ns + "Status");
Assert.IsNotNull(status);
var description = response_doc.Root.Element(ns + "Description");
Assert.IsNotNull(description);
Assert.AreEqual<string>("123", correlationID.Value);
Assert.AreEqual<string>("102", status.Value);
Assert.AreEqual<string>(string.Format("{0}|{1}|{2}", request_payload.VPNKey, request_payload.Topic, request_payload.Message), description.Value);
}
}
}
static void Main(string[] args)
{
// Prepare for a simple HttpPost request
var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:61924/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
// Get the body of the request
var vMRRequest = GetSampleRequest();
// Construct the DSS-level request, base-64 encoding the vMR request within it.
var evaluate =
new evaluate
{
interactionId =
new InteractionIdentifier
{
interactionId = Guid.NewGuid().ToString("N"),
scopingEntityId = "SAMPLE-CLIENT",
submissionTime = DateTime.Now.ToUniversalTime()
},
evaluationRequest =
new EvaluationRequest
{
clientLanguage = "XXX",
clientTimeZoneOffset = "XXX",
dataRequirementItemData = new List<DataRequirementItemData>
{
new DataRequirementItemData
{
driId = new ItemIdentifier { itemId = "RequiredDataId" },
data =
new SemanticPayload
{
informationModelSSId = SemanticSignifiers.CDSInputId,
base64EncodedPayload = Packager.EncodeRequestPayload(vMRRequest)
}
}
},
kmEvaluationRequest = new List<KMEvaluationRequest>
{
new KMEvaluationRequest { kmId = new EntityIdentifier { scopingEntityId = "org.hl7.cds", businessId = "NQF-0068", version = "1.0" } }
}
}
};
// Post the request and retrieve the response
var response = client.PostAsXmlAsync("api/evaluation", evaluate).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Evaluation succeeded.");
var evaluateResponse = response.Content.ReadAsAsync<evaluateResponse>().Result;
var evaluationResponse = evaluateResponse.evaluationResponse.finalKMEvaluationResponse.First();
if (evaluationResponse.kmId.scopingEntityId != "SAMPLE-CLIENT")
{
Console.WriteLine("Evaluation did not return the input scoping entity Id.");
}
var evaluationResult = evaluationResponse.kmEvaluationResultData.First();
if (!SemanticSignifiers.AreEqual(evaluationResult.data.informationModelSSId, SemanticSignifiers.CDSActionGroupResponseId))
{
Console.WriteLine("Evaluation did not return an action group response.");
}
var actionGroupResponse = Packager.DecodeActionGroupResponsePayload(evaluationResult.data.base64EncodedPayload);
var createAction = actionGroupResponse.actionGroup.subElements.Items.First() as CreateAction;
if (createAction == null)
{
Console.WriteLine("Result does not include a CreateAction.");
}
else
{
var proposalLiteral = createAction.actionSentence as elm.Instance;
if (proposalLiteral == null)
{
Console.WriteLine("Resulting CreateAction does not have an ELM Instance as the Action Sentence.");
}
else
{
if (proposalLiteral.classType.Name != "SubstanceAdministrationProposal")
{
Console.WriteLine("Resulting proposal is not a substance administration proposal");
}
else
{
Console.WriteLine("Substance Administration Proposed: {0}.", (proposalLiteral.element.Single(e => e.name == "substanceAdministrationGeneralPurpose").value as elm.Code).display);
}
}
}
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
var content = response.Content.ReadAsStringAsync().Result;
if (content.Length > 0)
{
// NOTE: Deserialization here is assuming EvaluationException, need to peek into the Xml stream to determine the actual type.
var dssException = DSSExceptionExtensions.DeserializeFromString<EvaluationException>(content);
Console.WriteLine(dssException.GetType().Name);
Console.WriteLine(String.Join("\r\n", dssException.errorMessage));
if (dssException.value != null)
{
var cdsMessage = Packager.DecodeExecutionMessagePayload(dssException.value.base64EncodedPayload);
Console.WriteLine(cdsMessage.GetType().Name);
Console.WriteLine(cdsMessage.message.value);
}
}
}
Console.ReadLine();
}
public void PostValueAsXML()
{
string baseAddress = "http://localhost:9003/";
const string posted_datakey = "posted";
using (Microsoft.Owin.Hosting.WebApp.Start<ValuesStartup>(url: baseAddress))
{
using (var client = new System.Net.Http.HttpClient())
{
var response = client.PostAsXmlAsync(baseAddress + "api/values", posted_datakey).Result;
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.AreEqual<System.Net.HttpStatusCode>(System.Net.HttpStatusCode.NoContent, response.StatusCode);
Assert.AreEqual<string>("No Content", response.ReasonPhrase);
Assert.IsNotNull(ValuesController.PostRequest);
Assert.IsTrue(ValuesController.PostRequest.ContainsKey(posted_datakey));
Assert.AreEqual<string>("application/xml; charset=utf-8", ValuesController.PostRequest[posted_datakey].Content.Headers.ContentType.ToString());
Assert.IsNotNull(ValuesController.PostRequestValue);
Assert.IsTrue(ValuesController.PostRequestValue.Contains(posted_datakey));
}
}
}
public static void AddSong(HttpClient client, Song song)
{
HttpResponseMessage response = null;
if (client.DefaultRequestHeaders.Accept.Contains(new MediaTypeWithQualityHeaderValue("application/xml")))
{
response = client.PostAsXmlAsync<Song>("api/Song", song).Result;
}
else if (client.DefaultRequestHeaders.Accept.Contains(new MediaTypeWithQualityHeaderValue("application/json")))
{
response = client.PostAsJsonAsync<Song>("api/Song", song).Result;
}
if (response == null)
{
throw new InvalidOperationException("Client must use json or xml.");
}
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Song added.");
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
}
