/// <summary>
/// Adds a named service to the dependency map.
/// </summary>
/// <remarks>This service will be created once per web session.</remarks>
/// <param name="map">The target dependency map.</param>
/// <param name="serviceName">The service name.</param>
/// <param name="serviceType">The service type.</param>
/// <param name="implementingType">The implementing type.</param>
public static void AddPerSessionService(this DependencyMap map, string serviceName, Type serviceType, Type implementingType)
{
// Add the SessionCache by default
if (!map.Contains(typeof(ICache)))
map.AddService<ICache, SessionCache>();
// The cached instantiation class will use the cache in the container
// to cache service instances
var dependency = new Dependency(serviceType, serviceName);
var implementation = new CachedInstantiation(new TransientType(implementingType, map, new ConstructorResolver()));
map.AddService(dependency, implementation);
}
public static void RegisterRepository(this IAcDomain acDomain, IEnumerable<string> efDbContextNames, params Assembly[] assemblies)
{
var repositoryContexts = efDbContextNames.Select(item => new EfRepositoryContext(acDomain, item)).ToList();
foreach (var assembly in assemblies)
{
foreach (var type in assembly.GetTypes())
{
if (type.IsClass && !type.IsAbstract && typeof(IAggregateRoot).IsAssignableFrom(type))
{
var repositoryType = typeof(GenericRepository<>);
var genericInterface = typeof(IRepository<>);
repositoryType = repositoryType.MakeGenericType(type);
genericInterface = genericInterface.MakeGenericType(type);
foreach (var repositoryContext in repositoryContexts)
{
if (TryGetType(repositoryContext, type))
{
var repository = Activator.CreateInstance(repositoryType, acDomain, repositoryContext.EfDbContextName);
acDomain.AddService(genericInterface, repository);
}
}
}
}
}
foreach (var item in repositoryContexts)
{
item.Dispose();
}
}
public static DiscordClient UsingCommands(this DiscordClient client, Action<CommandServiceConfigBuilder> configFunc = null)
{
var builder = new CommandServiceConfigBuilder();
configFunc(builder);
client.AddService(new CommandService(builder));
return client;
}
/// <summary>
/// Registers a service with a dependency map.
/// </summary>
/// <param name="map">The dependency map.</param>
/// <param name="service">The service that will be registered with the dependency map.</param>
internal static void Register(this DependencyMap map, IServiceInfo service)
{
var serviceName = service.ServiceName;
var serviceType = service.ServiceType;
var implementingType = service.ImplementingType;
map.AddService(serviceName, serviceType, implementingType);
}
/// <summary>
///
/// </summary>
/// <param name="acDomain"></param>
public static void RegisterEdiCore(this IAcDomain acDomain)
{
#region Edi
acDomain.AddService(typeof(IExecutorFactory), new ExecutorFactory());
acDomain.AddService(typeof(IDispatcherFactory), new DispatcherFactory());
acDomain.AddService(typeof(IAuthenticator), new DefaultAuthenticator());
acDomain.AddService(typeof(IMessageProducer), new DefaultMessageProducer());
acDomain.AddService(typeof(IStackTraceFormater), new JsonStackTraceFormater());
acDomain.AddService(typeof(IInputValidator), new DefaultInputValidator());
acDomain.AddService(typeof(IAuditDiscriminator), new DefaultAuditDiscriminator());
acDomain.AddService(typeof(IPermissionValidator), new DefaultPermissionValidator());
#endregion
}
public static void InitInterceptor(this IServiceContainer serviceContainer)
{
if (serviceContainer == null)
{
throw new ArgumentNullException("serviceContainer");
}
var interceptorProxy = new InterceptorProxy {Container = new ServiceLocatorAdapter(serviceContainer)};
serviceContainer.AddService(typeof(IInterceptorProxy), interceptorProxy);
serviceContainer.PostProcessors.Add(new InterceptorPostProcessor());
}
public static void UseMulticastSubscriptionClient(this ServiceBusConfigurator configurator,
Action<MulticastSubscriptionClientConfigurator> configureCallback)
{
string network = null;
var clientConfigurator = new MulticastSubscriptionClientConfiguratorImpl();
configureCallback(clientConfigurator);
configurator.AddSubscriptionObserver( (bus, router) =>
{
network = router.Network;
return clientConfigurator.Create(bus, router);
});
configurator.AddService(BusServiceLayer.Presentation,
() => new GroupMessageRouter(
clientConfigurator.SubscriptionBus,
clientConfigurator.GroupSelectionStrategy,
network));
}
public static DiscordClient UsingCommands(this DiscordClient client, CommandServiceConfig config = null)
{
client.AddService(new CommandService(config));
return client;
}
public static DiscordClient UsingAudio(this DiscordClient client, AudioServiceConfig config = null)
{
client.AddService(new AudioService(config));
return client;
}
public static DiscordClient UsingGlobalWhitelist(this DiscordClient client, params ulong[] initialUserIds)
{
client.AddService(new WhitelistService(initialUserIds));
return client;
}
public static DiscordClient UsingDynamicPerms(this DiscordClient client)
{
client.AddService(new DynamicPermissionService());
client.AddModule<DynamicPermissionModule>("Dynamic Permissions");
return client;
}
public static DiscordClient UsingPermissionLevels(this DiscordClient client, Func<User, Channel, int> permissionResolver)
{
client.AddService(new PermissionLevelService(permissionResolver));
return client;
}
public static DiscordClient UsingCommands(this DiscordClient client, CommandServiceConfig config = null, Func<Channel, bool> getNsfwFlag = null, Func<User, bool> getMusicFlag = null, Func<Channel, User, bool> getIgnoredChannelFlag = null)
{
client.AddService(new CommandService(config, getNsfwFlag, getMusicFlag, getIgnoredChannelFlag));
return client;
}
