protected async virtual Task <IResponse> BuildResponse(HttpResponseMessage responseMessage) { Ensure.ArgumentIsNotNull(responseMessage, "responseMessage"); object responseBody = null; string contentType = null; using (var content = responseMessage.Content) { if (content != null) { contentType = GetContentMediaType(responseMessage.Content); // We added support for downloading images and zip-files. Let's constrain this appropriately. if (contentType != null && (contentType.StartsWith("image/") || contentType.Equals("application/zip", StringComparison.OrdinalIgnoreCase))) { responseBody = await responseMessage.Content.ReadAsByteArrayAsync().ConfigureAwait(false); } else { responseBody = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); } } } return(new Response( responseMessage.StatusCode, responseBody, responseMessage.Headers.ToDictionary(h => h.Key, h => h.Value.First()), contentType)); }
public Task <IApiResponse <T> > Patch <T>(Uri uri, object body) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(body, "body"); return(SendData <T>(uri, HttpVerb.Patch, body, null, null, CancellationToken.None)); }
/// <summary> /// Creates a new connection instance used to make requests of the Sulekha Property API. /// </summary> /// <param name="baseAddress">The address to point this client to, such as https://api.tookanapp.com:8888.</param> /// <param name="credentialStore">Provides credentials to the client when making requests</param> /// <param name="httpClient">A raw <see cref="IHttpClient"/> used to make requests</param> /// <param name="serializer">Class used to serialize and deserialize JSON requests</param> /// <param name="jsonPipeline">Json Pipeline used to serialize and deserialize.</param> public Connection( Uri baseAddress, ICredentialStore credentialStore, IHttpClient httpClient, ISerializationService serializer, IJsonHttpPipeline jsonPipeline) { Ensure.ArgumentIsNotNull(baseAddress, nameof(baseAddress)); Ensure.ArgumentIsNotNull(credentialStore, nameof(credentialStore)); Ensure.ArgumentIsNotNull(httpClient, nameof(httpClient)); Ensure.ArgumentIsNotNull(serializer, nameof(serializer)); Ensure.ArgumentIsNotNull(jsonPipeline, nameof(jsonPipeline)); if (!baseAddress.IsAbsoluteUri) { throw new ArgumentException( string.Format(CultureInfo.InvariantCulture, "The base address '{0}' must be an absolute URI", baseAddress), nameof(baseAddress)); } BaseAddress = baseAddress; _authenticator = new Authenticator(credentialStore); _httpClient = httpClient; _jsonPipeline = jsonPipeline; }
public Task <IApiResponse <T> > Post <T>(Uri uri, object body, string accepts, string contentType, Uri baseAddress) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(body, "body"); return(SendData <T>(uri, HttpMethod.Post, body, accepts, contentType, CancellationToken.None, baseAddress: baseAddress)); }
/// <summary> /// Initializes a new API client. /// </summary> /// <param name="apiConnection">The client's connection</param> protected ApiClient(IApiConnection apiConnection) { Ensure.ArgumentIsNotNull(apiConnection, "apiConnection"); ApiConnection = apiConnection; Connection = apiConnection.Connection; }
public static TValue SafeGet <TKey, TValue>(this IReadOnlyDictionary <TKey, TValue> dictionary, TKey key) { Ensure.ArgumentIsNotNull(dictionary, "dictionary"); TValue value; return(dictionary.TryGetValue(key, out value) ? value : default(TValue)); }
public static Task <IApiResponse <T> > GetRedirect <T>(this IConnection connection, Uri uri) { Ensure.ArgumentIsNotNull(connection, "connection"); Ensure.ArgumentIsNotNull(uri, "uri"); return(connection.Get <T>(uri, null, null, false)); }
/// <summary> /// Deletes the API object at the specified URI. /// </summary> /// <param name="uri">URI of the API resource to delete</param> /// <param name="data">Object that describes the API resource; this will be serialized and used as the request's body</param> /// <returns>A <see cref="Task"/> for the request's execution.</returns> public Task Delete(Uri uri, object data) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(data, "data"); return(Connection.Delete(uri, data)); }
/// <summary> /// Creates a new API resource in the list at the specified URI. /// </summary> /// <typeparam name="T">The API resource's type.</typeparam> /// <param name="uri">URI of the API resource to get</param> /// <param name="data">Object that describes the new API resource; this will be serialized and used as the request's body</param> /// <returns>The created API resource.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public Task <T> Post <T>(Uri uri, object data) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(data, "data"); return(Post <T>(uri, data, null, null)); }
/// <summary> /// Gets the API resource at the specified URI. /// </summary> /// <typeparam name="T">Type of the API resource to get.</typeparam> /// <param name="connection">The connection to use</param> /// <param name="uri">URI of the API resource to get</param> /// <param name="cancellationToken">A token used to cancel the GetResponse request</param> /// <returns>The API resource.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public static Task <IApiResponse <T> > GetResponse <T>(this IConnection connection, Uri uri, CancellationToken cancellationToken) { Ensure.ArgumentIsNotNull(connection, "connection"); Ensure.ArgumentIsNotNull(uri, "uri"); return(connection.Get <T>(uri, null, null, cancellationToken)); }
public static ApiInfo ParseResponseHeaders(IDictionary <string, string> responseHeaders) { Ensure.ArgumentIsNotNull(responseHeaders, "responseHeaders"); var oauthScopes = new List <string>(); var acceptedOauthScopes = new List <string>(); string etag = null; if (responseHeaders.ContainsKey("X-Accepted-OAuth-Scopes")) { acceptedOauthScopes.AddRange(responseHeaders["X-Accepted-OAuth-Scopes"] .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries) .Select(x => x.Trim())); } if (responseHeaders.ContainsKey("X-OAuth-Scopes")) { oauthScopes.AddRange(responseHeaders["X-OAuth-Scopes"] .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries) .Select(x => x.Trim())); } if (responseHeaders.ContainsKey("ETag")) { etag = responseHeaders["ETag"]; } return(new ApiInfo(oauthScopes, acceptedOauthScopes, etag, new RateLimit(responseHeaders))); }
public Task <IApiResponse <T> > Post <T>(Uri uri, object body, string accepts, string contentType, TimeSpan timeout) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(body, "body"); return(SendData <T>(uri, HttpMethod.Post, body, accepts, contentType, timeout, CancellationToken.None)); }
/// <summary> /// Gets all API resources in the list at the specified URI. /// </summary> /// <typeparam name="T">Type of the API resource in the list.</typeparam> /// <param name="connection">The connection to use</param> /// <param name="uri">URI of the API resource to get</param> /// <returns><see cref="IReadOnlyList{T}"/> of the The API resources in the list.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public static Task <IReadOnlyList <T> > GetAll <T>(this IApiConnection connection, Uri uri) { Ensure.ArgumentIsNotNull(connection, "connection"); Ensure.ArgumentIsNotNull(uri, "uri"); return(connection.GetAll <T>(uri, null)); }
void GenerateReports(ReportResult reportResult, string reportTypes) { Ensure.ArgumentIsNotNull(reportResult, "reportResult"); if (BuildEnvironment.IsTeamCityBuild) { TeamCityReportGenerator.RenderReport(reportResult, this); } if (String.IsNullOrEmpty(reportTypes)) { return; } Log(Level.Info, "Generating reports"); foreach (string reportType in reportTypes.Split(';')) { string reportFileName = null; Log(Level.Verbose, "Report type: {0}", reportType); switch (reportType.ToLower()) { case "text": reportFileName = TextReport.RenderToText(reportResult, ReportDirectory, ReportFileNameFormat); break; case "xml": reportFileName = XmlReport.RenderToXml(reportResult, ReportDirectory, ReportFileNameFormat); break; case "html": reportFileName = HtmlReport.RenderToHtml(reportResult, ReportDirectory, ReportFileNameFormat); break; case "dox": reportFileName = DoxReport.RenderToDox(reportResult, ReportDirectory, ReportFileNameFormat); break; case "transform": if (Transform == null) { throw new BuildException(String.Format("No transform specified for report type '{0}'", reportType)); } reportFileName = HtmlReport.RenderToHtml(reportResult, ReportDirectory, Transform.FullName, TransformReportFileNameFormat); break; default: Log(Level.Error, "Unknown report type {0}", reportType); break; } if (reportFileName != null) { Log(Level.Info, "Created report at {0}", reportFileName); } } }
public static Task <IResponse> Send(this IHttpClient httpClient, IRequest request) { Ensure.ArgumentIsNotNull(httpClient, "httpClient"); Ensure.ArgumentIsNotNull(request, "request"); return(httpClient.Send(request, CancellationToken.None)); }
private PageProperty CreateProperty(PageNode pageNode, PagePropertyTemplate propertyTemplate, string text = null, bool commit = true) { Ensure.ArgumentIsNotNull(pageNode, "pageNode"); Ensure.ArgumentIsNotNull(propertyTemplate, "propertyTemplate"); var propertyDbSet = _unitOfWork.Context.GetDbSet <PageProperty>(); var property = propertyDbSet.Create(); property.PropertyTemplate = propertyTemplate; property.ParentPageNode = pageNode; property.Text = text; property.Order = pageNode.Properties == null || !pageNode.Properties.Any() ? CmsConstants.FirstOrderNumber : pageNode.Properties.Count(); propertyDbSet.Add(property); if (commit) { _unitOfWork.Commit(); } return(property); }
public PageProperty Create(PageNode pageNode, PagePropertyTemplate propertyTemplate, string text = null, bool commit = true) { Ensure.ArgumentIsNotNull(pageNode, "pageNode"); Ensure.ArgumentIsNotNull(propertyTemplate, "propertyTemplate"); return(CreateProperty(pageNode, propertyTemplate, text, commit)); }
public Response(IDictionary <string, string> headers) { Ensure.ArgumentIsNotNull(headers, "headers"); Headers = new ReadOnlyDictionary <string, string>(headers); ApiInfo = ApiInfoParser.ParseResponseHeaders(headers); }
public NAntRunListener(Task task) { Ensure.ArgumentIsNotNull(task, "task"); _task = task; UpdateNAntProperties(_task.Properties, 0, 0, 0, 0, 0, 0); }
/// <summary> /// Gets the API resource at the specified URI. /// </summary> /// <typeparam name="T">Type of the API resource to get.</typeparam> /// <param name="uri">URI of the API resource to get</param> /// <param name="parameters">Parameters to add to the API request</param> /// <returns>The API resource.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public async Task <T> Get <T>(Uri uri, IDictionary <string, string> parameters) { Ensure.ArgumentIsNotNull(uri, "uri"); var response = await Connection.Get <T>(uri, parameters, null).ConfigureAwait(false); return(response.Body); }
public async Task Apply(IRequest request) { Ensure.ArgumentIsNotNull(request, "request"); var credentials = await CredentialStore.GetCredentials().ConfigureAwait(false) ?? Credentials.Anonymous; authenticators[credentials.AuthenticationType].Authenticate(request, credentials); }
public ApiResponse(IResponse response, T bodyAsObject, ResponseInfo responseInfo = null) { Ensure.ArgumentIsNotNull(response, "response"); HttpResponse = response; Body = bodyAsObject; ResponseInfo = responseInfo; }
public TeamCityMessageProvider(TeamCityLogWriter writer, Task taskToUseForLogging) { Ensure.ArgumentIsNotNull(writer, "writer"); Ensure.ArgumentIsNotNull(taskToUseForLogging, "taskToUseForLogging"); _writer = writer; _writer.TaskToUseForLogging = taskToUseForLogging; }
/// <summary> /// Performs an asynchronous HTTP POST request. /// </summary> /// <param name="uri">URI endpoint to send request to</param> /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns> public async Task <HttpStatusCode> Post(Uri uri) { Ensure.ArgumentIsNotNull(uri, nameof(uri)); var response = await SendData <object>(uri, HttpMethod.Post, null, null, null, CancellationToken.None); return(response.HttpResponse.StatusCode); }
public RateLimit(IDictionary <string, string> responseHeaders) { Ensure.ArgumentIsNotNull(responseHeaders, "responseHeaders"); Limit = (int)GetHeaderValueAsInt32Safe(responseHeaders, "X-RateLimit-Limit"); Remaining = (int)GetHeaderValueAsInt32Safe(responseHeaders, "X-RateLimit-Remaining"); Reset = GetHeaderValueAsInt32Safe(responseHeaders, "X-RateLimit-Reset").FromUnixTime(); }
/// <summary> /// Performs an asynchronous HTTP POST request. /// Attempts to map the response body to an object of type <typeparamref name="T"/> /// </summary> /// <typeparam name="T">The type to map the response to</typeparam> /// <param name="uri">URI endpoint to send request to</param> /// <param name="body">The object to serialize as the body of the request</param> /// <param name="accepts">Specifies accepted response media types.</param> /// <param name="contentType">Specifies the media type of the request body</param> /// <param name="twoFactorAuthenticationCode">Two Factor Authentication Code</param> /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns> public Task <IApiResponse <T> > Post <T>(Uri uri, object body, string accepts, string contentType, string twoFactorAuthenticationCode) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(body, "body"); Ensure.ArgumentIsNotNullOrEmptyString(twoFactorAuthenticationCode, "twoFactorAuthenticationCode"); return(SendData <T>(uri, HttpMethod.Post, body, accepts, contentType, CancellationToken.None, twoFactorAuthenticationCode)); }
/// <summary> /// Creates or replaces the API resource at the specified URI. /// </summary> /// <typeparam name="T">The API resource's type.</typeparam> /// <param name="uri">URI of the API resource to create or replace</param> /// <param name="data">Object that describes the API resource; this will be serialized and used as the request's body</param> /// <param name="twoFactorAuthenticationCode">The two-factor authentication code in response to the current user's previous challenge</param> /// <param name="accepts">Accept header to use for the API request</param> /// <returns>The created API resource.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public async Task <T> Put <T>(Uri uri, object data, string twoFactorAuthenticationCode, string accepts) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(data, "data"); var response = await Connection.Put <T>(uri, data, twoFactorAuthenticationCode, accepts).ConfigureAwait(false); return(response.Body); }
/// <summary> /// Updates the API resource at the specified URI. /// </summary> /// <typeparam name="T">The API resource's type.</typeparam> /// <param name="uri">URI of the API resource to update</param> /// /// <param name="data">Object that describes the API resource; this will be serialized and used as the request's body</param> /// <returns>The updated API resource.</returns> /// <exception cref="ApiException">Thrown when an API error occurs.</exception> public async Task <T> Patch <T>(Uri uri, object data) { Ensure.ArgumentIsNotNull(uri, "uri"); Ensure.ArgumentIsNotNull(data, "data"); var response = await Connection.Patch <T>(uri, data).ConfigureAwait(false); return(response.Body); }
public T GetModel <T>(HttpContextBase httpContextBase) where T : class, new() { var currentRouteData = httpContextBase.Request.RequestContext.RouteData; Ensure.ArgumentIsNotNull(currentRouteData, "currentRouteData"); var routeDataValues = currentRouteData.Values.ToList(); var cmsRouteDataValues = GetCmsRouteDataValues(routeDataValues); var controllerName = cmsRouteDataValues[0].Value.ToString(); var sectionNode = _sectionNodeService.GetByUrlName(controllerName); if (sectionNode == null) { throw new ArgumentException(string.Format(Messages.SectionNodeNotFoundForUrlName, controllerName)); } PageNode pageNode = null; for (var i = 0; i < cmsRouteDataValues.Count; i++) { if (i == 0) { continue; //skip the controller route data value } pageNode = i == 1 ? NodeHelper.GetActionPageNode(sectionNode.PageNodes, cmsRouteDataValues[i].Value.ToString()) : NodeHelper.GetActionPageNode(pageNode.PageNodes, cmsRouteDataValues[i].Value.ToString()); if (pageNode == null) { throw new ArgumentException(string.Format("The page with the url name : {0} was not found.", cmsRouteDataValues[i].Value)); } } var modelName = pageNode.PageTemplate.ModelName; var modelType = Assembly.GetCallingAssembly().GetModels().FirstOrDefault(x => x.Name == modelName); var modelInstance = (T)Activator.CreateInstance(modelType); var props = modelType.GetMembers(); var modelProperties = props.Where(x => x.GetCustomAttributes(typeof(CmsModelPropertyAttribute), false).Length > 0).OfType <PropertyInfo>().ToList(); foreach (var property in pageNode.Properties) { var modelProperty = modelProperties.FirstOrDefault(x => x.Name == property.PropertyTemplate.PropertyName); if (modelProperty != null) { modelProperty.SetValue(modelInstance, property.Text, BindingFlags.Public, null, null, null); } } return(modelInstance); }
internal static void FormatValue(StringBuilder builder) { Ensure.ArgumentIsNotNull(builder, "builder"); builder.Replace("|", "||"); builder.Replace("'", "|'"); builder.Replace("\n", "|n"); builder.Replace("\r", "|r"); builder.Replace("]", "|]"); }