/// <summary>
/// Initializes a new instance of the <see cref="RestApiAsyncClient" /> class.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="acceptGZip">if set to <c>true</c> [accept g zip].</param>
/// <param name="timeout">The timeout.</param>
public RestApiAsyncClient(ApiEndpoint endpoint, bool acceptGZip = false, int?timeout = null) : base(endpoint, acceptGZip, timeout)
{
_client = new HttpClient()
{
Timeout = new TimeSpan(0, 0, timeout ?? 30)
};
}
internal Uri ToAbsoluteURI(string relativePath, IEnumerable <RequestParam> requestParameters)
{
if (ApiEndpoint.HasPath())
{
throw new InvalidOperationException("apiEndpoint should not contain a path");
}
if (ApiEndpoint.HasUserInfoOrQueryOrFragment())
{
throw new InvalidOperationException("apiEndpoint should not contain user info, query or fragment");
}
string absolutePath = relativePath.StartsWith("/", StringComparison.Ordinal)
? relativePath
: "/" + relativePath;
UriBuilder uriBuilder = new UriBuilder
{
Scheme = ApiEndpoint.Scheme,
Host = ApiEndpoint.Host,
Port = ApiEndpoint.Port,
Path = absolutePath,
};
if (requestParameters != null)
{
foreach (RequestParam nvp in requestParameters)
{
uriBuilder.AddParameter(nvp.Name, nvp.Value);
}
}
return(uriBuilder.Uri);
}
private string ConstructNewRequestObject(Indent indent, ApiEndpoint apiEndpoint, string endpointPath)
{
var builder = new StringBuilder();
builder.AppendLine();
indent.Increment();
builder.AppendLine($"{indent}new {apiEndpoint.ToCSharpRequestBodyClassName(endpointPath)!}");
builder.AppendLine($"{indent}{{ ");
indent.Increment();
var typeNameForDto = apiEndpoint.ToCSharpRequestBodyClassName(endpointPath);
foreach (var field in apiEndpoint.RequestBody !.Fields)
{
if (field.Type.IsCSharpReferenceType())
{
builder.AppendLine($"{indent}{field.ToCSharpPropertyName(typeNameForDto)} = {field.ToCSharpVariableInstanceOrDefaultValue(_codeGenerationContext)},");
}
else
{
builder.AppendLine($"{indent}{field.ToCSharpPropertyName(typeNameForDto)} = {field.ToCSharpVariableName()},");
}
}
indent.Decrement();
builder.Append($"{indent}}}");
indent.Decrement();
return(builder.ToString());
}
private ApiEndpoint GetEndpoint(ConnectorRequest request)
{
// Resolve the endpoint entity
EndpointAddressResult address;
try
{
address = _endpointResolver.ResolveEndpoint(request.ApiPath, false);
}
catch (EndpointNotFoundException)
{
return(null); // can't find it, so return null
}
// Check the API
Api apiEntity = _entityRepository.Get <Api>(address.ApiId);
if (apiEntity == null)
{
return(null);
}
// Get the endpoint
ApiEndpoint endpointEntity = _entityRepository.Get <ApiEndpoint>(address.EndpointId);
return(endpointEntity);
}
public TagService(IHttpClientFactory httpClientFactory, ApiEndpoint apiEndpoint)
{
_httpClient = httpClientFactory.CreateClient();
tagsUrl = apiEndpoint.TagsEndpointUrl;
_httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(JwtBearerDefaults.AuthenticationScheme, jwtToken);
}
private void ServieHookappTimer(Object o)
{
var serverStats = ApiEndpoint.GetServerStats();
_serviceHookappStats.Add(serverStats);
File.WriteAllText(Const.SERVICE_HOOKAPP_HISTORY, JsonConvert.SerializeObject(_serviceHookappStats, Formatting.Indented));
}
private async Task <bool> ExecuteAsync()
{
string joinCharacter = ApiEndpoint.Contains("?") ? "&" : "?";
string apiUrl = ApiEndpoint + joinCharacter + "access_token=" + Uri.EscapeDataString(AccessToken);
Log.LogMessage(MessageImportance.Low, "Posting job to {0}", ApiEndpoint);
Log.LogMessage(MessageImportance.Low, "Event json is ", EventDataPath);
using (HttpClient client = new HttpClient())
{
int retryCount = 15;
while (true)
{
HttpResponseMessage response;
using (Stream stream = File.OpenRead(EventDataPath))
{
HttpContent contentStream = new StreamContent(stream);
contentStream.Headers.Add("Content-Type", "application/json");
response = await client.PostAsync(apiUrl, contentStream);
}
if (response.IsSuccessStatusCode)
{
JObject responseObject;
using (Stream stream = await response.Content.ReadAsStreamAsync())
using (StreamReader streamReader = new StreamReader(stream))
using (JsonReader jsonReader = new JsonTextReader(streamReader))
{
responseObject = JObject.Load(jsonReader);
}
JobId = (string)responseObject["Name"];
if (String.IsNullOrEmpty(JobId))
{
Log.LogError("Publish to '{0}' did not return a job ID", ApiEndpoint);
return(false);
}
Log.LogMessage(MessageImportance.High, "Started Helix job: CorrelationId = {0}", JobId);
return(true);
}
if (retryCount-- <= 0)
{
Log.LogError(
"Unable to publish to '{0}' after 15 retries. Received status code: {1} {2}",
ApiEndpoint,
response.StatusCode,
response.ReasonPhrase);
return(false);
}
Log.LogWarning("Failed to publish to '{0}', {1} retries remaining", ApiEndpoint, retryCount);
}
}
}
public static string GenerateId(ApiEndpoint endpoint, string input)
{
string id = "";
if (endpoint.EndpointName.ToLower() == "apod")
{
}
return(id);
}
public ApiEndpoint SaveEndPoint(ApiEndpoint apiEndpoint)
{
ApiEndpoint retVal = null;
if (apiEndpoint != null)
{
retVal = _model.ApiEndpoints.Add(apiEndpoint);
_model.SaveChanges();
}
return(retVal);
}
public async Task <T> ExecuteDataAsync <T>(ApiEndpoint <T> endpoint)
{
var response = await ExecuteAsync(endpoint);
if (response.Successful)
{
return(await response.GetDataAsync());
}
throw new InvalidOperationException("Operation was not successfull");
}
public static string?ToCSharpRequestBodyClassName(this ApiEndpoint subject, string endpointPath)
{
if (subject.RequestBody == null ||
subject.RequestBody.Kind != ApiFieldType.Object.ObjectKind.REQUEST_BODY)
{
return(null);
}
return(CSharpIdentifier.ForClassOrNamespace(endpointPath)
+ subject.Method.ToHttpMethod().ToLowerInvariant().ToUppercaseFirst()
+ "Request");
}
/// <summary>
/// To the aws credentials.
/// </summary>
/// <param name="apiEndpoint">The API endpoint.</param>
/// <returns>AWSCredentials.</returns>
protected static AWSCredentials ToAWSCredentials(ApiEndpoint apiEndpoint)
{
if (apiEndpoint != null)
{
var accessKey = apiEndpoint.Token;
var accessSecretKey = apiEndpoint.SecondaryToken;
return(new Amazon.Runtime.BasicAWSCredentials(accessKey, accessSecretKey));
}
return(null);
}
public Task <ApiResponse <T> > ExecuteAsync <T>(ApiEndpoint <T> endpoint)
{
return(InternalExecuteAsync(endpoint, (ex) => new ApiResponse <T>(ex), async(response) =>
{
var result = new ApiResponse <T>(response);
if (result.Successful)
{
await result.GetDataAsync();
}
return result;
}));
}
private static HttpResponseMessage HttpGet(ApiEndpoint apiEndpoint, string encodedQuery)
{
var url = string.Concat(apiEndpoint.Endpoint, encodedQuery);
HttpClient client = new HttpClient {
BaseAddress = new Uri(url)
};
client.DefaultRequestHeaders.Add(X_QUERYKEY_HEADER, apiEndpoint.ApiKey);
client.DefaultRequestHeaders.Add(CommonStrings.Accept, StandardHttpContentTypes.ApplicationJson);
HttpResponseMessage response = client.GetAsync(url).Result;
return(response);
}
/// <summary>
/// Gets the request URI.
/// </summary>
/// <param name="apiEndpoint">The API endpoint.</param>
/// <param name="realm">The realm.</param>
/// <param name="version">The version.</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="resourceAction">The resource action.</param>
/// <param name="key">The key.</param>
/// <param name="queryString">The query string.</param>
/// <returns></returns>
protected internal virtual string GetRequestUri(ApiEndpoint apiEndpoint, string realm, string version, string resourceName, string resourceAction, string key, Dictionary <string, string> queryString = null)
{
var url = string.Format("{0}{1}/{2}", GetRequestEndpoint(Endpoint, realm, version), resourceName, resourceAction).TrimEnd('/') + "/";
if (!string.IsNullOrWhiteSpace(key))
{
url += (key.ToUrlEncodedText() + "/");
}
if (queryString.HasItem())
{
url += ("?" + queryString.ToKeyValuePairString(encodeKeyValue: true));
}
return(url);
}
private static void AddObsoletes(string jsonFile, ApiEndpoint endpoint)
{
var directory = Path.GetDirectoryName(jsonFile);
var obsoleteFile = Path.Combine(directory, Path.GetFileNameWithoutExtension(jsonFile)) + ".obsolete.json";
if (!File.Exists(obsoleteFile))
{
return;
}
var json = File.ReadAllText(obsoleteFile);
var endpointOverride = JsonConvert.DeserializeObject <Dictionary <string, ApiEndpoint> >(json).First();
endpoint.ObsoleteQueryParameters = endpointOverride.Value?.Url?.Params ?? new Dictionary <string, ApiQueryParameters>();
endpoint.RemovedMethods = endpointOverride.Value?.RemovedMethods ?? new Dictionary <string, string>();
}
private string GenerateMethodsForApiEndpoint(ApiEndpoint apiEndpoint, string baseEndpointPath)
{
var builder = new StringBuilder();
builder.AppendLine(GenerateMethodForApiEndpoint(apiEndpoint, baseEndpointPath));
var isResponseBatch = apiEndpoint.ResponseBody is ApiFieldType.Object objectResponse &&
objectResponse.Kind == ApiFieldType.Object.ObjectKind.BATCH;
if (isResponseBatch && apiEndpoint.ResponseBody != null)
{
builder.AppendLine();
builder.AppendLine(GenerateEnumerableMethodForBatchApiEndpoint(apiEndpoint, baseEndpointPath));
}
return(builder.ToString());
}
private static void LoadOverridesOnEndpoint(ApiEndpoint endpoint)
{
var method = endpoint.CsharpNames.MethodName;
if (CodeConfiguration.ApiNameMapping.TryGetValue(endpoint.Name, out var mapsApiMethodName))
{
method = mapsApiMethodName;
}
var namespacePrefix = typeof(GlobalOverrides).Namespace + ".Endpoints.";
var typeName = namespacePrefix + method + "Overrides";
var type = GeneratorLocations.Assembly.GetType(typeName);
if (type != null && Activator.CreateInstance(type) is IEndpointOverrides overrides)
{
endpoint.Overrides = overrides;
}
}
public void apiEndpoint_should_save_to_database()
{
ApiEndpoint apiEndpoint = new ApiEndpoint()
{
AccountId = 1,
ApiKey = "Duiwoelskj3342ksd",
ApiKeyType = 2,
Curl = "testing",
Endpoint = "https://www.google.com",
NRSQLSyntax = "Select * from Transaction",
Title = "Test Api Endpoint"
};
var result = _apiEndPointRepository.SaveEndPoint(apiEndpoint);
Assert.IsNotNull(result);
Assert.IsTrue(result.Id > 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="RestApiClientBase" /> class.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="acceptGZip">if set to <c>true</c> [accept g zip].</param>
/// <param name="timeout">The timeout.</param>
public RestApiClientBase(ApiEndpoint endpoint, bool acceptGZip = false, int?timeout = null)
{
//Try detecting base client version and generated version.
if (ClientGeneratedVersion != BaseClientVersion)
{
throw new NotSupportedException(string.Format("ClientGeneratedVersion [{0}] doesnot match BaseClientVersion [{1}].", ClientGeneratedVersion, BaseClientVersion));
}
Endpoint = endpoint ?? new ApiEndpoint();
AcceptGZip = acceptGZip;
Timeout = timeout;
var actualType = GetType();
var version = (actualType.Assembly.GetCustomAttribute <BeyovaComponentAttribute>()?.UnderlyingObject?.Version).SafeToString(actualType.Assembly.GetName().Version.ToString());
UserAgent = string.Format("{0}/{1} BeyovaCommon/{2} .NET/{3}", actualType.Name, version, EnvironmentCore.CommonComponentInfo?.Version, Environment.Version.ToString());
}
public PaymentsService(string apiLogin, string apiKey, string merchantID, string language, bool testMode)
{
_apiLogin = apiLogin ?? throw new ArgumentNullException(nameof(apiLogin));
_apiKey = apiKey ?? throw new ArgumentNullException(nameof(apiKey));
_language = language;
_testMode = testMode;
_endpoint = ApiEndpoint.Payments(testMode);
_merchantID = merchantID;
_headers = new
{
Accept = "application/json",
Content_Type = "application/json"
};
_merchant = new Merchant
{
ApiKey = _apiKey,
ApiLogin = _apiLogin
};
}
public async Task <dynamic> Call(ApiEndpoint endpoint, dynamic body, List <int> expectedStatusCodes)
{
string url = this.Config.Protocol + "://" + this.Config.Host + ":" + this.Config.Port + endpoint.Path;
string data = "{}";
if (body != null)
{
data = JsonConvert.SerializeObject(body);
}
client.DefaultRequestHeaders.Clear();
foreach (var header in this.Authentication.PrepareHeaders(this.Config.ApiKey, endpoint.Method, endpoint.Path, data))
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
HttpResponseMessage response = null;
switch (endpoint.Method)
{
case Api.METHOD.GET:
response = await client.GetAsync(url);
break;
case Api.METHOD.POST:
response = await client.PostAsync(url, new StringContent(data, Encoding.UTF8, "application/json"));
break;
case Api.METHOD.DELETE:
response = await client.DeleteAsync(url);
break;
}
string responseBody = await HandleResponseAsync(response, expectedStatusCodes);
return(JsonConvert.DeserializeObject("{'statusCode': " + (int)response.StatusCode + "," + " 'body': " + responseBody + "}"));
}
public HttpResponseMessage Endpoints()
{
IList <ApiEndpoint> apiEndpoints = new List <ApiEndpoint>();
ApiExplorer apiExplorer = new ApiExplorer(ControllerContext.Configuration);
foreach (var endpoint in apiExplorer.ApiDescriptions)
{
ApiEndpoint apiEndpoint = apiEndpoints.FirstOrDefault(a => a.RouteTemplate.Equals(endpoint.Route.RouteTemplate));
if (apiEndpoint == null)
{
apiEndpoint = new ApiEndpoint(endpoint.Route.RouteTemplate);
apiEndpoints.Add(apiEndpoint);
}
apiEndpoint.AddMethod(endpoint.HttpMethod.Method);
}
return(Request.CreateResponse(HttpStatusCode.OK, apiEndpoints.OrderBy(a => a.RouteTemplate)));
}
private string GenerateMethodDocumentationForEndpoint(ApiEndpoint apiEndpoint)
{
var indent = new Indent();
var builder = new StringBuilder();
// Documentation for method
if (!string.IsNullOrEmpty(apiEndpoint.Documentation))
{
builder.Append(
indent.Wrap(
apiEndpoint.Documentation.ToCSharpDocumentationComment()));
}
// Remarks (required permissions)
if (apiEndpoint.Rights != null && apiEndpoint.Rights.Count > 0)
{
builder.AppendLine($"{indent}/// <remarks>");
builder.AppendLine($"{indent}/// Required permissions:");
builder.AppendLine($"{indent}/// <list type=\"bullet\">");
foreach (var apiRight in apiEndpoint.Rights)
{
builder.AppendLine($"{indent}/// <item>");
builder.AppendLine($"{indent}/// <term>{apiRight.Title}</term>");
if (!string.IsNullOrEmpty(apiRight.Description))
{
builder.AppendLine($"{indent}/// <description>{apiRight.Description}</description>");
}
builder.AppendLine($"{indent}/// </item>");
}
builder.AppendLine($"{indent}/// </list>");
builder.AppendLine($"{indent}/// </remarks>");
}
// Attributes
if (apiEndpoint.Deprecation != null)
{
builder.AppendLine(apiEndpoint.Deprecation.ToCSharpDeprecation());
}
return(builder.ToString());
}
} = 60; // Default to every minute
/// <summary>
/// Go over the values in the configuration and validate them and also fix any issues
/// such as leading characters etc,
/// </summary>
/// <returns></returns>
public Boolean Parse()
{
if ((SignalREndpoint ?? String.Empty).Trim() == String.Empty)
{
throw new Exception("No SignalR Endpoint defined for Application Monitor");
}
else
{
// Clean endpoint string
if (!SignalREndpoint.StartsWith('/'))
{
SignalREndpoint = $"/{SignalREndpoint}".Trim();
}
}
if ((ApiEndpoint ?? String.Empty).Trim() == String.Empty)
{
throw new Exception("No API Endpoint defined for Application Monitor");
}
{
// Clean endpoint string
if (!ApiEndpoint.StartsWith('/'))
{
ApiEndpoint = $"/{ApiEndpoint}".Trim();
}
}
if ((SaveLocation ?? String.Empty).Trim() == String.Empty)
{
throw new Exception("No save location defined for Application Monitor");
}
if (BackgroundTaskInterval < 60)
{
throw new Exception("Application Monitor Background Task Interval is too short at less than 60 seconds");
}
return(true);
}
public async Task StatusAsync([Summary("Name of service")] string service, [Summary("How many hours to go back for comparison stats")] int hours = 0)
{
_log.Info($"{Context.User.Username} executed !stats command with parameter {service}");
var builder = new EmbedBuilder()
{
Color = Const.DISCORD_EMBED_COLOR,
};
switch (service)
{
case "hookapp":
ServerStats stats = _stats.Where(o => string.IsNullOrEmpty(o.error)).LastOrDefault();
ServerStats compared = null;
if (stats == null)
{
_log.Info($"Ho history of stats available. Forcefully getting one from server.");
stats = ApiEndpoint.GetServerStats();
}
var historyList = _stats.Where(o => string.IsNullOrEmpty(o.error)).Take(_stats.Count() - 1).ToList();
if (hours.Equals(0))
{
compared = historyList.LastOrDefault();
}
else
{
_log.Info($"Getting history stats from {hours} hours ago");
var queryDay = DateTime.Now.Subtract(TimeSpan.FromHours(hours));
compared = historyList.OrderBy(o => Math.Abs((o.date.Subtract(queryDay).Ticks))).FirstOrDefault();
}
_log.Info($"Replying with server status for service {service}");
await Context.Channel.SendMessageAsync("", false, DiscordMessageFormatter.GetServiceHookappMessage(stats, compared).Build());
break;
}
}
public async Task Get()
{
const string expectedOutput = "Request handled by next request delegate";
var requestDelegate = new RequestDelegate((innerHttpContext) =>
{
innerHttpContext.Response.WriteAsync(expectedOutput);
return(Task.CompletedTask);
});
// Arrange
DefaultHttpContext defaultContext = new DefaultHttpContext();
defaultContext.Response.Body = new MemoryStream();
defaultContext.Request.Path = "/";
var infoHandler = new Mock <IInfoCollector>();
RegisterServiceWithInstance <IInfoCollector>(infoHandler.Object);
// Act
var middlewareInstance = new ApiEndpoint(
next: requestDelegate,
serviceScopeFactory: _serviceScopeFactory.Object);
await middlewareInstance.InvokeAsync(defaultContext);
infoHandler.Verify(x => x.AggregateData());
//defaultContext.Response.Body.Seek(0, SeekOrigin.Begin);
//var body = new StreamReader(defaultContext.Response.Body).ReadToEnd();
//var jsonData = JsonDocument.Parse(body);
//var items = jsonData.RootElement.EnumerateObject();
// Assert
//Assert.True(items.Count() > 0, "No data in JSON response");
}
private static void PatchRequestParameters(ApiEndpoint endpoint)
{
var newParams = ApiQueryParametersPatcher.Patch(endpoint.Name, endpoint.Url.Params, endpoint.Overrides);
endpoint.Url.Params = newParams;
}
public async Task <IPlatformResponse <T> > Request <T>(ApiEndpoint endpoint, string relativePath, CancellationToken cancellationToken, IProgress <ISDKProgress> progress = null, HttpMethod method = null, string body = null, byte[] rawData = null, string contentType = "application/json", IDictionary <string, string> headers = null)
{
var monitor = _container.Resolve <IProgressMonitor>();
if (progress != null)
{
monitor.Progress = progress;
monitor.Start();
}
monitor.Report("Initializing Http Request", 0);
var _method = HttpMethod.Get;
if (method != null)
{
_method = method;
}
var platformResponse = new PlatformResponse <T>
{
Success = false
};
if (headers != null && headers.Count > 0)
{
if (headers.ContainsKey("Authorization"))
{
var h = headers["Authorization"];
if (h.IndexOf(" ", StringComparison.Ordinal) > 0)
{
var type = h.Substring(0, h.IndexOf(" ", StringComparison.Ordinal)).Trim();
var token = h.Substring(h.IndexOf(" ", StringComparison.Ordinal)).Trim();
AuthorizationType = type;
Authorization.MojioApiToken = token;
headers.Remove("Authorization");
}
}
}
HttpClient client;
switch (endpoint)
{
case ApiEndpoint.Accounts:
client = AccountsClient(contentType);
break;
case ApiEndpoint.Images:
client = ImagesClient(contentType);
break;
case ApiEndpoint.Push:
client = PushClient(contentType);
break;
default:
client = ApiClient(contentType);
break;
}
var request = new HttpRequestMessage(_method, relativePath);
monitor.Report("Setting HttpContent Body", 0.1);
if (!string.IsNullOrEmpty(body))
{
Debug.WriteLine($"Request Content:{body}");
request.Content = new StringContent(body, Encoding.UTF8, contentType);
}
monitor.Report("Set HttpContent Body", 0.2);
if (rawData != null)
{
monitor.Report("Creating MultiPart Form Content", 0.2);
var requestContent = new MultipartFormDataContent(); //"Upload----" + DateTime.Now.ToString(CultureInfo.InvariantCulture));
var imageContent = new ByteArrayContent(rawData);
var fileName = "image.png";
var type = "image/png";
if (headers != null && headers.Count > 0)
{
type = (from x in headers where x.Key == "Content-Type" select x.Value).FirstOrDefault();
fileName = (from x in headers where x.Key == "Filename" select x.Value).FirstOrDefault();
if (!string.IsNullOrEmpty(type))
{
headers.Remove("Content-Type");
}
if (!string.IsNullOrEmpty(fileName))
{
headers.Remove("Filename");
}
}
imageContent.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse("form-data");
imageContent.Headers.ContentDisposition.Name = "\"file\"";
imageContent.Headers.ContentDisposition.FileName = fileName;
imageContent.Headers.ContentDisposition.Size = rawData.Length;
imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse(type);
requestContent.Add(imageContent);
request.Content = requestContent;
monitor.Report("Created MultiPart Form Content", 0.3);
}
monitor.Report("Adding Headers", 0.4);
if (headers != null && headers.Count > 0)
{
foreach (var h in headers)
{
request.Headers.Add(h.Key, h.Value);
}
}
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
if (DisableSessionAffinity)
{
request.Headers.Add("Arr-Disable-Session-Affinity", "True");
}
monitor.Report("Added Headers", 0.4);
if (cancellationToken.IsCancellationRequested)
{
platformResponse.WasCancelled = true;
monitor.Report("Operation Cancelled", 0.5);
return(platformResponse);
}
monitor.Report("Sending Http Request", 0.6);
var requestSw = new Stopwatch();
requestSw.Start();
Debug.WriteLine($"Pre-flight request URL: {request.RequestUri}");
using (var sendResult = await client.SendAsync(request, cancellationToken))
{
platformResponse.RequestDurationMS = requestSw.ElapsedMilliseconds;
monitor.Report("Received Response from Http Request", 0.7);
requestSw.Stop();
platformResponse.Url = sendResult.RequestMessage.RequestUri.ToString();
Debug.WriteLine($"Post-flight request URL: {platformResponse.Url}");
platformResponse.Timestamp = DateTimeOffset.UtcNow;
platformResponse.HttpStatusCode = sendResult.StatusCode;
Debug.WriteLine($"Status Code: {platformResponse.HttpStatusCode}");
try
{
var cookie = (from h in sendResult.Headers where h.Key == "Set-Cookie" select h.Value.FirstOrDefault()).FirstOrDefault();
if (cookie != null)
{
platformResponse.ARRAffinityInstance = (from c in cookie.Split(';') where c.StartsWith("") select c.Split('=').LastOrDefault()).FirstOrDefault();
}
}
catch (Exception)
{
}
if (sendResult.IsSuccessStatusCode)
{
monitor.Report("Received Successful StatusCode", 0.8);
if (cancellationToken.IsCancellationRequested)
{
platformResponse.WasCancelled = true;
monitor.Report("Operation Cancelled", 0.9);
return(platformResponse);
}
monitor.Report("Reading data from Response", 0.9);
var json = await sendResult.Content.ReadAsStringAsync();
monitor.Report("Deserializing data", 0.95);
try
{
platformResponse.Response = _serializer.Deserialize <T>(json);
if (platformResponse.Response != null)
{
platformResponse.Success = true;
}
}
catch (Exception e)
{
_log.Error(e, "Invalid response from the server. Received:{0}, expected:{1}. Will continue.", json, typeof(T));
}
if (typeof(T) == typeof(IAuthorization))
{
monitor.Report("Setting internal auth token", 0.99);
Authorization.MojioApiToken = (platformResponse.Response as IAuthorization).AccessToken;
_container.RegisterInstance(Authorization, "Session");
}
}
else
{
monitor.Report("Received Unsuccessful StatusCode", 0.8);
platformResponse.Success = false;
platformResponse.ErrorCode = sendResult.StatusCode.ToString();
platformResponse.ErrorMessage = sendResult.ReasonPhrase;
monitor.Report("Reading data from Response", 0.9);
var content = await sendResult.Content.ReadAsStringAsync();
Debug.WriteLine(content);
Debug.WriteLine(_serializer.SerializeToString(request));
if (!string.IsNullOrEmpty(content))
{
try
{
monitor.Report("Deserializing data", 0.95);
dynamic result = _serializer.Deserialize(content);
if (result != null)
{
if (result.Message != null)
{
platformResponse.ErrorMessage = platformResponse.ErrorMessage + ", " + result.Message;
}
else
{
platformResponse.ErrorMessage = platformResponse.ErrorMessage + ", " + content;
}
}
}
catch (Exception)
{
}
}
}
}
monitor.Report("Finished", 1);
monitor.Stop();
return(platformResponse);
}
public SharePointFileManager(IConfiguration Configuration)
{
// create the HttpClient that is used for our direct REST calls.
_CookieContainer = new CookieContainer();
_HttpClientHandler = new HttpClientHandler()
{
UseCookies = true, AllowAutoRedirect = false, CookieContainer = _CookieContainer
};
_Client = new HttpClient(_HttpClientHandler);
_Client.DefaultRequestHeaders.Add("Accept", "application/json;odata=verbose");
// SharePoint configuration settings.
string sharePointServerAppIdUri = Configuration["SHAREPOINT_SERVER_APPID_URI"];
string sharePointOdataUri = Configuration["SHAREPOINT_ODATA_URI"];
string sharePointWebname = Configuration["SHAREPOINT_WEBNAME"];
string sharePointNativeBaseURI = Configuration["SHAREPOINT_NATIVE_BASE_URI"];
// ADFS using fed auth
string sharePointStsTokenUri = Configuration["SHAREPOINT_STS_TOKEN_URI"]; // Full URI to the STS service we will use to get the initial token.
string sharePointRelyingPartyIdentifier = Configuration["SHAREPOINT_RELYING_PARTY_IDENTIFIER"]; // use Fiddler to grab this from an interactive session. Will normally start with urn:
string sharePointUsername = Configuration["SHAREPOINT_USERNAME"]; // Service account username. Be sure to add this user to the SharePoint instance.
string sharePointPassword = Configuration["SHAREPOINT_PASSWORD"]; // Service account password
// SharePoint Online
string sharePointAadTenantId = Configuration["SHAREPOINT_AAD_TENANTID"];
string sharePointClientId = Configuration["SHAREPOINT_CLIENT_ID"];
string sharePointCertFileName = Configuration["SHAREPOINT_CERTIFICATE_FILENAME"];
string sharePointCertPassword = Configuration["SHAREPOINT_CERTIFICATE_PASSWORD"];
// Basic Auth (SSG API Gateway)
string ssgUsername = Configuration["SSG_USERNAME"]; // BASIC authentication username
string ssgPassword = Configuration["SSG_PASSWORD"]; // BASIC authentication password
// sometimes SharePoint could be using a different username / password.
string sharePointSsgUsername = Configuration["SHAREPOINT_SSG_USERNAME"];
string sharePointSsgPassword = Configuration["SHAREPOINT_SSG_PASSWORD"];
if (string.IsNullOrEmpty(sharePointSsgUsername))
{
sharePointSsgUsername = ssgUsername;
}
if (string.IsNullOrEmpty(sharePointSsgPassword))
{
sharePointSsgPassword = ssgPassword;
}
OdataUri = sharePointOdataUri;
ServerAppIdUri = sharePointServerAppIdUri;
NativeBaseUri = sharePointNativeBaseURI;
WebName = sharePointWebname;
// ensure the webname has a slash.
if (!string.IsNullOrEmpty(WebName) && WebName[0] != '/')
{
WebName = "/" + WebName;
}
ApiEndpoint = sharePointOdataUri;
// ensure there is a trailing slash.
if (!ApiEndpoint.EndsWith("/"))
{
ApiEndpoint += "/";
}
ApiEndpoint += "_api/";
// Scenario #1 - ADFS (2016) using FedAuth
if (!string.IsNullOrEmpty(sharePointRelyingPartyIdentifier) &&
!string.IsNullOrEmpty(sharePointUsername) &&
!string.IsNullOrEmpty(sharePointPassword) &&
!string.IsNullOrEmpty(sharePointStsTokenUri)
)
{
Authorization = null;
var samlST = Authentication.GetStsSamlToken(sharePointRelyingPartyIdentifier, sharePointUsername, sharePointPassword, sharePointStsTokenUri).GetAwaiter().GetResult();
//FedAuthValue =
Authentication.GetFedAuth(sharePointOdataUri, samlST, sharePointRelyingPartyIdentifier, _Client, _CookieContainer).GetAwaiter().GetResult();
}
// Scenario #2 - SharePoint Online (Cloud) using a Client Certificate
else if (!string.IsNullOrEmpty(sharePointAadTenantId) &&
!string.IsNullOrEmpty(sharePointCertFileName) &&
!string.IsNullOrEmpty(sharePointCertPassword) &&
!string.IsNullOrEmpty(sharePointClientId)
)
{
// add authentication.
var authenticationContext = new AuthenticationContext(
"https://login.windows.net/" + sharePointAadTenantId);
// Create the Client cert.
X509Certificate2 cert = new X509Certificate2(sharePointCertFileName, sharePointCertPassword);
ClientAssertionCertificate clientAssertionCertificate = new ClientAssertionCertificate(sharePointClientId, cert);
//ClientCredential clientCredential = new ClientCredential(clientId, clientKey);
var task = authenticationContext.AcquireTokenAsync(sharePointServerAppIdUri, clientAssertionCertificate);
task.Wait();
authenticationResult = task.Result;
Authorization = authenticationResult.CreateAuthorizationHeader();
}
else
// Scenario #3 - Using an API Gateway with Basic Authentication. The API Gateway will handle other authentication and have different credentials, which may be NTLM
{
// authenticate using the SSG.
string credentials = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(sharePointSsgUsername + ":" + sharePointSsgPassword));
Authorization = "Basic " + credentials;
}
// Authorization header is used for Cloud or Basic API Gateway access
if (!string.IsNullOrEmpty(Authorization))
{
_Client.DefaultRequestHeaders.Add("Authorization", Authorization);
}
// Add a Digest header. Needed for certain API operations
Digest = GetDigest(_Client).GetAwaiter().GetResult();
if (Digest != null)
{
_Client.DefaultRequestHeaders.Add("X-RequestDigest", Digest);
}
// Standard headers for API access
_Client.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
_Client.DefaultRequestHeaders.Add("OData-Version", "4.0");
}
/// <summary>
/// Initializes a new instance of the <see cref="RestApiClient" /> class.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="acceptGZip">if set to <c>true</c> [accept g zip].</param>
public RestApiClient(ApiEndpoint endpoint, bool acceptGZip = false)
: this(endpoint?.ToString(), endpoint.Token, acceptGZip)
{
}
