mirror of
https://github.com/Smaug123/WoofWare.Myriad
synced 2025-10-05 20:18:43 +00:00
1984 lines
88 KiB
Forth
1984 lines
88 KiB
Forth
//------------------------------------------------------------------------------
|
|
// This code was generated by myriad.
|
|
// Changes to this file will be lost when the code is regenerated.
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module PureGymApi =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IPureGymApi =
|
|
{ new IPureGymApi with
|
|
member _.GetGyms (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (("v1/gyms/"), System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Gym list"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return
|
|
jsonNode.AsArray ()
|
|
|> Seq.map (fun elt ->
|
|
(match elt with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected element of array (element type Gym) to be non-null, but found a null element"
|
|
)
|
|
| elt -> Gym.jsonParse elt)
|
|
)
|
|
|> List.ofSeq
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetGymAttendance (gymId : int, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
"v1/gyms/{gym_id}/attendance"
|
|
.Replace ("{gym_id}", gymId.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type GymAttendance"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return GymAttendance.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetGymAttendance' (gymId : int, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
"v1/gyms/{gym_id}/attendance"
|
|
.Replace ("{gym_id}", gymId.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type GymAttendance"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return GymAttendance.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetMember (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("v1/member", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Member"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return Member.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetGym (gym : int, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
"v1/gyms/{gym}".Replace ("{gym}", gym.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Gym"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return Gym.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetMemberActivity (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("v1/member/activity", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type MemberActivityDto"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return MemberActivityDto.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetUrl (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("some/url", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type UriThing"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return UriThing.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.PostStringToString (foo : Map<string, string> option, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("some/url", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
foo
|
|
|> (fun field ->
|
|
match field with
|
|
| None -> None
|
|
| Some field ->
|
|
(field
|
|
|> (fun field ->
|
|
let ret = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
for (KeyValue (key, value)) in field do
|
|
let key = key.ToString ()
|
|
|
|
ret.Add (
|
|
key,
|
|
(fun field ->
|
|
let field =
|
|
System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
value
|
|
)
|
|
|
|
ret
|
|
))
|
|
:> System.Text.Json.Nodes.JsonNode
|
|
|> Some
|
|
)
|
|
|> (fun node ->
|
|
match node with
|
|
| None -> "null"
|
|
| Some node -> node.ToJsonString ()
|
|
),
|
|
null,
|
|
"application/json"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode = jsonNode |> Option.ofObj
|
|
|
|
return
|
|
match jsonNode with
|
|
| None -> None
|
|
| Some v ->
|
|
v.AsObject ()
|
|
|> Seq.map (fun kvp ->
|
|
let key = (kvp.Key)
|
|
let value = kvp.Value
|
|
|
|
key,
|
|
(match value with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected dictionary value of type string to be non-null, but it was null"
|
|
)
|
|
| value -> value.AsValue().GetValue<System.String> ())
|
|
)
|
|
|> Map.ofSeq
|
|
|> Some
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetSessions (fromDate : DateOnly, toDate : DateOnly, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
("/v2/gymSessions/member"
|
|
+ (if "/v2/gymSessions/member".IndexOf (char 63) >= 0 then
|
|
"&"
|
|
else
|
|
"?")
|
|
+ "fromDate="
|
|
+ ((fromDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)
|
|
+ "&toDate="
|
|
+ ((toDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Sessions"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return Sessions.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetSessionsWithQuery (fromDate : DateOnly, toDate : DateOnly, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
("/v2/gymSessions/member?foo=1"
|
|
+ (if "/v2/gymSessions/member?foo=1".IndexOf (char 63) >= 0 then
|
|
"&"
|
|
else
|
|
"?")
|
|
+ "fromDate="
|
|
+ ((fromDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)
|
|
+ "&toDate="
|
|
+ ((toDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Sessions"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return Sessions.jsonParse jsonNode
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserString (user : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.StringContent (user)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserStream (user : System.IO.Stream, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.StreamContent (user)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserByteArr (user : byte[], ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.ByteArrayContent (user)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserByteArr' (user : array<byte>, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.ByteArrayContent (user)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserByteArr'' (user : byte array, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.ByteArrayContent (user)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserSerialisedBody (user : PureGym.Member, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
user |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
|
|
null,
|
|
"application/json"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserSerialisedUrlBody (user : Uri, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
user
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<Uri> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type URI to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
|> (fun node -> node.ToJsonString ()),
|
|
null,
|
|
"application/json"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserSerialisedIntBody (user : int, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
user
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
|> (fun node -> node.ToJsonString ()),
|
|
null,
|
|
"application/json"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.CreateUserHttpContent (user : System.Net.Http.HttpContent, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("users/new", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
do httpMessage.Content <- user
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetStream (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetStream' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetStream'' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
return responseStream
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponseMessage (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponseMessage' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponseMessage'' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponseMessage''' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponse (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Response<MemberActivityDto>"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return
|
|
new RestEase.Response<_> (
|
|
responseString,
|
|
response,
|
|
(fun () -> (MemberActivityDto.jsonParse jsonNode))
|
|
)
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponse' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type RestEase.Response<MemberActivityDto>"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return
|
|
new RestEase.Response<_> (
|
|
responseString,
|
|
response,
|
|
(fun () -> (MemberActivityDto.jsonParse jsonNode))
|
|
)
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponse'' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type Response<MemberActivityDto>"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return
|
|
new RestEase.Response<_> (
|
|
responseString,
|
|
response,
|
|
(fun () -> (MemberActivityDto.jsonParse jsonNode))
|
|
)
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetResponse''' (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
|
|
|
|
let! jsonNode =
|
|
System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
|
|
|> Async.AwaitTask
|
|
|
|
let jsonNode =
|
|
(match jsonNode with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Response from server was the JSON null object; expected a non-nullable type RestEase.Response<MemberActivityDto>"
|
|
)
|
|
| jsonNode -> jsonNode)
|
|
|
|
return
|
|
new RestEase.Response<_> (
|
|
responseString,
|
|
response,
|
|
(fun () -> (MemberActivityDto.jsonParse jsonNode))
|
|
)
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetWithAnyReturnCode (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
|
|
member _.GetWithoutAnyReturnCode (ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/"
|
|
| v -> v),
|
|
System.Uri ("endpoint", System.UriKind.Relative)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
return response
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module internal ApiWithoutBaseAddress =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithoutBaseAddress =
|
|
{ new IApiWithoutBaseAddress with
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithBasePath =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithBasePath =
|
|
{ new IApiWithBasePath with
|
|
member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri ("foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithBasePathAndAddress =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAddress =
|
|
{ new IApiWithBasePathAndAddress with
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/thing/"
|
|
| v -> v),
|
|
System.Uri ("foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithAbsoluteBasePath =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePath =
|
|
{ new IApiWithAbsoluteBasePath with
|
|
member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri ("/foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithAbsoluteBasePathAndAddress =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAddress =
|
|
{ new IApiWithAbsoluteBasePathAndAddress with
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/thing/"
|
|
| v -> v),
|
|
System.Uri ("/foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithBasePathAndAbsoluteEndpoint =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAbsoluteEndpoint =
|
|
{ new IApiWithBasePathAndAbsoluteEndpoint with
|
|
member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri ("foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"/endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithBasePathAndAddressAndAbsoluteEndpoint =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAddressAndAbsoluteEndpoint =
|
|
{ new IApiWithBasePathAndAddressAndAbsoluteEndpoint with
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/thing/"
|
|
| v -> v),
|
|
System.Uri ("foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"/endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithAbsoluteBasePathAndAbsoluteEndpoint =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAbsoluteEndpoint =
|
|
{ new IApiWithAbsoluteBasePathAndAbsoluteEndpoint with
|
|
member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri ("/foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"/endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint =
|
|
{ new IApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint with
|
|
member _.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null -> System.Uri "https://whatnot.com/thing/"
|
|
| v -> v),
|
|
System.Uri ("/foo/", System.UriKind.Relative)
|
|
),
|
|
System.Uri (
|
|
"/endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithHeaders =
|
|
/// Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties.
|
|
let make
|
|
(someHeader : unit -> string)
|
|
(someOtherHeader : unit -> int)
|
|
(client : System.Net.Http.HttpClient)
|
|
: IApiWithHeaders
|
|
=
|
|
{ new IApiWithHeaders with
|
|
member _.SomeHeader : string = someHeader ()
|
|
member _.SomeOtherHeader : int = someOtherHeader ()
|
|
|
|
member this.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
do httpMessage.Headers.Add ("X-Foo", this.SomeHeader.ToString ())
|
|
do httpMessage.Headers.Add ("Authorization", this.SomeOtherHeader.ToString ())
|
|
do httpMessage.Headers.Add ("Header-Name", "Header-Value")
|
|
do httpMessage.Headers.Add ("Something-Else", "val")
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ApiWithHeaders2 =
|
|
/// Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties.
|
|
let make
|
|
(someHeader : unit -> string)
|
|
(someOtherHeader : unit -> int)
|
|
(client : System.Net.Http.HttpClient)
|
|
: IApiWithHeaders2
|
|
=
|
|
{ new IApiWithHeaders2 with
|
|
member _.SomeHeader : string = someHeader ()
|
|
member _.SomeOtherHeader : int = someOtherHeader ()
|
|
|
|
member this.GetPathParam (parameter : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Get,
|
|
RequestUri = uri
|
|
)
|
|
|
|
do httpMessage.Headers.Add ("X-Foo", this.SomeHeader.ToString ())
|
|
do httpMessage.Headers.Add ("Authorization", this.SomeOtherHeader.ToString ())
|
|
do httpMessage.Headers.Add ("Header-Name", "Header-Value")
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ClientWithJsonBody =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IClientWithJsonBody =
|
|
{ new IClientWithJsonBody with
|
|
member _.GetPathParam (parameter : string, mem : PureGym.Member, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
mem |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
|
|
null,
|
|
"application/json"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ClientWithJsonBodyOverridden =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IClientWithJsonBodyOverridden =
|
|
{ new IClientWithJsonBodyOverridden with
|
|
member _.GetPathParam (parameter : string, mem : PureGym.Member, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams =
|
|
new System.Net.Http.StringContent (
|
|
mem |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
|
|
null,
|
|
"application/ecmascript"
|
|
)
|
|
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|
|
namespace PureGym
|
|
|
|
open System
|
|
open System.Threading
|
|
open System.Threading.Tasks
|
|
open System.IO
|
|
open System.Net
|
|
open System.Net.Http
|
|
open RestEase
|
|
|
|
/// Module for constructing a REST client.
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
|
|
module ClientWithStringBody =
|
|
/// Create a REST client.
|
|
let make (client : System.Net.Http.HttpClient) : IClientWithStringBody =
|
|
{ new IClientWithStringBody with
|
|
member _.GetPathParam (parameter : string, mem : string, ct : CancellationToken option) =
|
|
async {
|
|
let! ct = Async.CancellationToken
|
|
|
|
let uri =
|
|
System.Uri (
|
|
(match client.BaseAddress with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException (
|
|
nameof (client.BaseAddress),
|
|
"No base address was supplied on the type, and no BaseAddress was on the HttpClient."
|
|
)
|
|
)
|
|
| v -> v),
|
|
System.Uri (
|
|
"endpoint/{param}"
|
|
.Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
|
|
System.UriKind.Relative
|
|
)
|
|
)
|
|
|
|
let httpMessage =
|
|
new System.Net.Http.HttpRequestMessage (
|
|
Method = System.Net.Http.HttpMethod.Post,
|
|
RequestUri = uri
|
|
)
|
|
|
|
let queryParams = new System.Net.Http.StringContent (mem)
|
|
do httpMessage.Content <- queryParams
|
|
let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
|
|
let response = response.EnsureSuccessStatusCode ()
|
|
let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
|
|
return responseString
|
|
}
|
|
|> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
|
|
}
|