513 lines
18 KiB
C#
513 lines
18 KiB
C#
using System;
|
|
using System.Linq;
|
|
using Microsoft.AspNetCore.Builder;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using xCategoryService.Configurations;
|
|
using xCategoryService.Constants;
|
|
using xCategoryService.Helpers;
|
|
using xCategoryService.Interfaces;
|
|
using xCategoryService.Interfaces.Dtos;
|
|
using xCategoryService.Interfaces.Entities;
|
|
using xCategoryService.Providers;
|
|
using xCategoryService.Providers.Dtos;
|
|
using xCategoryService.Providers.Entities;
|
|
using xCommons.Extensions;
|
|
using xCommons.Helpers;
|
|
using xDataService.Constants;
|
|
using xDataService.Db;
|
|
using xDataService.DI;
|
|
using xDataService.Models;
|
|
using xExceptions.Constants;
|
|
using xPushService.DI;
|
|
using xPushService.Helpers;
|
|
|
|
namespace xCategoryService.DI
|
|
{
|
|
public static class XDIHelperExtension
|
|
{
|
|
/// <summary>
|
|
/// Extract Service Configurations ...
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <returns></returns>
|
|
public static XCategoryServiceConfiguration GetXCategoryServiceConfigurations(
|
|
this IConfiguration source
|
|
)
|
|
{
|
|
//
|
|
XCategoryServiceConfiguration result = null;
|
|
|
|
//
|
|
var section = source.GetSection(Constants.ConfigurationNodeNames.CATEGORY_SERVICE_NODE);
|
|
var sectionJson = source.GetSectionAsJson(Constants.ConfigurationNodeNames.CATEGORY_SERVICE_NODE);
|
|
if (!section.IsNull())
|
|
{
|
|
result = sectionJson.FromJSON<XCategoryServiceConfiguration>();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register Service Configuration ...
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="configuration"></param>
|
|
public static void AddXCategoryServiceConfiguration(
|
|
this IServiceCollection source,
|
|
IConfiguration configuration
|
|
)
|
|
{
|
|
//
|
|
// Extract Configuration Class ...
|
|
var config = configuration.GetXCategoryServiceConfigurations();
|
|
|
|
//
|
|
// Register Class as Service ...
|
|
source.AddXCategoryServiceConfiguration(config);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register Service Configuration ...
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="configuration"></param>
|
|
public static void AddXCategoryServiceConfiguration(
|
|
this IServiceCollection source,
|
|
XCategoryServiceConfiguration configuration
|
|
)
|
|
{
|
|
//
|
|
// Normalize Configuration Class ...
|
|
if (configuration.IsNull())
|
|
{
|
|
configuration = new XCategoryServiceConfiguration();
|
|
}
|
|
|
|
//
|
|
// Register ...
|
|
source.AddSingleton(configuration);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register Service ...
|
|
/// </summary>
|
|
/// <param name="services"></param>
|
|
/// <param name="repositoryType"></param>
|
|
/// <param name="lifeTime"></param>
|
|
public static void AddXCategoryService(
|
|
this IServiceCollection services,
|
|
XRepositoryType repositoryType,
|
|
ServiceLifetime lifeTime = ServiceLifetime.Scoped
|
|
)
|
|
{
|
|
AddCategoryService(
|
|
contextType: null,
|
|
services: services,
|
|
lifeTime: lifeTime,
|
|
repositoryType: repositoryType
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register Service ...
|
|
/// </summary>
|
|
/// <typeparam name="TContext"></typeparam>
|
|
/// <param name="services"></param>
|
|
/// <param name="repositoryType"></param>
|
|
/// <param name="lifeTime"></param>
|
|
public static void AddXCategoryService<TContext>(
|
|
this IServiceCollection services,
|
|
XRepositoryType repositoryType,
|
|
ServiceLifetime lifeTime = ServiceLifetime.Scoped
|
|
)
|
|
where TContext : XDbContext
|
|
{
|
|
AddCategoryService(
|
|
services: services,
|
|
lifeTime: lifeTime,
|
|
contextType: typeof(TContext),
|
|
repositoryType: repositoryType
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use XSubCategoryService Middleware ...
|
|
/// </summary>
|
|
/// <param name="app"></param>
|
|
/// <param name="isDevelopmentEnvironment"></param>
|
|
public static void UseXCategoryService(
|
|
this IApplicationBuilder app,
|
|
bool isDevelopmentEnvironment = false
|
|
)
|
|
{
|
|
//
|
|
#region Using Hubs ...
|
|
//
|
|
var pushHelper = new XPushServiceHelper();
|
|
|
|
//
|
|
// Category ...
|
|
pushHelper.AddHub<XCategoryDtoHub>(XCategoryServiceConstants.XCategoryDtoHub);
|
|
pushHelper.AddHub<XCategoryEntityHub>(XCategoryServiceConstants.XCategoryEntityHub);
|
|
|
|
//
|
|
// SubCategory ...
|
|
pushHelper.AddHub<XSubCategoryDtoHub>(XCategoryServiceConstants.XSubCategoryDtoHub);
|
|
pushHelper.AddHub<XSubCategoryEntityHub>(XCategoryServiceConstants.XSubCategoryEntityHub);
|
|
|
|
//
|
|
app.UseXPushService(pushHelper);
|
|
#endregion
|
|
|
|
//
|
|
// Using XCategory Repository Descriptor ...
|
|
if (!categoryDescriptor.IsNull())
|
|
{
|
|
//
|
|
app.UseXRepository(
|
|
descriptor: categoryDescriptor,
|
|
isDevelopmentEnvironment: isDevelopmentEnvironment
|
|
);
|
|
}
|
|
|
|
//
|
|
// Using XSubCategory Repository Descriptor ...
|
|
if (!subCategoryDescriptor.IsNull())
|
|
{
|
|
//
|
|
app.UseXRepository(
|
|
descriptor: subCategoryDescriptor,
|
|
isDevelopmentEnvironment: isDevelopmentEnvironment
|
|
);
|
|
}
|
|
|
|
//
|
|
// Create an Scope for Services Acces ...
|
|
// Handle Seeding Category/SubCategory Resources ...
|
|
using (var scope = app.ApplicationServices.CreateScope())
|
|
{
|
|
//
|
|
// Retrieve Configuratuions ...
|
|
var categoryProvider = scope.ServiceProvider.GetService<IXCategoryProvider>();
|
|
var subCategoryProvider = scope.ServiceProvider.GetService<IXSubCategoryProvider>();
|
|
var configuration = scope.ServiceProvider.GetService<XCategoryServiceConfiguration>();
|
|
if (!configuration.IsNullOrDefault() &&
|
|
!categoryProvider.IsNullOrDefault() &&
|
|
!subCategoryDescriptor.IsNullOrDefault()
|
|
)
|
|
{
|
|
//
|
|
// Logging ...
|
|
Log("Start Seeding ...");
|
|
|
|
//
|
|
// Count Data in Category ...
|
|
var hasCategory = categoryProvider.Count().GetAwaiter().GetResult() > 0;
|
|
var hasSubCategory = subCategoryProvider.Count().GetAwaiter().GetResult() > 0;
|
|
|
|
//
|
|
// Seed Category Resources ...
|
|
var canSeed =
|
|
!hasCategory &&
|
|
configuration.Categories.HasChild();
|
|
if (canSeed)
|
|
{
|
|
//
|
|
// Loop through Provided items ...
|
|
foreach (var cat in configuration.Categories)
|
|
{
|
|
//
|
|
try
|
|
{
|
|
//
|
|
Log($"Start Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} ...");
|
|
|
|
//
|
|
categoryProvider.Refresh(
|
|
resource: cat,
|
|
userInfo: null,
|
|
connectionId: null,
|
|
cancellationToken: default
|
|
)
|
|
.GetAwaiter()
|
|
.GetResult();
|
|
|
|
//
|
|
Log($"Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} Finished Successfully ...");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log($"Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} Failed due: {ex.Message} ...");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Seed SubCategory Resources ...
|
|
canSeed =
|
|
!hasSubCategory &&
|
|
configuration.SubCategories.HasChild();
|
|
if (canSeed)
|
|
{
|
|
//
|
|
// Loop through Provided items ...
|
|
foreach (var subcat in configuration.SubCategories)
|
|
{
|
|
//
|
|
try
|
|
{
|
|
//
|
|
Log($"Start Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} ...");
|
|
|
|
//
|
|
subCategoryProvider.Refresh(
|
|
userInfo: null,
|
|
resource: subcat,
|
|
connectionId: null,
|
|
cancellationToken: default
|
|
)
|
|
.GetAwaiter()
|
|
.GetResult();
|
|
|
|
//
|
|
Log($"Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} Finished Successfully ...");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log($"Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} Failed due: {ex.Message} ...");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
Log("Finish Seeding ...");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
#region Private ...
|
|
private static XRepositoryDescriptor categoryDescriptor = null;
|
|
private static XRepositoryDescriptor subCategoryDescriptor = null;
|
|
|
|
/// <summary>
|
|
/// a LogTag for Service ...
|
|
/// </summary>
|
|
private static string XLogTag = XCategoryServiceConstants.XCategoryServiceDILogTag;
|
|
|
|
/// <summary>
|
|
/// print a log in Console ...
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
private static void Log(string message)
|
|
{
|
|
Console.WriteLine($"{XLogTag} => {message}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register Service ...
|
|
/// </summary>
|
|
/// <param name="services"></param>
|
|
/// <param name="repositoryType"></param>
|
|
/// <param name="contextType"></param>
|
|
/// <param name="lifeTime"></param>
|
|
private static void AddCategoryService(
|
|
IServiceCollection services,
|
|
XRepositoryType repositoryType,
|
|
Type contextType = null,
|
|
ServiceLifetime lifeTime = ServiceLifetime.Scoped
|
|
)
|
|
{
|
|
//
|
|
var exception = XException.InvalidArgs.ToException(); ;
|
|
|
|
//
|
|
// Services ...
|
|
var isServicesExists = !services.IsNull();
|
|
if (!isServicesExists)
|
|
{
|
|
//
|
|
Log("Service Registration failed, services not provided ...");
|
|
throw exception;
|
|
}
|
|
|
|
//
|
|
// Lifetime ...
|
|
var isLifetimeExists = !lifeTime.IsNull();
|
|
if (!isLifetimeExists)
|
|
{
|
|
//
|
|
Log("Service Registration failed, lifetime not provided ...");
|
|
throw exception;
|
|
}
|
|
|
|
//
|
|
// Validate Repository Type ...
|
|
var isRepositoryTypeValid =
|
|
(repositoryType == XRepositoryType.EF &&
|
|
!contextType.IsNull()) ||
|
|
((repositoryType == XRepositoryType.Mongo ||
|
|
repositoryType == XRepositoryType.InMemory) &&
|
|
contextType.IsNull());
|
|
if (!isRepositoryTypeValid)
|
|
{
|
|
//
|
|
Log("Service Registration failed, Invalid Repository Type and Context Type ...");
|
|
throw exception;
|
|
}
|
|
|
|
//
|
|
// Maske Instance of Repository Descriptor
|
|
// Based on Provided Type ...
|
|
switch (repositoryType)
|
|
{
|
|
//
|
|
case XRepositoryType.EF:
|
|
//
|
|
// Category ...
|
|
categoryDescriptor = typeof(XCategoryServiceHelper)
|
|
.InvokeGenericMethod<XRepositoryDescriptor>(
|
|
args: null,
|
|
runtimeType: contextType,
|
|
methodName: XCategoryServiceConstants.GetXCategoryEFRepositoryDescriptor
|
|
);
|
|
|
|
//
|
|
// SubCategory ...
|
|
subCategoryDescriptor = typeof(XCategoryServiceHelper)
|
|
.InvokeGenericMethod<XRepositoryDescriptor>(
|
|
args: null,
|
|
runtimeType: contextType,
|
|
methodName: XCategoryServiceConstants.GetXSubCategoryEFRepositoryDescriptor
|
|
);
|
|
break;
|
|
|
|
//
|
|
case XRepositoryType.Mongo:
|
|
//
|
|
// Category ...
|
|
categoryDescriptor = XCategoryServiceHelper.GetXCategoryMongoRepositoryDescriptor();
|
|
|
|
//
|
|
// SubCategory ...
|
|
subCategoryDescriptor = XCategoryServiceHelper.GetXSubCategoryMongoRepositoryDescriptor();
|
|
break;
|
|
|
|
//
|
|
case XRepositoryType.InMemory:
|
|
//
|
|
// Category ...
|
|
categoryDescriptor = XCategoryServiceHelper.GetXCategoryInMemoryRepositoryDescriptor();
|
|
|
|
//
|
|
// SubCategory ...
|
|
subCategoryDescriptor = XCategoryServiceHelper.GetXSubCategoryInMemoryRepositoryDescriptor();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Register Category Repository Descriptor ...
|
|
if (!categoryDescriptor.IsNull())
|
|
{
|
|
//
|
|
services.AddXRepository(
|
|
lifeTime: lifeTime,
|
|
descriptor: categoryDescriptor
|
|
);
|
|
}
|
|
|
|
//
|
|
// Register SubCategory Repository Descriptor ...
|
|
if (!subCategoryDescriptor.IsNull())
|
|
{
|
|
//
|
|
services.AddXRepository(
|
|
lifeTime: lifeTime,
|
|
descriptor: subCategoryDescriptor
|
|
);
|
|
}
|
|
|
|
//
|
|
#region Register Services ...
|
|
//
|
|
#region Category ...
|
|
//
|
|
// Models ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryServiceProvider), typeof(XCategoryServiceProvider), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryRepositoryService), typeof(XCategoryRepositoryService), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryRepositoryProvider), typeof(XCategoryRepositoryProvider), lifeTime)
|
|
);
|
|
|
|
//
|
|
// Resource Providers ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryTitleResourceProvider), typeof(XCategoryTitleResourceProvider), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryDescriptionResourceProvider), typeof(XCategoryDescriptionResourceProvider), lifeTime)
|
|
);
|
|
|
|
//
|
|
// Reference Providers ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategorySubCategoryReferenceProvider), typeof(XCategorySubCategoryReferenceProvider), lifeTime)
|
|
);
|
|
|
|
//
|
|
// Provider ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryProvider), typeof(XCategoryProvider), lifeTime)
|
|
);
|
|
#endregion
|
|
|
|
//
|
|
#region SubCategory ...
|
|
//
|
|
// Models ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryServiceProvider), typeof(XSubCategoryServiceProvider), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryRepositoryService), typeof(XSubCategoryRepositoryService), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryRepositoryProvider), typeof(XSubCategoryRepositoryProvider), lifeTime)
|
|
);
|
|
|
|
//
|
|
// Resource Providers ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryTitleResourceProvider), typeof(XSubCategoryTitleResourceProvider), lifeTime)
|
|
);
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryDescriptionResourceProvider), typeof(XSubCategoryDescriptionResourceProvider), lifeTime)
|
|
);
|
|
|
|
//
|
|
// Provider ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXSubCategoryProvider), typeof(XSubCategoryProvider), lifeTime)
|
|
);
|
|
#endregion
|
|
#endregion
|
|
|
|
//
|
|
// Register Service Main Provider ...
|
|
services.Add(
|
|
new ServiceDescriptor(typeof(IXCategoryService), typeof(XCategoryService), lifeTime)
|
|
);
|
|
|
|
//
|
|
Log("Service Regitration Succeed ...");
|
|
}
|
|
#endregion
|
|
}
|
|
} |