private async Task <HttpRequestMessage> CreateRequest <TResponse, TBody>(HttpMethod method, string relativeUrl, Dictionary <string, List <string> > customHeaders,
CancellationToken cancellationToken, TBody instance) where TBody : class
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
var baseUrl = BaseUri.AbsoluteUri;
if (!baseUrl.EndsWith("/"))
{
baseUrl += "/";
}
if (relativeUrl.StartsWith("/"))
{
relativeUrl = relativeUrl.Substring(1);
}
var url = new Uri(new Uri(baseUrl), relativeUrl).ToString();
var request = CreateRequest(method, url, customHeaders);
if (instance != null)
{
var requestContent =
Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(instance, _serializationSettings);
request.Content = new StringContent(requestContent, System.Text.Encoding.UTF8);
request.Content.Headers.ContentType =
System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
if (Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Credentials.ProcessHttpRequestAsync(request, cancellationToken).ConfigureAwait(false);
}
return(request);
}
/// <inheritdoc />
public async Task <TDatabaseItem> SearchFirstAdvancedAsync(string selectStatement, string orderBy = null, object param = null, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(selectStatement, nameof(selectStatement));
var result = await InternalSearchAsync(param, selectStatement, orderBy, 0, 1);
return(result.SingleOrDefault());
}
public async Task <TResponse> GetAsync <TResponse>(string relativeUrl)
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
var response = await SendRequestAsync <TResponse, object>(HttpMethod.Get, relativeUrl);
return(response.Body);
}
public async Task <TResponse> PutAsync <TResponse, TBody>(string relativeUrl, TBody instance)
where TBody : class
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
var response = await SendRequestAsync <TResponse, TBody>(HttpMethod.Post, relativeUrl, null, default(CancellationToken), instance);
return(response.Body);
}
/// <summary>
/// Constructor
/// </summary>
public Tenant(string organization, string environment)
{
InternalContract.RequireNotNullOrWhitespace(organization, nameof(organization));
InternalContract.RequireNotNullOrWhitespace(environment, nameof(environment));
Organization = organization?.ToLower();
Environment = environment?.ToLower();
Validate($"{Namespace}: 80BAC4F7-6369-4ACD-A34F-413A20E24C27");
}
protected internal async Task <IEnumerable <TDatabaseItem> > QueryAsync(string statement, object param = null, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(statement, nameof(statement));
using (var db = Database.NewSqlConnection())
{
return(await db.QueryAsync <TDatabaseItem>(statement, param));
}
}
protected internal async Task ExecuteAsync(string statement, object param = null, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(statement, nameof(statement));
using (var db = Database.NewSqlConnection())
{
await db.ExecuteAsync(statement, param);
}
}
/// <inheritdoc />
public T GetValue <T>(string key)
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
if (Holder?.Value?.ContainsKey(key) != true)
{
return(default(T));
}
return((T)Holder.Value[key]);
}
/// <inheritdoc />
public T GetValue <T>(string key)
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
if (!Dictionary.ContainsKey(key))
{
return(default(T));
}
return((T)Dictionary[key]);
}
/// <inheritdoc />
public async Task PublishAsync(string entityName, string eventName, int majorVersion, int minorVersion, JObject eventBody)
{
InternalContract.RequireNotNullOrWhitespace(entityName, nameof(entityName));
InternalContract.RequireNotNullOrWhitespace(eventName, nameof(eventName));
InternalContract.RequireGreaterThanOrEqualTo(1, majorVersion, nameof(majorVersion));
InternalContract.RequireGreaterThanOrEqualTo(0, minorVersion, nameof(minorVersion));
FulcrumAssert.IsTrue(FulcrumApplication.IsInDevelopment, $"This method can only be called in run time level Development. The run time level was {FulcrumApplication.Setup.RunTimeLevel}");
var relativeUrl = $"api/BusinessEvents/{entityName}/{eventName}/{majorVersion}/{minorVersion}";
await RestClient.PostNoResponseContentAsync(relativeUrl, eventBody);
}
/// <summary>
/// Sets the server technical name. This name will be used as a default for all new FulcrumExceptions.
/// </summary>
/// <param name="serverTechnicalName"></param>
public static void Initialize(string serverTechnicalName)
{
InternalContract.RequireNotNullOrWhitespace(serverTechnicalName, nameof(serverTechnicalName));
serverTechnicalName = serverTechnicalName.ToLower();
if (_serverTechnicalName != null)
{
InternalContract.Require(serverTechnicalName == _serverTechnicalName,
$"Once the server name has been set ({_serverTechnicalName}, it can't be changed ({serverTechnicalName}).");
}
_serverTechnicalName = serverTechnicalName;
}
/// <inheritdoc />
public void SetValue <T>(string name, T data)
{
InternalContract.RequireNotNullOrWhitespace(name, nameof(name));
InternalContract.RequireNotNull(data, nameof(data));
FulcrumAssert.IsNotNull(Holder, $"{Namespace}: 07B2EC29-9231-4DC1-82FF-09DCB6EC87FA");
if (Holder.Value == null)
{
Holder.Value = new Dictionary <string, object>();
}
Holder.Value[name] = data;
}
/// <summary>
/// Find the items specified by the <paramref name="selectStatement"/>.
/// </summary>
/// <param name="param">The fields for the <paramref name="selectStatement"/> condition.</param>
/// <param name="selectStatement">The SELECT statement, including WHERE, but not ORDER BY.</param>
/// <param name="orderBy">An expression for how to order the result.</param>
/// <param name="offset">The number of items that will be skipped in result.</param>
/// <param name="limit">The maximum number of items to return.</param>
/// <returns>The found items.</returns>
///
protected async Task <IEnumerable <TDatabaseItem> > InternalSearchAsync(object param, string selectStatement, string orderBy,
int offset, int limit)
{
InternalContract.RequireGreaterThanOrEqualTo(0, offset, nameof(offset));
InternalContract.RequireGreaterThanOrEqualTo(0, limit, nameof(limit));
InternalContract.RequireNotNullOrWhitespace(selectStatement, nameof(selectStatement));
orderBy = orderBy ?? TableMetadata.GetOrderBy() ?? "1";
var sqlQuery = $"{selectStatement} " +
$" ORDER BY {orderBy}" +
$" OFFSET {offset} ROWS FETCH NEXT {limit} ROWS ONLY";
return(await QueryAsync(sqlQuery, param));
}
/// <inheritdoc />
public async Task <Person> FindFirstOrDefaultByNameAsync(string name, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(name, nameof(name));
var enumerator =
new PageEnvelopeEnumeratorAsync <Person>((offset, t) => ReadAllWithPagingAsync(offset, null, t), token);
while (await enumerator.MoveNextAsync())
{
if (enumerator.Current.Name == name)
{
return(enumerator.Current);
}
}
return(null);
}
/// <inheritdoc />
public async Task <int> CountItemsAdvancedAsync(string selectFirst, string selectRest, object param = null, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(selectFirst, nameof(selectFirst));
InternalContract.RequireNotNullOrWhitespace(selectRest, nameof(selectRest));
if (selectRest == null)
{
return(0);
}
var selectStatement = $"{selectFirst} {selectRest}";
using (IDbConnection db = Database.NewSqlConnection())
{
return((await db.QueryAsync <int>(selectStatement, param))
.SingleOrDefault());
}
}
public void EmptyString()
{
const string parameterName = "parameterName";
try
{
string emptyString = "";
// ReSharper disable once ExpressionIsAlwaysNull
InternalContract.RequireNotNullOrWhitespace(emptyString, parameterName);
UT.Assert.Fail("An exception should have been thrown");
}
catch (FulcrumContractException fulcrumException)
{
UT.Assert.IsTrue(fulcrumException.TechnicalMessage.Contains(parameterName));
}
catch (Exception e)
{
UT.Assert.Fail($"Expected a specific FulcrumException but got {e.GetType().FullName}.");
}
}
public void WhitespaceString()
{
const string parameterName = "parameterName";
try
{
string whitespaceString = " \t";
// ReSharper disable once ExpressionIsAlwaysNull
InternalContract.RequireNotNullOrWhitespace(whitespaceString, parameterName);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Fail("An exception should have been thrown");
}
catch (FulcrumContractException fulcrumException)
{
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(fulcrumException.TechnicalMessage.Contains(parameterName));
}
catch (Exception e)
{
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Fail($"Expected a specific FulcrumException but got {e.GetType().FullName}.");
}
}
/// <inheritdoc />
public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options,
CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
InternalContract.RequireNotNull(value, nameof(value));
var item = await GetAsync(key, token);
if (item == null)
{
try
{
await ItemStorage.CreateWithSpecifiedIdAsync(key, value, token);
}
catch (FulcrumConflictException)
{
await ItemStorage.UpdateAsync(key, value, token);
}
}
else
{
await ItemStorage.UpdateAsync(key, value, token);
}
}
/// <inheritdoc />
public async Task <TDatabaseItem> SearchAdvancedSingleAsync(string selectStatement, object param = null, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(selectStatement, nameof(selectStatement));
return(await SearchFirstAdvancedAsync(selectStatement, null, param, token));
}
/// <summary>
/// Constructor
/// </summary>
public MemoryQueue(string name)
{
InternalContract.RequireNotNullOrWhitespace(name, nameof(name));
Name = name;
_queue = new Queue <T>();
}
/// <inheritdoc />
public async Task <byte[]> GetAsync(string key, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
return(await ItemStorage.ReadAsync(key, token));
}
public async Task PostNoResponseContentAsync <TBody>(string relativeUrl, TBody instance)
where TBody : class
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
await SendRequestAsync <object, TBody>(HttpMethod.Post, relativeUrl, null, default(CancellationToken), instance);
}
public async Task DeleteAsync(string relativeUrl)
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
await SendRequestAsync <object, object>(HttpMethod.Delete, relativeUrl);
}
/// <inheritdoc />
public async Task RemoveAsync(string key, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
await ItemStorage.DeleteAsync(key, token);
}
public async Task <T> PutAsync <T>(string relativeUrl, T instance)
where T : class
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
return(await PutAsync <T, T>(relativeUrl, instance));
}
/// <summary>
/// Get a value from the cache if all constraints are fulfilled.
/// </summary>
protected async Task <TModel> CacheGetByKeyAsync(string key, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
return(await CacheGetAsync(default(TId), key, token));
}
public async Task PostNoResponseContentAsync(string relativeUrl)
{
InternalContract.RequireNotNullOrWhitespace(relativeUrl, nameof(relativeUrl));
await SendRequestAsync <object, object>(HttpMethod.Post, relativeUrl);
}
/// <inheritdoc />
public void SetValue <T>(string name, T data)
{
InternalContract.RequireNotNullOrWhitespace(name, nameof(name));
InternalContract.RequireNotNull(data, nameof(data));
Dictionary[name] = data;
}
/// <summary>
/// Put the item in the cache.
/// </summary>
protected async Task CacheSetByKeyAsync(string key, TModel item, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhitespace(key, nameof(key));
await CacheSetAsync(default(TId), item, key, token);
}