/// <summary>
/// Finds all documents matching a given expression
/// </summary>
/// <param name="session">Session object to manage the transaction</param>
/// <param name="filterDefinition">The filter definition</param>
/// <param name="sort">Sort definition</param>
/// <param name="skip">The number of documents to skip in the query</param>
/// <param name="take">The maximal amount of documents to return. The skip is applied before the limit restriction</param>
/// <returns>Returns a cursor</returns>
public async Task <ICollection <TDocument> > FindManyAsync(IOspSession session,
FilterDefinition <TDocument> filterDefinition,
SortDefinition <TDocument> sort = null, int?skip = null, int?take = null)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.Validate(nameof(filterDefinition), filterDefinition);
try
{
var cursor = await _documentCollection.FindAsync(((IOspSessionInternal)session).SessionHandle,
filterDefinition, new FindOptions <TDocument>
{
Sort = sort,
Skip = skip,
Limit = take
});
return(await cursor.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Initializes a new instance
/// </summary>
/// <param name="ospIdentityOptions">The osp identity options.</param>
/// <exception cref="System.ArgumentNullException">keys</exception>
public SigningCredentialService(IOptions <OspIdentityOptions> ospIdentityOptions)
{
ArgumentValidation.Validate(nameof(ospIdentityOptions), ospIdentityOptions);
ArgumentValidation.ValidateString(nameof(ospIdentityOptions.Value.KeyFilePath), ospIdentityOptions.Value.KeyFilePath);
ArgumentValidation.ValidateString(nameof(ospIdentityOptions.Value.KeyFilePassword), ospIdentityOptions.Value.KeyFilePassword);
if (File.Exists(ospIdentityOptions.Value.KeyFilePath))
{
Logger.Debug($"SigninCredentialExtension adding key from file {ospIdentityOptions.Value.KeyFilePath}");
var certificate = new X509Certificate2(ospIdentityOptions.Value.KeyFilePath, ospIdentityOptions.Value.KeyFilePassword);
_credential = new SigningCredentials(new X509SecurityKey(certificate), SecurityAlgorithms.RsaSha256);
var keyInfo = new SecurityKeyInfo
{
Key = _credential.Key,
SigningAlgorithm = _credential.Algorithm
};
_keys = new[] { keyInfo };
}
else
{
Logger.Error($"SigninCredentialExtension cannot find key file {ospIdentityOptions.Value.KeyFilePath}");
}
}
public SystemContext(IOptions <OspSystemConfiguration> systemConfiguration,
IDistributedWithPubSubCache distributedWithPubSubCache)
{
ArgumentValidation.Validate(nameof(systemConfiguration), systemConfiguration);
ArgumentValidation.Validate(nameof(distributedWithPubSubCache), distributedWithPubSubCache);
_systemConfiguration = systemConfiguration.Value;
_distributedWithPubSubCache = distributedWithPubSubCache;
var sharedSettings = new MongoConnectionOptions
{
MongoDbHost = _systemConfiguration.DatabaseHost,
MongoDbUsername = _systemConfiguration.AdminUser,
MongoDbPassword = _systemConfiguration.AdminUserPassword,
AuthenticationSource = _systemConfiguration.AuthenticationDatabaseName
};
_ckCaches = new ConcurrentDictionary <string, ICkCache>();
_repositoryClient = new MongoRepositoryClient(sharedSettings);
OspSystemDatabase = _repositoryClient.GetRepository(_systemConfiguration.SystemDatabaseName);
_tenantCollection = OspSystemDatabase.GetCollection <SystemEntities.OspTenant>();
_configurationCollection = OspSystemDatabase.GetCollection <OspConfiguration>();
var sub = _distributedWithPubSubCache.Subscribe <string>(CacheCommon.KeyTenantUpdate);
sub.OnMessage(message =>
{
RemoveCkCache(message.Message);
return(Task.CompletedTask);
});
}
public async Task EnsureAuthenticated(IServiceClientAccessToken serviceClientAccessToken)
{
ArgumentValidation.Validate(nameof(serviceClientAccessToken), serviceClientAccessToken);
if (string.IsNullOrEmpty(_authenticationOptions.Value.RefreshToken) || string.IsNullOrEmpty(_authenticationOptions.Value.AccessToken))
{
Logger.Info("No credential data available.");
return;
}
var ensureAuthenticationData = await
_authenticatorClient.EnsureAuthenticatedAsync(_authenticationOptions.Value.RefreshToken,
_authenticationOptions.Value.AccessToken);
if (ensureAuthenticationData.IsRefreshDone)
{
SaveAuthenticationData(ensureAuthenticationData.RefreshedAuthenticationData);
serviceClientAccessToken.AccessToken = ensureAuthenticationData.RefreshedAuthenticationData.AccessToken;
Logger.Info("Credential data has been refreshed.");
}
else
{
serviceClientAccessToken.AccessToken = _authenticationOptions.Value.AccessToken;
}
}
private async Task AddMessageAsync(string tenantId, NotificationMessageDto notificationMessageDto, RtEntityId?targetRtId)
{
ArgumentValidation.ValidateString(nameof(tenantId), tenantId);
ArgumentValidation.Validate(nameof(notificationMessageDto), notificationMessageDto);
var tenantContext = await _systemContext.CreateOrGetTenantContext(tenantId);
var session = await tenantContext.Repository.StartSessionAsync();
session.StartTransaction();
var rtEntity = CreateRtEntity(notificationMessageDto, tenantContext);
var associationUpdateInfos = new List <AssociationUpdateInfo>();
if (targetRtId != null)
{
associationUpdateInfos.Add(new AssociationUpdateInfo(rtEntity.ToRtEntityId(), targetRtId.Value, Constants.RelatedRoleId, AssociationModOptionsDto.Create));
}
await tenantContext.Repository.ApplyChanges(session, new[]
{
new EntityUpdateInfo(rtEntity, EntityModOptions.Create)
}, associationUpdateInfos);
await session.CommitTransactionAsync();
}
public async Task <ResultSet <RtEntity> > GetRtEntitiesByIdAsync(IOspSession session, string ckId,
IReadOnlyList <ObjectId> rtIds,
DataQueryOperation dataQueryOperation, int?skip = null, int?take = null)
{
ArgumentValidation.ValidateString(nameof(ckId), ckId);
ArgumentValidation.Validate(nameof(rtIds), rtIds);
ArgumentValidation.Validate(nameof(dataQueryOperation), dataQueryOperation);
if (!rtIds.Any())
{
return(new ResultSet <RtEntity>(new List <RtEntity>(), 0));
}
var resultSet = new List <RtEntity>();
long totalCount = 0;
var entityCacheItem = GetEntityCacheItem(ckId);
var statementCreator =
new RtStatementCreator(entityCacheItem, _databaseContext, dataQueryOperation.Language);
statementCreator.AddFieldFilters(dataQueryOperation.FieldFilters);
statementCreator.AddIdFilter(rtIds);
statementCreator.AddTextSearchFilter(dataQueryOperation.TextSearchFilter);
statementCreator.AddAttributeSearchFilter(dataQueryOperation.AttributeSearchFilter);
statementCreator.AddSort(dataQueryOperation.SortOrders);
var tempResultSet = await statementCreator.ExecuteQuery(session, skip, take);
resultSet.AddRange(tempResultSet.Result);
totalCount += tempResultSet.TotalCount;
return(new ResultSet <RtEntity>(resultSet, totalCount));
}
public async Task <BulkImportResult> BulkRtAssociationsAsync(IOspSession session,
IEnumerable <RtAssociation> rtAssociations)
{
ArgumentValidation.Validate(nameof(rtAssociations), rtAssociations);
return(await _databaseContext.RtAssociations.BulkImportAsync(session, rtAssociations));
}
public async Task UpdateAutoCompleteTexts(IOspSession session, string ckId, string attributeName,
IEnumerable <string> autoCompleteTexts)
{
ArgumentValidation.ValidateString(nameof(ckId), ckId);
ArgumentValidation.ValidateString(nameof(attributeName), attributeName);
ArgumentValidation.Validate(nameof(autoCompleteTexts), autoCompleteTexts);
var ckEntity =
await _databaseContext.CkEntities.FindSingleOrDefaultAsync(session, x => x.CkId == ckId);
if (ckEntity == null)
{
throw new EntityNotFoundException($"'{ckId}' does not exist in database.");
}
var attribute = ckEntity.Attributes.FirstOrDefault(x => x.AttributeName == attributeName);
if (attribute == null)
{
throw new InvalidAttributeException(
$"Attribute with name '{attributeName}' does not exist on type '{ckId}'");
}
attribute.AutoCompleteTexts = autoCompleteTexts.ToList();
try
{
await _databaseContext.CkEntities.ReplaceByIdAsync(session, ckEntity.CkId, ckEntity);
}
catch (Exception e)
{
throw new OperationFailedException("An error occurred during import: " + e.Message, e);
}
}
public async Task CreateTextIndexAsync(string name, string language,
IEnumerable <CkIndexFields> fields)
{
ArgumentValidation.ValidateString(nameof(name), name);
ArgumentValidation.ValidateString(nameof(language), language);
ArgumentValidation.Validate(nameof(fields), fields);
Dictionary <string, int> weights = new Dictionary <string, int>();
var indexKeys =
fields.SelectMany(f => f.AttributeNames).Select(f =>
Builders <TDocument> .IndexKeys.Text(Constants.AttributesName + "." + f.ToCamelCase()));
foreach (var field in fields)
{
foreach (var attributeName in field.AttributeNames)
{
weights.Add(Constants.AttributesName + "." + attributeName.ToCamelCase(),
field.Weight.GetValueOrDefault(1));
}
}
await _documentCollection.Indexes.CreateOneAsync(new CreateIndexModel <TDocument>(
Builders <TDocument> .IndexKeys.Combine(
indexKeys), new CreateIndexOptions
{
Name = name,
Weights = new BsonDocument(weights),
DefaultLanguage = language
}
));
}
/// <summary>
/// Adds Osp to the pipeline.
/// </summary>
/// <param name="app">The application.</param>
/// <returns></returns>
// ReSharper disable once UnusedMethodReturnValue.Global
public static IApplicationBuilder UseOspApiVersioningAndDocumentation(
this IApplicationBuilder app)
{
ArgumentValidation.Validate(nameof(app), app);
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
var provider = app.ApplicationServices.GetRequiredService <IApiVersionDescriptionProvider>();
var ospOptions = app.ApplicationServices.GetRequiredService <IOptions <OspSwaggerOptions> >();
app.UseSwaggerUI(
options =>
{
// build a swagger endpoint for each discovered API version
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json",
description.GroupName.ToUpperInvariant());
}
options.InjectStylesheet("/css/swagger.css");
options.OAuthClientId(ospOptions.Value.ClientId);
options.OAuthAppName(ospOptions.Value.AppName);
options.OAuthUsePkce();
});
return(app);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="tenantClientOptions">Options for data source client</param>
/// <param name="tenantClientAccessToken">Access Token for backend access</param>
// ReSharper disable once MemberCanBePrivate.Global
public TenantClient(TenantClientOptions tenantClientOptions,
ITenantClientAccessToken tenantClientAccessToken)
{
AccessToken = tenantClientAccessToken;
Options = tenantClientOptions;
ArgumentValidation.Validate(nameof(tenantClientOptions), tenantClientOptions);
ArgumentValidation.Validate(nameof(tenantClientAccessToken), tenantClientAccessToken);
}
public async Task <long> GetTotalCountAsync(IOspSession session, Expression <Func <TDocument, bool> > expression)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.Validate(nameof(expression), expression);
return(await _documentCollection.CountDocumentsAsync(((IOspSessionInternal)session).SessionHandle,
expression));
}
public async Task <long> GetTotalCountAsync(IOspSession session, FilterDefinition <TDocument> filterDefinition)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.Validate(nameof(filterDefinition), filterDefinition);
return(await _documentCollection.CountDocumentsAsync(((IOspSessionInternal)session).SessionHandle,
filterDefinition));
}
public AttributeSearchFilter(IEnumerable <string> attributeNames, object searchTerm)
{
ArgumentValidation.Validate(nameof(attributeNames), attributeNames);
ArgumentValidation.Validate(nameof(searchTerm), searchTerm);
AttributeNames = attributeNames;
SearchTerm = searchTerm;
}
public async Task ImportRtModelAsTextAsync(IOspSession session, string jsonText)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.ValidateString(nameof(jsonText), jsonText);
var importer = new ImportRtModel(this);
await importer.ImportText(session, jsonText);
}
public async Task ImportRtModelAsync(IOspSession session, string filePath, CancellationToken?cancellationToken)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.ValidateFilePath(nameof(filePath), filePath);
var importer = new ImportRtModel(this);
await importer.Import(session, filePath, cancellationToken);
}
protected ServiceClient(ServiceClientOptions options, IServiceClientAccessToken accessToken)
{
ArgumentValidation.Validate(nameof(options), options);
ArgumentValidation.Validate(nameof(accessToken), accessToken);
Options = options;
AccessToken = accessToken;
}
/// <summary>
/// Adds a distributed cache with pub sub mechanisms to the service collection
/// </summary>
/// <param name="services">The current service collection</param>
/// <returns>The <see cref="T:Microsoft.Extensions.DependencyInjection.IServiceCollection" /> so that additional calls can be chained.</returns>
public static IServiceCollection AddDistributedPubSubCache(this IServiceCollection services)
{
ArgumentValidation.Validate(nameof(services), services);
services.AddOptions();
services.Add(ServiceDescriptor.Singleton <IDistributedWithPubSubCache, DistributedWithPubSubCache>());
return(services);
}
public IAsyncCursor <TOutput> Aggregate <TOutput>(IOspSession session,
PipelineDefinition <TDocument, TOutput> pipelineDefinition)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.Validate(nameof(pipelineDefinition), pipelineDefinition);
return(_documentCollection.Aggregate(((IOspSessionInternal)session).SessionHandle, pipelineDefinition));
}
/// <summary>
/// Adds Osp to the pipeline.
/// </summary>
/// <param name="app">The application.</param>
/// <returns></returns>
// ReSharper disable once UnusedMethodReturnValue.Global
public static IApplicationBuilder UseOspPersistence(
this IApplicationBuilder app)
{
ArgumentValidation.Validate(nameof(app), app);
ConfigureOsp(app).GetAwaiter().GetResult();
return(app);
}
/// <summary>
/// Wraps <see cref="ResolveFieldContextExtensions.GetArgument{TType}"/> to validate the resulting argument instance.
/// Uses <see cref="IValidator.Validate(ValidationContext)"/> to perform validation.
/// If a <see cref="ValidationException"/> occurs it will be converted to <see cref="ExecutionError"/>s by a field middleware.
/// </summary>
public static TArgument GetValidatedArgument <TArgument>(this IResolveFieldContext context, string name, TArgument defaultValue = default)
{
Guard.AgainstNull(context, nameof(context));
var argument = context.GetArgument(name, defaultValue);
var validatorCache = context.GetCache();
ArgumentValidation.Validate(validatorCache, typeof(TArgument), argument, context.UserContext, context.Schema as IServiceProvider);
return(argument);
}
// ReSharper disable once MemberCanBePrivate.Global
public async Task <bool> IsTenantExistingAsync(IOspSession systemSession, string tenantId)
{
ArgumentValidation.Validate(nameof(systemSession), systemSession);
ArgumentValidation.ValidateString(nameof(tenantId), tenantId);
var ospDatabase = await GetOspDatabaseFromTenantAsync(systemSession, tenantId);
return(ospDatabase != null);
}
/// <summary>
/// Wraps <see cref="ResolveFieldContextExtensions.GetArgument{TType}"/> to validate the resulting argument instance.
/// Uses <see cref="IValidator.Validate(IValidationContext)"/> to perform validation.
/// If a <see cref="ValidationException"/> occurs it will be converted to <see cref="ExecutionError"/>s by a field middleware.
/// </summary>
public static object GetValidatedArgument(this IResolveFieldContext context, Type argumentType, string name, object?defaultValue = null)
{
Guard.AgainstNull(context, nameof(context));
var argument = context.GetArgument(argumentType, name, defaultValue);
var validatorCache = context.GetCache();
ArgumentValidation.Validate(validatorCache, argumentType, argument, context.UserContext, context.Schema as IServiceProvider);
return(argument);
}
public IAggregateFluent <TDocument> Aggregate(IOspSession session)
{
ArgumentValidation.Validate(nameof(session), session);
return(_documentCollection.Aggregate(((IOspSessionInternal)session).SessionHandle,
new AggregateOptions {
AllowDiskUse = true
}));
}
/// <summary>
/// Adds a distributed cache with pub sub mechanisms to the service collection
/// </summary>
/// <param name="services">The current service collection</param>
/// <param name="setupAction">An <see cref="T:System.Action`1" /> to configure the provided
/// <see cref="T:Ianitor.Osp.Backend.Common.DistributedCache.DistributeCacheWithPubSubOptions" />.</param>
/// <returns>The <see cref="T:Microsoft.Extensions.DependencyInjection.IServiceCollection" /> so that additional calls can be chained.</returns>
public static IServiceCollection AddDistributedPubSubCache(this IServiceCollection services, Action <DistributeCacheWithPubSubOptions> setupAction)
{
ArgumentValidation.Validate(nameof(services), services);
ArgumentValidation.Validate(nameof(setupAction), setupAction);
services.AddOptions();
services.Configure(setupAction);
services.AddDistributedPubSubCache();
return(services);
}
public async Task ExportRtModelAsync(IOspSession session, OspObjectId queryId, string filePath,
CancellationToken?cancellationToken)
{
ArgumentValidation.Validate(nameof(session), session);
ArgumentValidation.Validate(nameof(queryId), queryId);
ArgumentValidation.ValidateExistingFile(nameof(filePath), filePath);
var exporter = new ExportRtModel(this);
await exporter.Export(session, queryId, filePath, cancellationToken);
}
public async Task <TEntity> GetRtEntityAsync <TEntity>(IOspSession session, RtEntityId rtEntityId)
where TEntity : RtEntity, new()
{
ArgumentValidation.Validate(nameof(rtEntityId), rtEntityId);
ArgumentValidation.ValidateString(nameof(rtEntityId.CkId), rtEntityId.CkId);
ArgumentValidation.Validate(nameof(rtEntityId.RtId), rtEntityId.RtId);
return(await _databaseContext.GetRtCollection <TEntity>(rtEntityId.CkId)
.DocumentAsync(session, rtEntityId.RtId.ToObjectId()));
}
public async Task CreateIdentityProvider(IdentityProviderDto identityProvider)
{
ArgumentValidation.Validate(nameof(identityProvider), identityProvider);
var request = new RestRequest("identityProviders", Method.POST);
request.AddJsonBody(identityProvider);
IRestResponse response = await Client.ExecuteAsync(request);
ValidateResponse(response);
}
public async Task CreateUser(UserDto userDto)
{
ArgumentValidation.Validate(nameof(userDto), userDto);
var request = new RestRequest("identities", Method.POST);
request.AddJsonBody(userDto);
IRestResponse response = await Client.ExecutePostAsync(request);
ValidateResponse(response);
}
public async Task CreateClient(ClientDto client)
{
ArgumentValidation.Validate(nameof(client), client);
var request = new RestRequest("clients", Method.POST);
request.AddJsonBody(client);
IRestResponse response = await Client.ExecuteAsync(request);
ValidateResponse(response);
}
