public string GetUriRequest(Common.Utils.IContactRequest typeRequest, IRequestSettings <T> config, Common.Partners.IContact.IContactRequest requestFrmOuter)
{
requestFrm = requestFrmOuter;
string uri = CreatetUriRequest(config.mailingProvider, typeRequest);
return(uri);
}
/// <summary>
/// Specific settings to be used for the request. These settings are merged
/// into the default setting of the IRequestClient instance.
/// </summary>
/// <param name="settings">The request specific settings.</param>
/// <returns>The API request instance updated with the request specific settings.</returns>
public ApiRequest UsingSettings(IRequestSettings settings)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings),
"Settings cannot be null.");
return(this);
}
public string GetUriRequest(IContactRequest typeRequest, IRequestSettings <T> config, IContactRequest requestFrmOuter)
{
requestFrm = requestFrmOuter;
string uri = CreatetUriRequest(config.mailingProvider, typeRequest);
return(uri);
}
private void IContactConfigureRequestJson(HttpWebRequest request, IRequestSettings <T> config)
{
// Get data from config.headers dictionary
string Username = config.headers["Username"];
string Password = config.headers["Password"];
string ApiVersion = config.headers["API-Version"];
string AppId = config.headers["API-AppId"];
string Data = config.data;
// config request with IRequestSettings
request.KeepAlive = false;
request.Method = config.method;
request.Accept = config.accept;
request.Headers.Add("API-Version", ApiVersion);
request.Headers.Add("API-AppId", AppId);
request.Headers.Add("API-Username", Username);
request.Headers.Add("API-Password", Password);
request.Headers.Add("Authorization", string.Format("{0} {1}", Username, Password));
request.ContentType = config.contentType;
request.Credentials = new NetworkCredential(Username, Password);
// config body of request
if (Data != null)
{
byte[] DataBytes = Encoding.ASCII.GetBytes(Data);
request.ContentLength = DataBytes.Length;
using (var stream = request.GetRequestStream())
{
stream.Write(DataBytes, 0, DataBytes.Length);
}
}
}
private void ValidateRequestSettings(IRequestSettings <T> config, IContactRequest typeRequest)
{
TypeSwitch.Do(
config.mailingProvider,
TypeSwitch.Case <IIContactRequest>(() => { IContactValidateRequestSettings(config, typeRequest); }),
TypeSwitch.Default(() => { }));
}
public HttpClient GetHttpClient(IRequestSettings <T> config, IContactRequest typeRequest)
{
HttpClient client = new HttpClient();
string username = requestFrm.ApiUserName == string.Empty ? throw new ArgumentException("[Username] not found in settings, this key es required.") : requestFrm.ApiUserName;
string password = requestFrm.ApiUserPassword == string.Empty ? throw new ArgumentException("[Password] not found in settings, this key es required.") : requestFrm.ApiUserPassword;
string apiversion = requestFrm.ApiVersion == string.Empty ? throw new ArgumentException("[API-Version] not found in settings, this key es required.") : requestFrm.ApiVersion;
string appid = requestFrm.ApiAppId == string.Empty ? throw new ArgumentException("[API-AppId] not found in settings, this key es required.") : requestFrm.ApiAppId;
string accept = config.accept == string.Empty ? throw new ArgumentException("[Accept] not found in settings, this key es required.") : config.accept;
string contenttype = config.contentType == string.Empty ? throw new ArgumentException("[contentType] not found in settings, this key es required.") : config.contentType;
AuthenticationHeaderValue authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
System.Text.ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", username, password))));
//Todo
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contenttype));
client.DefaultRequestHeaders.Add("Username", username);
client.DefaultRequestHeaders.Add("Password", password);
client.DefaultRequestHeaders.Add("API-Version", apiversion);
client.DefaultRequestHeaders.Add("API-AppId", appid);
client.DefaultRequestHeaders.Add("Accept", accept);
client.DefaultRequestHeaders.Add("API-Username", username);
client.DefaultRequestHeaders.Add("API-Password", password);
client.DefaultRequestHeaders.Authorization = authorization;
return(client);
}
public HttpWebRequest GetWebRequest(IContactRequest typeRequest, IRequestSettings <T> config, IContactRequest requestFrmOuter)
{
requestFrm = requestFrmOuter;
ValidateRequestSettings(config, typeRequest);
string uri = CreatetUriRequest(config.mailingProvider, typeRequest);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
ConfigureRequest(request, config);
return(request);
}
private void ConfigureRequest(HttpWebRequest request, IRequestSettings <T> config)
{
TypeSwitch.Do(
config.mailingProvider,
TypeSwitch.Case <IIContactRequest>(() => {
//IContactConfigureRequest(request, config);
IContactConfigureRequestJson(request, config);
}),
TypeSwitch.Default(() => { }));
}
public ErrorStatusContext(
IRequestClient client,
HttpResponseMessage response,
IRequestSettings defaultSettings,
IRequestSettings requestSettings)
{
Client = client ?? throw new ArgumentNullException(nameof(client));
Response = response ?? throw new ArgumentNullException(nameof(response));
DefaultSettings = defaultSettings ?? throw new ArgumentNullException(nameof(defaultSettings));
Settings = requestSettings ?? throw new ArgumentNullException(nameof(requestSettings));
}
private void RegisterClientsWithFactory(ClientFactorySettings factorySettings)
{
RequestClientFactory.Instance.RegisterMediaTypeSerializer <JsonMediaTypeSerializer>();
RequestClientFactory.Instance.RegisterMediaTypeSerializer <JsonMediaTypeSerializer>(InternetMediaTypes.HalJson);
// Register each defined client within the configuration settings with the RequestClientFactory.
foreach (ClientSettings clientSettings in factorySettings.Clients)
{
IRequestSettings requestSettings = BuildRequestSettings(clientSettings);
RequestClientFactory.Instance.RegisterBaseAddress(clientSettings.BaseAddress, requestSettings);
}
}
public IRequestSettings GetMerged(IRequestSettings requestSettings)
{
if (requestSettings == null)
{
return(this);
}
return(new RequestSettings()
{
Headers = Headers.GetMergedHeaders(requestSettings.Headers),
QueryString = QueryString.GetMerged(requestSettings.QueryString)
});
}
public static RequestSettings Create(IRequestSettings contractObject)
{
if (null == contractObject)
{
return(null);
}
if (contractObject is RequestSettings businessObject)
{
return(businessObject);
}
return(Mapper.Map <RequestSettings>(contractObject));
}
/// <summary>
/// Called at the beginning of the consuming application to register base
/// API addresses for which IResourceClient instances should be created.
/// </summary>
/// <param name="baseAddress">The base address to associated with the client.</param>
/// <param name="settings">The default settings applied when making a request.</param>
public void RegisterBaseAddress(string baseAddress, IRequestSettings requestSettings)
{
if (String.IsNullOrWhiteSpace(baseAddress))
{
throw new ArgumentException("Client base address not specified.", nameof(baseAddress));
}
if (_baseAddressRegistrations.ContainsKey(baseAddress))
{
throw new InvalidOperationException(
$"The base address: {baseAddress} is already registered.");
}
_baseAddressRegistrations[baseAddress] = requestSettings ??
throw new ArgumentNullException(nameof(requestSettings), "Default client settings not specified.");
}
public IServiceResponse Get(IServiceRequest request, IRequestSettings restSettings)
{
if (Auth != null)
client.Authenticator = Auth;
var restRequest = new RestRequest(request.Uri, Method.GET);
var response = client.Execute(restRequest);
return new ServiceResponse
{
Data = response.Content,
StatusCode = response.StatusCode,
ErrorException = response.ErrorException,
ErrorMessage = response.ErrorMessage
};
}
private void IContactValidateRequestSettings(IRequestSettings <T> config, IContactRequest typeRequest)
{
//Tem var
string username = requestFrm.ApiUserName == string.Empty ? throw new ArgumentException("[Username] not found in settings, this key es required.") : requestFrm.ApiUserName;
string password = requestFrm.ApiUserPassword == string.Empty ? throw new ArgumentException("[Password] not found in settings, this key es required.") : requestFrm.ApiUserPassword;
string apiversion = requestFrm.ApiVersion == string.Empty ? throw new ArgumentException("[API-Version] not found in settings, this key es required.") : requestFrm.ApiVersion;
string appid = requestFrm.ApiAppId == string.Empty ? throw new ArgumentException("[API-AppId] not found in settings, this key es required.") : requestFrm.ApiAppId;
string accept = config.accept == string.Empty ? throw new ArgumentException("[Accept] not found in settings, this key es required.") : config.accept;
string contenttype = config.contentType == string.Empty ? throw new ArgumentException("[contentType] not found in settings, this key es required.") : config.contentType;
//Add to header
config.headers.Add("Username", username);
config.headers.Add("Password", password);
config.headers.Add("API-Version", apiversion);
config.headers.Add("API-AppId", appid);
config.headers.Add("Accept", accept);
config.headers.Add("contentType", contenttype);
if (
typeRequest == IContactRequest.AddMessage ||
typeRequest == IContactRequest.AddSends)
{
if (config.data == string.Empty)
{
throw new ArgumentException("[Data] not found in settings, this key es required.");
}
config.method = "POST";
}
else if (typeRequest == IContactRequest.AddCampaign)
{
config.method = "POST";
}
else
{
config.method = "GET";
}
// Config
string method = config.method == string.Empty ? throw new ArgumentException("[Method] not found in settings, this key es required.") : config.method;
config.authorization = string.Format("{0} {1}", username, password);
config.headers.Add("Method", method);
}
/// <summary>
/// Applies the settings commonly used when submitting and consuming
/// REST/HAL based requests.
/// </summary>
/// <returns>Reference to the settings being configured.<returns>
/// <param name="requestSettings">The request settings to configure.</param>
public static IRequestSettings UseHalDefaults(this IRequestSettings requestSettings)
{
if (requestSettings == null)
{
throw new ArgumentNullException(nameof(requestSettings), "Request Settings must be specified.");
}
requestSettings.Headers.AcceptMediaType(InternetMediaTypes.HalJson);
requestSettings.Headers.AcceptMediaType(InternetMediaTypes.Json);
// If the settings content-type is not specified assume JSON serialized
// content will be submitted to the server.
if (requestSettings.Headers.ContentType == null)
{
requestSettings.Headers.ContentMediaType(InternetMediaTypes.Json);
}
return(requestSettings);
}
public IServiceResponse Get(IServiceRequest request, IRequestSettings restSettings)
{
if (Auth != null)
{
client.Authenticator = Auth;
}
var restRequest = new RestRequest(request.Uri, Method.GET);
var response = client.Execute(restRequest);
return(new ServiceResponse
{
Data = response.Content,
StatusCode = response.StatusCode,
ErrorException = response.ErrorException,
ErrorMessage = response.ErrorMessage
});
}
public IRequestSettings GetMerged(IRequestSettings requestSettings)
{
if (requestSettings != null)
{
return(new RequestSettings
{
Headers = Headers.GetMergedHeaders(requestSettings.Headers),
QueryString = QueryString.GetMerged(requestSettings.QueryString),
SuppressStatusCodeHandlers = requestSettings.SuppressStatusCodeHandlers ?? SuppressStatusCodeHandlers ?? false
});
}
return(new RequestSettings
{
Headers = Headers,
QueryString = QueryString,
SuppressStatusCodeHandlers = SuppressStatusCodeHandlers ?? false
});
}
/// <summary>
/// Initializes an instance of the client with its associated HttpClient delegated to
/// for making network requests.
/// </summary>
/// <param name="httpClient">Reference to a HttpClient instance.</param>
/// <param name="logger">The logger to use for log messages.</param>
/// <param name="contentSerializers">Dictionary of serializers keyed by media-type.</param>
/// <param name="requestSettings">The default request settings to be used for each request.</param>
public RequestClient(HttpClient httpClient,
ILogger logger,
IDictionary <string, IMediaTypeSerializer> contentSerializers,
IRequestSettings requestSettings)
{
_httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient),
"HTTP Client cannot be null.");
_logger = logger ?? throw new ArgumentNullException(nameof(httpClient),
"Logger cannot be null.");
_defaultRequestSettings = requestSettings ?? throw new ArgumentNullException(nameof(requestSettings),
"Default Request Settings cannot be null.");
if (contentSerializers == null)
{
throw new ArgumentNullException(nameof(contentSerializers), "HTTP Context Serializers cannot be null.");
}
_mediaTypeSerializers = new ConcurrentDictionary <string, IMediaTypeSerializer>(contentSerializers);
}
public static IRequestClient CreateTestClient(this IRequestSettings requestSettings,
MockAppHostPlugin hostPlugin,
IMockedService mockService = null)
{
requestSettings.UseHalDefaults();
var serializers = new Dictionary <string, IMediaTypeSerializer>
{
{ InternetMediaTypes.Json, new JsonMediaTypeSerializer() },
{ InternetMediaTypes.HalJson, new JsonMediaTypeSerializer() }
};
var builder = new WebHostBuilder()
.ConfigureServices(services =>
{
// Add the needed ResourcePlugin modules since this is
// what the unit tests will be testing.
hostPlugin.UseResourcePlugin();
// Creates the typical StartUp class used by ASP.NET Core.
var startup = new TestStartup(hostPlugin);
services.AddSingleton <IStartup>(startup);
// This service will be injected by the WebApi controller and
// can be used to very the system under test.
services.AddSingleton <IMockedService>(mockService ?? new NullUnitTestService());
});
// Create an instance of the server and create an HTTP Client
// to communicate with in-memory web-host.
var server = new TestServer(builder);
var httpClient = server.CreateClient();
// Return an instance of the ResourceClient to be tested.
return(new RequestClient(httpClient, serializers, requestSettings));
}
public HttpWebRequest GetRequest(KindAds.Common.Utils.IContactRequest type, IRequestSettings <IIContactRequest> config, IContactRequest requestFrm)
{
HttpWebRequest request = requestManager.GetWebRequest(type, config, requestFrm);
return(request);
}
/// <summary>
/// Specifies the default settings that should be used for each request. Any request specific settings,
/// if specified, will be merged into the default settings. If not specified, the default settings are
/// initialized for the most common usage.
/// </summary>
/// <param name="requestSettings">Request setting to use for each request.</param>
/// <returns>Builder for method chaining.</returns>
public RequestClientBuilder UsingDefaultSettings(IRequestSettings requestSettings)
{
_defaultRequestSettings = requestSettings ??
throw new ArgumentNullException(nameof(requestSettings));
return(this);
}
public void Post(IServiceRequest request, IRequestSettings restSettings)
{
throw new NotImplementedException();
}
public DistrictCollectionDataResolver(IRequestSettings requestSettings)
{
_requestSettings = requestSettings;
}
public void Post(IServiceRequest request, IRequestSettings restSettings)
{
throw new NotImplementedException();
}
