/// <summary>
/// Peforms DELETE method
/// </summary>
/// <param name="uri"></param>
/// <param name="query"></param>
public void Delete(string uri, List <KeyValuePair <string, object> > query)
{
uri = UriUtil.BuildUri(uri, query);
try
{
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
HttpRequestMessage request = CreateDeleteRequest(uri);
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
long tStart = DateTime.Now.Ticks;
HttpResponseMessage message = response.Result;
long time = ((DateTime.Now.Ticks - tStart) / TimeSpan.TicksPerMillisecond);
long?requestSize = request.Content == null ? 0L : request.Content.Headers.ContentLength;
long?contentSize = message.Content == null ? 0L : message.Content.Headers.ContentLength;
LogPerformance(time, request.Method.ToString(), uri, requestSize == null ? 0L : requestSize.Value, contentSize == null ? 0L : contentSize.Value);
message.EnsureSuccessStatusCode();
}
catch (Exception e)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "Error URI: " + uri, e);
if (e.InnerException is TaskCanceledException)
{
throw new Exception("A timeout occurred waiting on a response from request: " + uri, e.InnerException);
}
}
}
/// <summary>
/// Raw Post
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="uri"></param>
/// <param name="requestBody"></param>
/// <param name="mimeType"></param>
/// <param name="query"></param>
/// <returns></returns>
public T PostRaw <T>(string uri, Stream requestBody, string mimeType, List <KeyValuePair <string, object> > query)
{
uri = UriUtil.BuildUri(uri, query);
T obj = default(T);
try
{
using (requestBody)
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = new StreamContent(requestBody);
request.Content.Headers.ContentType = new MediaTypeWithQualityHeaderValue(mimeType);
request.Headers.Accept.Add(JSON_GENERIC_MEDIA_TYPE);
SetBasicAuthHeader(request);
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
long tStart = DateTime.Now.Ticks;
HttpResponseMessage message = response.Result;
long time = ((DateTime.Now.Ticks - tStart) / TimeSpan.TicksPerMillisecond);
long?requestSize = request.Content == null ? 0L : request.Content.Headers.ContentLength;
long?contentSize = message.Content == null ? 0L : message.Content.Headers.ContentLength;
LogPerformance(time, request.Method.ToString(), uri, requestSize == null ? 0L : requestSize.Value, contentSize == null ? 0L : contentSize.Value);
message.EnsureSuccessStatusCode();
if (message.Content != null)
{
Task <Stream> result = message.Content.ReadAsStreamAsync();
obj = JsonSerializer.ReadObject <T>(result.Result);
}
}
}
catch (Exception e)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "Error URI: " + uri, e);
if (e.InnerException is TaskCanceledException)
{
throw new Exception("A timeout occurred waiting on a response from request: " + uri, e.InnerException);
}
}
if (obj != null && obj is Executable)
{
(obj as Executable).SetClient(this);
}
return(obj);
}
/// <summary>
/// Performs a POST method
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="R"></typeparam>
/// <param name="uri"></param>
/// <param name="requestBody"></param>
/// <param name="query"></param>
/// <returns></returns>
public R Post <T, R>(string uri, T requestBody, List <KeyValuePair <string, object> > query)
{
uri = UriUtil.BuildUri(uri, query);
R obj = default(R);
try
{
using (MemoryStream ms = new MemoryStream())
{
JsonSerializer.WriteObject(ms, requestBody);
byte[] requestInJson = ms.ToArray();
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
HttpRequestMessage request = CreatePostRequest(uri, requestBody);
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
long tStart = DateTime.Now.Ticks;
HttpResponseMessage message = response.Result;
long time = ((DateTime.Now.Ticks - tStart) / TimeSpan.TicksPerMillisecond);
long?requestSize = request.Content == null ? 0L : request.Content.Headers.ContentLength;
long?contentSize = message.Content == null ? 0L : message.Content.Headers.ContentLength;
LogPerformance(time, request.Method.ToString(), uri, requestSize == null? 0L: requestSize.Value, contentSize == null? 0L : contentSize.Value);
message.EnsureSuccessStatusCode();
if (message.Content != null)
{
Task <Stream> result = message.Content.ReadAsStreamAsync();
obj = JsonSerializer.ReadObject <R>(result.Result);
}
}
}
catch (Exception e)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "Error URI: " + uri, e);
if (e.InnerException is TaskCanceledException)
{
throw new Exception("A timeout occurred waiting on a response from request: " + uri, e.InnerException);
}
}
if (obj != null && obj is Executable)
{
(obj as Executable).SetClient(this);
}
return(obj);
}
/// <summary>
/// Performs a Async GET an Async GET against the URI given with the query/package passed
/// </summary>
/// <typeparam name="T">This is the Type that is passed</typeparam>
/// <param name="uri"></param>
/// <param name="query"></param>
/// <returns></returns>
public T Get <T>(string uri, List <KeyValuePair <string, object> > query)
{
T obj = default(T);
try
{
uri = UriUtil.BuildUri(uri, query);
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
HttpRequestMessage request = CreateGetRequest(uri);
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
long tStart = DateTime.Now.Ticks;
HttpResponseMessage message = response.Result;
long time = ((DateTime.Now.Ticks - tStart) / TimeSpan.TicksPerMillisecond);
long?requestSize = request.Content == null ? 0L : request.Content.Headers.ContentLength;
long?contentSize = message.Content == null ? 0L : message.Content.Headers.ContentLength;
LogPerformance(time, request.Method.ToString(), uri, requestSize == null ? 0L : requestSize.Value, contentSize == null ? 0L : contentSize.Value);
if (message.StatusCode == HttpStatusCode.Unauthorized)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "||" + uri, new Exception("AUTHENTICATION"));
throw new Exception("Authorization failed for user " + UserName
+ ". Ensure the correct credentials are specified in the configuration "
+ "file and that the account password has not expired or been locked out.");
}
message.EnsureSuccessStatusCode();
Task <Stream> result = message.Content.ReadAsStreamAsync();
obj = JsonSerializer.ReadObject <T>(result.Result);
}
catch (Exception e)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "Error URI: " + uri, e);
if (e.InnerException is TaskCanceledException)
{
throw new Exception("A timeout occurred waiting on a response from request: " + uri, e.InnerException);
}
}
if (obj is Executable)
{
(obj as Executable).SetClient(this);
}
return(obj);
}
/// <summary>
/// Posts multiparts
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="R"></typeparam>
/// <param name="uri"></param>
/// <param name="requestBody"></param>
/// <param name="otherParts"></param>
/// <param name="query"></param>
/// <returns></returns>
public R PostMultiparts <T, R>(string uri, T requestBody, IDictionary <Stream, string> otherParts, List <KeyValuePair <string, object> > query)
{
uri = UriUtil.BuildUri(uri, query);
R obj = default(R);
try
{
using (var multiPartStream = new MultipartFormDataContent())
{
MemoryStream stream = new MemoryStream();
JsonSerializer.WriteObject(stream, requestBody);
ByteArrayContent firstPart = new ByteArrayContent(stream.ToArray());
firstPart.Headers.ContentType = JSON_VND_MEDIA_TYPE;
firstPart.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "metadata"
};
multiPartStream.Add(firstPart);
stream.Dispose();
if (otherParts != null)
{
foreach (var other in otherParts)
{
StreamContent otherContent = new StreamContent(other.Key);
otherContent.Headers.ContentType = new MediaTypeHeaderValue(other.Value);
otherContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "binary"
};
multiPartStream.Add(otherContent);
}
}
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = multiPartStream;
request.Headers.Accept.Add(JSON_GENERIC_MEDIA_TYPE);
SetBasicAuthHeader(request);
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
long tStart = DateTime.Now.Ticks;
HttpResponseMessage message = response.Result;
long time = ((DateTime.Now.Ticks - tStart) / TimeSpan.TicksPerMillisecond);
long?requestSize = request.Content == null ? 0L : request.Content.Headers.ContentLength;
long?contentSize = message.Content == null ? 0L : message.Content.Headers.ContentLength;
LogPerformance(time, request.Method.ToString(), uri, requestSize == null ? 0L : requestSize.Value, contentSize == null ? 0L : contentSize.Value);
message.EnsureSuccessStatusCode();
if (message.Content != null)
{
Task <Stream> result = message.Content.ReadAsStreamAsync();
obj = JsonSerializer.ReadObject <R>(result.Result);
}
foreach (var other in otherParts)
{
other.Key.Dispose();
}
}
}
catch (Exception e)
{
WriteToLog(LogLevel.ERROR, this.GetType().Name, "Error URI: " + uri, e);
if (e.InnerException is TaskCanceledException)
{
throw new Exception("A timeout occurred waiting on a response from request: " + uri, e.InnerException);
}
}
if (obj != null && obj is Executable)
{
(obj as Executable).SetClient(this);
}
return(obj);
}
public static IEnumerable <Client> GetClients(IConfigurationSection configuration)
{
return(configuration
.GetChildren()
.Select(c =>
{
// TODO: check required config options
var baseUrl = c["Url"];
var client = new Client
{
ClientId = c["Id"],
ClientName = c["Name"],
AllowOfflineAccess = bool.TrueString.Equals(c["AllowOfflineAccess"]),
AllowedScopes = c.GetSection("AllowedScopes")
.GetChildren()
.Select(s => s.Value)
.ToArray(),
AllowedGrantTypes = c.GetSection("AllowedGrantTypes")
.GetChildren()
.Select(s => s.Value)
.ToArray(),
AllowedCorsOrigins = c.GetSection("AllowedCorsOrigins")
.GetChildren()
.Select(s => s.Value)
.ToArray(),
RedirectUris = c.GetSection("RedirectPaths")
.GetChildren()
.Select(s => UriUtil.BuildUri(s.Value, baseUrl))
.ToArray(),
PostLogoutRedirectUris = c.GetSection("PostLogoutRedirectPaths")
.GetChildren()
.Select(s => UriUtil.BuildUri(s.Value, baseUrl))
.ToArray(),
RequirePkce = bool.TrueString.Equals(c["RequirePkce"]),
RequireConsent = string.IsNullOrEmpty(c["RequireConsent"]) ||
bool.TrueString.Equals(c["RequireConsent"]),
RequireClientSecret = bool.TrueString.Equals(c["RequireClientSecret"]),
AllowAccessTokensViaBrowser = bool.TrueString.Equals(c["AllowAccessTokensViaBrowser"]),
Properties = c.GetSection("Properties")
.GetChildren()
.ToDictionary(s => s.Key, s => s.Value)
};
var clientSecret = c["Secret"];
if (!string.IsNullOrEmpty(clientSecret))
{
client.ClientSecrets = new[] { new Secret(clientSecret.Sha256()) };
}
var frontChannelLogoutPath = c["FrontChannelLogoutPath"];
if (!string.IsNullOrEmpty(frontChannelLogoutPath))
{
client.FrontChannelLogoutUri = UriUtil.BuildUri(frontChannelLogoutPath, baseUrl);
}
return client;
})
.ToArray());
}
public static void Run(RestController client, string RestHomeUri, string repositoryName)
{
HomeDocument home = client.Get <HomeDocument>(RestHomeUri, null);
Feed <Repository> repositories = home.GetRepositories <Repository>(new FeedGetOptions {
Inline = true, Links = true
});
Repository repository = repositories.FindInlineEntry(repositoryName);
BatchCapabilities batchCapabilities = repository.GetBatchCapabilities();
Console.WriteLine("Batch capabilities for this repository:");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(" - transactional or non-transactional? {0}", batchCapabilities.Transactions);
Console.WriteLine(" - sequential or non-sequential? {0}", batchCapabilities.Sequence);
Console.WriteLine(" - fail on error or continue on error? {0}", batchCapabilities.OnError);
Console.WriteLine(" - all resources are batch-able except these [{0}] ", String.Join(",", batchCapabilities.NonBatchableResources.ToArray <string>()));
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Press any key to continue batch test..");
Console.ReadKey();
Console.WriteLine(String.Format("\r\nPreparing data for the batch.."));
User currentUser = repository.GetCurrentUser(new SingleGetOptions());
Console.WriteLine("\t - Fetched current user: "******"user_name"));
Cabinet homeCabinet = currentUser.GetHomeCabinet(new SingleGetOptions());
Console.WriteLine("\t - Fetched home cabinet: " + homeCabinet.GetPropertyString("object_name"));
// start a batch - create 1 folder & 1 document under home cabinet + get dql + create a new relation
Console.WriteLine("\r\nReady to create a batch with 5 operations:");
string folderNamePrefix = "BatchTestFolder-";
Console.WriteLine("\t - (1) create a new folder under home cabinet with name prefix: " + folderNamePrefix);
string docNamePrefix = "BatchTestDoc-";
Console.WriteLine("\t - (2) create a new document under home cabinet with name: " + docNamePrefix);
string dql = "select * from dm_group";
Console.WriteLine("\t - (3) execute a dql query: " + dql);
Console.WriteLine("\t - (4) get all relations");
Console.WriteLine("\t - (5) create a new cabinet with empty name (should fail)");
Console.WriteLine("Press any key to run batch..");
Console.ReadKey();
List <KeyValuePair <string, object> > dqlParams = new List <KeyValuePair <string, object> >();
dqlParams.Add(new KeyValuePair <string, object>("dql", dql));
string dqlUri = UriUtil.BuildUri(LinkRelations.FindLinkAsString(repository.Links, LinkRelations.DQL.Rel), dqlParams);
Batch batch = Batch.CreateFromBuilder()
.Description("a sample batch with 4 operations")
.BatchSpec(new BatchSpec {
Transactional = false, Sequential = false, FailOnError = false, ReturnRequest = false
})
.AddOperation <Folder>(
"batch-opt-1", homeCabinet, LinkRelations.FOLDERS.Rel, "POST", ObjectUtil.NewRandomFolder(folderNamePrefix, "dm_folder")
)
.AddOperation <Document>(
"batch-opt-2", homeCabinet, LinkRelations.DOCUMENTS.Rel, "POST", ObjectUtil.NewRandomDocument(docNamePrefix, "dm_document")
)
.AddOperation(
"batch-opt-3", dqlUri, "GET"
)
.AddOperation(
"batch-opt-4", homeCabinet, LinkRelations.RELATIONS.Rel, "GET"
)
.AddOperation(
"batch-opt-5", repository, LinkRelations.CABINETS.Rel, "POST", new Cabinet()
)
.Build();
Batch result = repository.CreateBatch(batch);
Console.WriteLine("\r\nPrinting batch result..");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(String.Format(" - description [{0}]", result.Description));
Console.WriteLine(String.Format(" - owner [{0}]", result.Owner));
Console.WriteLine(String.Format(" - state [{0}]", result.State));
Console.WriteLine(String.Format(" - submitted [{0}]", result.Submitted));
Console.WriteLine(String.Format(" - started [{0}]", result.Started));
Console.WriteLine(String.Format(" - finished [{0}]", result.Finished));
foreach (BatchOperation operation in result.Operations)
{
Console.WriteLine(String.Format("\r\n - operation [{0}]", operation.Id));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(String.Format("\t--> state [{0}]", operation.State));
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(String.Format("\t--> started [{0}]", operation.Started));
Console.WriteLine(String.Format("\t--> finished [{0}]", operation.Finished));
Console.WriteLine("\t--> response");
Console.WriteLine(String.Format("\t-----------> status [{0}]", operation.Response.Status));
if (operation.Response.HasError())
{
Error error = operation.Response.GetError();
Console.WriteLine(String.Format("\t-----------> entity [{0}:{1}]", error.Code, error.Message));
}
else
{
if (operation.Id.Equals("batch-opt-1") || operation.Id.Equals("batch-opt-2"))
{
PersistentObject po = operation.Response.GetObject <PersistentObject>();
Console.WriteLine(String.Format("\t-----------> entity [object of URI {0}]", LinkRelations.FindLinkAsString(po.Links, LinkRelations.SELF.Rel)));
}
else if (operation.Id.Equals("batch-opt-3") || operation.Id.Equals("batch-opt-4"))
{
Feed <PersistentObject> feed = operation.Response.GetObject <Feed <PersistentObject> >();
Console.WriteLine(String.Format("\t-----------> entity [feed with title {0} and entry count {1}]", feed.Title, feed.Entries.Count));
}
}
}
Console.ForegroundColor = ConsoleColor.White;
}
