private async Task <HttpResponseMessage> DoRequestAsync(HttpRequestMessage request)
{
var entityType = typeof(TEntity).FullName;
var repoType = typeof(TCorrespondingRepository).FullName;
var alias = AliasHelper.GetRepositoryAlias(typeof(ApiRepository <TEntity, TCorrespondingRepository>));
var httpClient = _httpClientFactory.CreateClient(alias);
if (httpClient.BaseAddress == default)
{
throw new InvalidOperationException($"Please configure an HttpClient for the repository '{alias}' using " +
$".{nameof(RapidCMSMiddleware.AddRapidCMSApiRepository)}([..]) and configure its BaseAddress correctly.");
}
var response = await httpClient.SendAsync(request);
return(response.StatusCode switch
{
HttpStatusCode.OK => response,
HttpStatusCode.Unauthorized => throw new UnauthorizedAccessException(),
HttpStatusCode.Forbidden => throw new UnauthorizedAccessException(),
HttpStatusCode.NotFound => throw new NotFoundException($"{request.RequestUri} not found."),
_ => throw new InvalidOperationException()
});
public IApiRepositoryConfig RegisterRepository <TEntity, TMappedEntity, TRepository>()
where TEntity : class, IEntity
where TMappedEntity : class
where TRepository : IRepository
{
var fullType = typeof(ApiMappedRepository <TEntity, TMappedEntity>);
var alias = AliasHelper.GetRepositoryAlias(fullType);
if (Repositories.Any(x => x.Alias == alias))
{
throw new NotUniqueException(nameof(TRepository));
}
var config = new ApiRepositoryConfig
{
Alias = alias,
EntityType = typeof(TEntity),
DatabaseType = typeof(TMappedEntity),
RepositoryType = typeof(TRepository),
ApiRepositoryType = fullType
};
Repositories.Add(config);
return(config);
}
public ApiRepository(IHttpClientFactory httpClientFactory, IMemoryCache memoryCache)
{
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Add(new EntityModelJsonConverter <TEntity>());
var repositoryAlias = AliasHelper.GetRepositoryAlias(typeof(ApiRepository <TEntity, TCorrespondingRepository>));
_apiRepositoryHelper = new ApiRepositoryHelper(memoryCache, httpClientFactory, jsonSerializerSettings, repositoryAlias);
}
public ApiMappedRepository(IHttpClientFactory httpClientFactory)
{
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Add(new EntityModelJsonConverter <TEntity>());
var repositoryAlias = AliasHelper.GetRepositoryAlias(typeof(ApiMappedRepository <TEntity, TDatabaseEntity>));
_apiRepositoryHelper = new ApiRepositoryHelper(httpClientFactory, jsonSerializerSettings, repositoryAlias);
}
public CmsRepositoryTypeResolver(ICmsConfig cmsConfig, IServiceProvider serviceProvider)
{
using var repositoryResolvingScope = serviceProvider.CreateScope();
var types = cmsConfig.RepositoryTypes.Distinct();
_repositoryTypes = types.ToDictionary(
type => AliasHelper.GetRepositoryAlias(repositoryResolvingScope.ServiceProvider.GetRequiredService(type).GetType()));
_originallyRegisterdRepositoriesToAlias = _repositoryTypes.ToDictionary(x => x.Value, x => x.Key);
}
/// <summary>
/// Adds the repository as scoped service and adds a plain HttpClient for the given repository.
/// </summary>
/// <typeparam name="TIRepository"></typeparam>
/// <typeparam name="TRepository"></typeparam>
/// <param name="services"></param>
/// <param name="baseUri"></param>
/// <returns></returns>
public static IHttpClientBuilder AddRapidCMSApiRepository <TIRepository, TRepository>(this IServiceCollection services, Uri baseUri)
where TIRepository : class
where TRepository : class, TIRepository
{
var alias = AliasHelper.GetRepositoryAlias(typeof(TRepository));
services.AddScoped <TIRepository, TRepository>();
return(services.AddHttpClient(alias)
.ConfigureHttpClient(x => x.BaseAddress = new Uri(baseUri, $"api/_rapidcms/{alias}/")));
}
private static void AddServicesRequiringRepositories(IServiceCollection services, CmsConfig rootConfig)
{
var repositoryTypeDictionary = new Dictionary <string, Type>();
var reverseRepositoryTypeDictionary = new Dictionary <Type, string>();
var collectionAliasDictionary = new Dictionary <string, List <string> >();
foreach (var collection in rootConfig.CollectionsAndPages.OfType <ICollectionConfig>())
{
ProcessCollection(collection);
}
services.AddSingleton <IRepositoryTypeResolver>(new CmsRepositoryTypeResolver(repositoryTypeDictionary, reverseRepositoryTypeDictionary));
services.AddSingleton <ICollectionAliasResolver>(new CollectionAliasResolver(collectionAliasDictionary));
void ProcessCollection(ICollectionConfig collection)
{
var descriptor = services.FirstOrDefault(x => x.ServiceType == collection.RepositoryType);
if (descriptor == null)
{
throw new InvalidOperationException($"Could not find service descriptor for {collection.RepositoryType}. Please add it to the service collection.");
}
var implementationType = descriptor.ImplementationType;
if (implementationType == null)
{
throw new InvalidOperationException($"Could not find implementation type for {collection.RepositoryType}. Please add it as type to the service collection.");
}
var repositoryAlias = AliasHelper.GetRepositoryAlias(implementationType);
repositoryTypeDictionary[repositoryAlias] = collection.RepositoryType;
reverseRepositoryTypeDictionary[collection.RepositoryType] = repositoryAlias;
if (implementationType != collection.RepositoryType)
{
reverseRepositoryTypeDictionary[implementationType] = repositoryAlias;
}
if (!collectionAliasDictionary.ContainsKey(repositoryAlias))
{
collectionAliasDictionary.Add(repositoryAlias, new List <string>());
}
collectionAliasDictionary[repositoryAlias].Add(collection.Alias);
foreach (var subCollection in collection.CollectionsAndPages.OfType <ICollectionConfig>().Where(x => !x.Recursive))
{
ProcessCollection(subCollection);
}
}
}
private static void AddServicesRequiringRepositories(IServiceCollection services, CmsConfig rootConfig)
{
var repositoryTypeDictionary = new Dictionary <string, Type>();
var reverseRepositoryTypeDictionary = new Dictionary <Type, string>();
var collectionAliasDictionary = new Dictionary <string, List <string> >();
foreach (var collection in rootConfig.CollectionsAndPages.OfType <ICollectionConfig>())
{
ProcessCollection(collection);
}
services.AddSingleton <IRepositoryTypeResolver>(new CmsRepositoryTypeResolver(repositoryTypeDictionary, reverseRepositoryTypeDictionary));
services.AddSingleton <ICollectionAliasResolver>(new CollectionAliasResolver(collectionAliasDictionary));
void ProcessCollection(ICollectionConfig collection)
{
foreach (var repository in collection.RepositoryTypes)
{
var descriptor = services.FirstOrDefault(x => x.ServiceType == repository);
if (descriptor == null)
{
continue;
}
var implementationType = descriptor.ImplementationType;
if (implementationType == null)
{
continue;
}
var repositoryAlias = AliasHelper.GetRepositoryAlias(implementationType);
repositoryTypeDictionary[repositoryAlias] = repository;
reverseRepositoryTypeDictionary[repository] = repositoryAlias;
if (implementationType != repository)
{
reverseRepositoryTypeDictionary[implementationType] = repositoryAlias;
}
if (!collectionAliasDictionary.ContainsKey(repositoryAlias))
{
collectionAliasDictionary.Add(repositoryAlias, new List <string>());
}
collectionAliasDictionary[repositoryAlias].Add(collection.Alias);
}
foreach (var subCollection in collection.CollectionsAndPages.OfType <ICollectionConfig>().Where(x => x is not ReferencedCollectionConfig))
{
ProcessCollection(subCollection);
}
}
}
