/// <summary>
/// Constructor
/// </summary>
public MemoryQueue(string name)
{
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
Name = name;
_queue = new ConcurrentQueue <MessageEnvelope <T> >();
KeepQueueAliveTimeSpan = TimeSpan.FromSeconds(1);
}
public IFile CreateFile(string name)
{
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
var blockBlob = _blobContainer.GetBlockBlobReference(name);
return(new AzureBlockBlob(blockBlob));
}
/// <summary>
/// Initialize <see cref="Setup"/>.
/// </summary>
/// <param name="name">The name of the application.</param>
/// <param name="tenant">The tenant that the application itself runs in.</param>
/// <param name="level">The run time level for the application itself.</param>
/// <remarks>Will setup all mandatory fields for <see cref="Setup"/>, but you might want to override those values when this method returns."/></remarks>
public static void Initialize(string name, Tenant tenant, RunTimeLevelEnum level)
{
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
InternalContract.RequireValidated(tenant, nameof(tenant));
InternalContract.Require(level != RunTimeLevelEnum.None, $"{nameof(level)} ({level}) must be set to something else than {RunTimeLevelEnum.None}");
Setup.Name = name;
Setup.Tenant = tenant;
Setup.RunTimeLevel = level;
Setup.ThreadHandler = ThreadHelper.RecommendedForRuntime;
Setup.SynchronousFastLogger = LogHelper.RecommendedSyncLoggerForRuntime;
switch (level)
{
case RunTimeLevelEnum.None:
case RunTimeLevelEnum.Development:
Setup.LogSeverityLevelThreshold = LogSeverityLevel.Verbose;
break;
case RunTimeLevelEnum.Test:
Setup.LogSeverityLevelThreshold = LogSeverityLevel.Information;
break;
case RunTimeLevelEnum.ProductionSimulation:
case RunTimeLevelEnum.Production:
Setup.LogSeverityLevelThreshold = LogSeverityLevel.Warning;
break;
default:
Setup.LogSeverityLevelThreshold = LogSeverityLevel.Verbose;
InternalContract.Fail($"Parameter {nameof(level)} had an unexpected value ({level})");
break;
}
}
public ValueTranslatorHttpSender(IHttpSender httpSender, string translationClientName)
{
InternalContract.RequireNotNull(httpSender, nameof(httpSender));
InternalContract.RequireNotNullOrWhiteSpace(translationClientName, nameof(translationClientName));
HttpSender = httpSender;
TranslationClientName = translationClientName;
}
/// <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");
}
public AzureBlobClient(string connectionString)
{
InternalContract.RequireNotNullOrWhiteSpace(connectionString, nameof(connectionString));
var storageAccount = CloudStorageAccount.Parse(connectionString);
_blobClient = storageAccount.CreateCloudBlobClient();
FulcrumAssert.IsNotNull(_blobClient, null, "Could not create a cloud blob client.");
}
public AzureStorageTable(string connectionString, string name)
{
InternalContract.RequireNotNullOrWhiteSpace(connectionString, nameof(connectionString));
var storageAccount = CloudStorageAccount.Parse(connectionString);
var client = storageAccount.CreateCloudTableClient();
FulcrumAssert.IsNotNull(client, null, "Could not create a cloud table client.");
Table = client.GetTableReference(name);
}
/// <summary>
/// Set up a new client translator.
/// </summary>
/// <param name="idConceptName">The <see cref="IdConceptName"/>.</param>
/// <param name="getClientNameMethod">The <see cref="GetClientNameMethod"/>.</param>
/// <param name="translatorService">The <see cref="TranslatorService"/>.</param>
protected ClientTranslatorBase(string idConceptName, System.Func <string> getClientNameMethod, ITranslatorService translatorService)
{
InternalContract.RequireNotNullOrWhiteSpace(idConceptName, nameof(idConceptName));
InternalContract.RequireNotNull(getClientNameMethod, nameof(getClientNameMethod));
InternalContract.RequireNotNull(translatorService, nameof(translatorService));
IdConceptName = idConceptName;
GetClientNameMethod = getClientNameMethod;
TranslatorService = translatorService;
}
/// <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;
}
public async Task <TStorableItem> ReadAsync(string partitionKey, string rowKey, CancellationToken token = default)
{
InternalContract.RequireNotNullOrWhiteSpace(partitionKey, nameof(partitionKey));
InternalContract.RequireNotNullOrWhiteSpace(rowKey, nameof(rowKey));
var tableRequestOptions = new TableRequestOptions();
var operationContext = new OperationContext();
if (!await Table.ExistsAsync(tableRequestOptions, operationContext, token))
{
return(default);
/// <summary>
/// A translator for a specific <paramref name="clientName"/> that will use the <paramref name="service"/> for the actual translations.
/// </summary>
public Translator(string clientName, ITranslatorService service)
{
InternalContract.RequireNotNullOrWhiteSpace(clientName, nameof(clientName));
InternalContract.RequireNotNull(service, nameof(service));
_clientName = clientName;
_service = service;
_conceptValues = new HashSet <string>();
_translations = new Dictionary <string, string>();
_conceptValueRegex = new Regex(@"\(([^!]+)!([^!]+)!(.+)\)", RegexOptions.Compiled);
_conceptValueAndNothingElseInStringRegex = new Regex("\"" + @"(\(([^!]+)!([^!]+)!(?:(?!\)" + "\"" + @").)+\))" + "\"", RegexOptions.Compiled);
}
/// <summary>
/// Use this method to add a new <see cref="FulcrumException"/>. This means that it will be included in converting.
/// </summary>
/// <param name="exceptionType">The type of the exception.</param>
/// <param name="inboundStatusCode">The status code that it should be converted to if we convert it to an HTTP response.</param>
/// <param name="outboundExceptionType">Fulcrum errors of type <paramref name="exceptionType"/> should be converted to this type of exception.</param>
public static void AddFulcrumException(Type exceptionType, HttpStatusCode inboundStatusCode, string outboundExceptionType)
{
InternalContract.RequireNotNull(exceptionType, nameof(exceptionType));
InternalContract.RequireNotNullOrWhiteSpace(outboundExceptionType, nameof(outboundExceptionType));
var createDelegate = GetInstanceDelegate(exceptionType);
var sourceException = createDelegate("test", (Exception)null);
FactoryMethodsCache.Add(sourceException.Type, createDelegate);
HttpStatusCodesCache.Add(sourceException.Type, inboundStatusCode);
FulcrumErrorTargetExceptionType.Add(sourceException.Type, outboundExceptionType);
}
/// <inheritdoc />
public StackifyLogger(string serverKey)
{
// Null serverKey is for testing, no log message is sent, but the LastSentEnvelope property is still set.
if (!FulcrumApplication.IsInDevelopment)
{
InternalContract.RequireNotNullOrWhiteSpace(serverKey, nameof(serverKey));
}
_client = serverKey == null ? null : new Client(serverKey);
var tenant = FulcrumApplication.Setup.Tenant;
_env = $"{tenant.Organization}/{tenant.Environment}";
_serverName = FulcrumApplication.Setup.Name;
_appName = $"{FulcrumApplication.Setup.Name} {(FulcrumApplication.Setup.RunTimeLevel)}";
}
/// <inheritdoc />
public async Task <int> CountItemsAdvancedAsync(string selectFirst, string selectRest, object param = null, CancellationToken cancellationToken = default)
{
InternalContract.RequireNotNullOrWhiteSpace(selectFirst, nameof(selectFirst));
InternalContract.RequireNotNullOrWhiteSpace(selectRest, nameof(selectRest));
if (selectRest == null)
{
return(0);
}
var selectStatement = $"{selectFirst} {selectRest}";
var result = await InternalQueryAsync <int>(selectStatement, param, cancellationToken);
FulcrumAssert.IsNotNull(result, CodeLocation.AsString());
return(result.SingleOrDefault());
}
public Task <Foo> UpdateAndReturnAsync([TranslationConcept(Foo.IdConceptName)] string id, Foo item,
CancellationToken token = default)
{
InternalContract.RequireNotNullOrWhiteSpace(id, nameof(id));
InternalContract.RequireNotNull(item, nameof(item));
var success = ConceptValue.TryParse(item.Id, out var conceptValue);
FulcrumAssert.IsTrue(success);
FulcrumAssert.AreEqual(Foo.IdConceptName, conceptValue.ConceptName);
FulcrumAssert.AreEqual(Foo.ConsumerName, conceptValue.ClientName);
InternalContract.Require(id == item.Id, $"Expected {nameof(id)} to be identical to {nameof(item)}.{nameof(item.Id)}.");
item.Id = Translator.Decorate(Foo.IdConceptName, Foo.ProducerName, Foo.ProducerId1);
return(Task.FromResult(item));
}
/// <inheritdoc />
public async Task WithdrawAsync(string id, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhiteSpace(id, nameof(id));
try
{
await _crmSystem.LeadFunctionality.RejectAsync(id.ToGuid(), "Application withdrawn.");
}
catch (NotFoundException)
{
throw new FulcrumNotFoundException($"The application with id {id} could not be found.");
}
catch (Exception e)
{
throw e.ToNexusException();
}
}
/// <inheritdoc />
public async Task <string> ApproveAsync(string id, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNullOrWhiteSpace(id, nameof(id));
try
{
var memberId = await _crmSystem.LeadFunctionality.QualifyAsync(id.ToGuid());
return(memberId.ToIdString());
}
catch (NotFoundException)
{
throw new FulcrumNotFoundException($"The application with id {id} could not be found.");
}
catch (Exception e)
{
throw e.ToNexusException();
}
}
public void WhitespaceString()
{
const string parameterName = "parameterName";
try
{
string whitespaceString = " \t";
// ReSharper disable once ExpressionIsAlwaysNull
InternalContract.RequireNotNullOrWhiteSpace(whitespaceString, 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}.");
}
}
/// <summary>
/// Get a string value.
/// </summary>
/// <param name="name">The name of the app setting.</param>
/// <param name="isMandatory">Throw an excepton if this is true and no value was found.</param>
/// <returns>The found string or null.</returns>
public string GetString(string name, bool isMandatory)
{
// We must not have InternalContract and stuff here, since we may not have set up logging, etc.
if (string.IsNullOrWhiteSpace(name))
{
throw new FulcrumContractException($"Parameter {nameof(name)} was empty.");
}
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
var value = _appSettingGetter?.GetAppSetting(name)
#if NETSTANDARD
?? _configuration[name]
#endif
;
if (isMandatory && string.IsNullOrWhiteSpace(value))
{
throw new FulcrumContractException($"Missing app setting: {name}");
}
return(value);
}
public async Task CreateAsync(string partitionKey, string rowKey, TStorableItemCreate item, CancellationToken token = default)
{
InternalContract.RequireNotNullOrWhiteSpace(partitionKey, nameof(partitionKey));
InternalContract.RequireNotNullOrWhiteSpace(rowKey, nameof(rowKey));
InternalContract.RequireNotNull(item, nameof(item));
InternalContract.RequireValidated(item, nameof(item));
var dbItem = StorageHelper.DeepCopy <TStorableItem, TStorableItemCreate>(item);
StorageHelper.MaybeCreateNewEtag(dbItem);
StorageHelper.MaybeUpdateTimeStamps(dbItem, true);
InternalContract.RequireValidated(dbItem, nameof(item));
var tableRequestOptions = new TableRequestOptions();
var operationContext = new OperationContext();
var createTableTask = Table.CreateIfNotExistsAsync(tableRequestOptions, operationContext, token);
var entity = new JsonEntity(partitionKey, rowKey)
{
ETag = dbItem.Etag,
JsonAsString = JsonConvert.SerializeObject(dbItem)
};
await createTableTask;
await Table.ExecuteAsync(TableOperation.Insert(entity, true), tableRequestOptions, operationContext, token);
}
/// <inheritdoc />
public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options,
CancellationToken cancellationToken = default)
{
InternalContract.RequireNotNullOrWhiteSpace(key, nameof(key));
InternalContract.RequireNotNull(value, nameof(value));
var item = await GetAsync(key, cancellationToken);
if (item == null)
{
try
{
await ItemStorage.CreateWithSpecifiedIdAsync(key, value, cancellationToken);
}
catch (FulcrumConflictException)
{
await ItemStorage.UpdateAsync(key, value, cancellationToken);
}
}
else
{
await ItemStorage.UpdateAsync(key, value, cancellationToken);
}
}
/// <inheritdoc />
public Client(string serverKey)
{
InternalContract.RequireNotNullOrWhiteSpace(serverKey, nameof(serverKey));
_serverKey = serverKey;
_client = new RestClient(new HttpSender(@"https://api.stackify.com/Log/Save"));
}
/// <summary>
/// The constructor
/// </summary>
/// <param name="connectionString">How to connect to the database.</param>
public Database(string connectionString)
{
InternalContract.RequireNotNullOrWhiteSpace(connectionString, nameof(connectionString));
_connectionString = connectionString;
}
/// <inheritdoc />
public async Task DeleteAsync(string id, CancellationToken token = new CancellationToken())
{
InternalContract.RequireNotNullOrWhiteSpace(id, nameof(id));
await _crmSystem.ContactFunctionality.Delete(id.ToGuid());
}
public MemoryQueue(string name, QueueItemActionDelegate queueItemAction = null,
bool actionsCanExecuteWithoutIndividualAwait = false) : this(name)
{
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
SetQueueItemAction(queueItemAction, actionsCanExecuteWithoutIndividualAwait);
}
public MemoryQueue(string name, QueueItemActionDelegate queueItemAction) : this(name)
{
InternalContract.RequireNotNullOrWhiteSpace(name, nameof(name));
SetQueueItemAction(queueItemAction);
}
/// <inheritdoc />
public T GetValue <T>(string key)
{
InternalContract.RequireNotNullOrWhiteSpace(key, nameof(key));
if (!Dictionary.TryGetValue(key, out AsyncLocal <object> asyncLocalObject))
{
return(default);
/// <summary>
/// Constructor
/// </summary>
public OneValueProvider(IValueProvider valueProvider, string key)
{
_valueProvider = valueProvider;
InternalContract.RequireNotNullOrWhiteSpace(key, nameof(key));
Key = key;
}
/// <inheritdoc />
public async Task RemoveAsync(string key, CancellationToken cancellationToken = default)
{
InternalContract.RequireNotNullOrWhiteSpace(key, nameof(key));
await ItemStorage.DeleteAsync(key, cancellationToken);
}
/// <inheritdoc />
public async Task <byte[]> GetAsync(string key, CancellationToken cancellationToken = default)
{
InternalContract.RequireNotNullOrWhiteSpace(key, nameof(key));
return(await ItemStorage.ReadAsync(key, cancellationToken));
}