public static void RegisterSharpRepository(this Container container, ISharpRepositoryConfiguration configuration)
{
container.ResolveUnregisteredType += (s, e) =>
{
var type = e.UnregisteredServiceType;
if (type.IsGenericType)
{
var args = type.GetGenericArguments();
var typedef = type.GetGenericTypeDefinition();
if (typedef == typeof(IRepository<>))
{
e.Register(() => RepositoryFactory.GetInstance(args[0], configuration));
}
else if (typedef == typeof(IRepository<,>))
{
e.Register(() => RepositoryFactory.GetInstance(args[0], args[1], configuration));
}
else if (typedef == typeof(ICompoundKeyRepository<,,>))
{
e.Register(() => RepositoryFactory.GetInstance(args[0], args[1], args[2], configuration));
}
}
};
}
public static LambdaInstance<object> ForRepositoriesUseSharpRepository(this IInitializationExpression initialization, ISharpRepositoryConfiguration configuration)
{
initialization.Scan(scan => scan.IncludeNamespaceContainingType<IAmInRepository>());
initialization.For(typeof(IRepository<>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], configuration);
}
);
initialization.For(typeof(IRepository<,>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], configuration);
}
);
return initialization.For(typeof(ICompoundKeyRepository<,,>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], genericArgs[2], configuration);
}
);
}
public static void ForRepositoriesUseSharpRepository(this ConfigurationExpression initialization, ISharpRepositoryConfiguration configuration)
{
initialization.Scan(scan => scan.IncludeNamespaceContainingType<IAmInRepository>());
initialization.For(typeof(IRepository<>)).Use(new RepositoryNoKeyInstanceFactory(configuration));
initialization.For(typeof(IRepository<,>)).Use(new RepositorySingleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository<,,>)).Use(new RepositoryDoubleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository<,,,>)).Use(new RepositoryTripleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository<>)).Use(new RepositoryCompoundKeyInstanceFactory(configuration));
}
public static void BindSharpRepository(this IKernel kernel, ISharpRepositoryConfiguration configuration)
{
kernel.Bind(typeof (IRepository<>)).ToMethod(context =>
{
var genericArgs = context.Request.ParentRequest.Service.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], configuration);
});
kernel.Bind(typeof(IRepository<,>)).ToMethod(context =>
{
var genericArgs = context.Request.ParentRequest.Service.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], configuration);
});
}
public static void RegisterSharpRepository(this IWindsorContainer container, ISharpRepositoryConfiguration configuration)
{
container.Register(Component.For(typeof(IRepository<>)).UsingFactoryMethod((c, t) =>
{
var genericArgs = t.GenericArguments;
return RepositoryFactory.GetInstance(genericArgs[0], configuration);
}));
container.Register(Component.For(typeof(IRepository<>)).UsingFactoryMethod((c, t) =>
{
var genericArgs = t.GenericArguments;
return RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], configuration);
}));
}
public static object GetInstance(Type entityType, Type keyType, Type key2Type, Type key3Type, ISharpRepositoryConfiguration configuration, string repositoryName = null)
{
if (String.IsNullOrEmpty(repositoryName))
{
// if no specific repository is provided then check to see if the SharpRepositoryConfigurationAttribute is used
repositoryName = GetAttributeRepositoryName(entityType);
}
var method = typeof(ISharpRepositoryConfiguration).GetTypeInfo().DeclaredMethods.First(m => m.Name == "GetInstance" && m.ReturnType.Name == "ICompoundKeyRepository`4");
var genericMethod = method.MakeGenericMethod(entityType, keyType, key2Type, key3Type);
return(genericMethod.Invoke(configuration, new object[] { repositoryName }));
}
public RepositoryFactory(ISharpRepositoryConfiguration configuration)
{
Configuration = configuration;
}
public static IRepository <T, int> GetInstance <T>(ISharpRepositoryConfiguration configuration, string repositoryName = null) where T : class, new()
{
return(GetInstance <T, int>(configuration, repositoryName));
}
public static void RegisterSharpRepository(this UnityContainer container, ISharpRepositoryConfiguration configuration)
{
throw new NotImplementedException();
}
public static void ForRepositoriesUseSharpRepository(this ConfigurationExpression initialization, ISharpRepositoryConfiguration configuration)
{
initialization.Scan(scan => scan.IncludeNamespaceContainingType <IAmInRepository>());
initialization.For(typeof(IRepository <>)).Use(new RepositoryNoKeyInstanceFactory(configuration));
initialization.For(typeof(IRepository <,>)).Use(new RepositorySingleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository <, ,>)).Use(new RepositoryDoubleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository <, , ,>)).Use(new RepositoryTripleKeyInstanceFactory(configuration));
initialization.For(typeof(ICompoundKeyRepository <>)).Use(new RepositoryCompoundKeyInstanceFactory(configuration));
}
public RepositoryRegistrationSource(ISharpRepositoryConfiguration configuration, string repositoryName = null, params object[] lifetimeScopeTag)
{
Configuration = configuration;
RepositoryName = repositoryName;
LifetimeScopeTag = lifetimeScopeTag;
}
public ConfigurationBasedRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null)
{
Repository = RepositoryFactory.GetInstance <T, TKey>(configuration, repositoryName);
}
public RepositoryCompoundKeyInstance(ISharpRepositoryConfiguration configuration)
: base(() => RepositoryFactory.GetCompoundKeyInstance <T>(configuration, null))
{
}
public UserFromConfigRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
public static IServiceProvider UseSharpRepository(this IServiceCollection services, ISharpRepositoryConfiguration sharpRepoConfig, string repositoryName = null)
{
var container = new Container();
container.Configure(config =>
{
config.Scan(x =>
{
x.TheCallingAssembly();
x.AssembliesAndExecutablesFromApplicationBaseDirectory();
x.LookForRegistries();
});
config.ForRepositoriesUseSharpRepository(sharpRepoConfig, repositoryName);
config.Populate(services);
});
var resolver = container.GetInstance <IServiceProvider>();
RepositoryDependencyResolver.SetDependencyResolver(resolver);
// Finally, make sure we return an IServiceProvider. This makes
// ASP.NET use the StructureMap container to resolve its services.
return(resolver);
}
public RepositoryInstance(ISharpRepositoryConfiguration configuration, string repositoryName = null)
: base(() => RepositoryFactory.GetInstance <T, TKey, TKey2>(configuration, repositoryName))
{
}
public WxOfficialRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
public static void RegisterSharpRepository(this ContainerBuilder container, ISharpRepositoryConfiguration configuration)
{
}
public MaintenanceOrdersRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
public sealed record ServiceManagerDeamonState(ISharpRepositoryConfiguration Repository);
public static void RegisterSharpRepository(this UnityContainer container, ISharpRepositoryConfiguration configuration)
{
throw new NotImplementedException();
}
public static IActorRef Init(ActorSystem system, ISharpRepositoryConfiguration repository)
=> system.ActorOf("ServiceDeamon", Feature.Create(() => new ServiceManagerDeamon(), _ => new ServiceManagerDeamonState(repository)));
/// <summary>
/// Registers in autofac container all IRepository and ICompoundKeyRepository resolutions.
/// </summary>
/// <param name="container"></param>
/// <param name="configuration"></param>
/// <param name="repositoryName"></param>
/// <param name="lifetimeScopeTag">Accepts any MatchingScopeLifetimeTags scope enum tag</param>
public static void RegisterSharpRepository(this ContainerBuilder container, ISharpRepositoryConfiguration configuration, string repositoryName = null, params object[] lifetimeScopeTag)
{
container.RegisterSource(new RepositoryRegistrationSource(configuration, repositoryName, lifetimeScopeTag));
}
public static ICompoundKeyRepository <T, TKey, TKey2, TKey3> GetInstance <T, TKey, TKey2, TKey3>(ISharpRepositoryConfiguration configuration, string repositoryName) where T : class, new()
{
if (!configuration.HasRepository)
{
throw new Exception("There are no repositories configured");
}
var repositoryConfiguration = configuration.GetRepository(repositoryName);
var repository = repositoryConfiguration.GetInstance <T, TKey, TKey2, TKey3>();
if (repository == null)
{
return(null);
}
var strategyConfiguration = configuration.GetCachingStrategy(repositoryConfiguration.CachingStrategy);
if (strategyConfiguration == null)
{
return(repository);
}
var cachingStrategy = strategyConfiguration.GetInstance <T, TKey, TKey2, TKey3>();
if (cachingStrategy == null)
{
return(repository);
}
var providerConfiguration = configuration.GetCachingProvider(repositoryConfiguration.CachingProvider);
if (providerConfiguration != null)
{
cachingStrategy.CachingProvider = providerConfiguration.GetInstance();
}
repository.CachingStrategy = cachingStrategy;
return(repository);
}
public OrdemManutencaoRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
public WxNewsItemRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
/// <summary>
/// Configures StructureMap container telling to resolve IRepository and ICompoundKeyRepository with the repository from configuration
/// </summary>
/// <param name="init"></param>
/// <param name="configuration"></param>
/// <param name="repositoryName">name of repository implementation in configuration, null tell to use default in configuration</param>
/// <param name="lifecycle">StructureMap coping of variables default is Lifecycle.Transient</param>
public static void ForRepositoriesUseSharpRepository(this ConfigurationExpression init, ISharpRepositoryConfiguration configuration, string repositoryName = null, ILifecycle lifeCycle = null)
{
if (lifeCycle == null)
{
lifeCycle = Lifecycles.Transient;
}
init.For(typeof(IRepository <>))
.LifecycleIs(lifeCycle)
.Use(new RepositoryNoKeyInstanceFactory(configuration, repositoryName));
init.For(typeof(IRepository <,>))
.LifecycleIs(lifeCycle)
.Use(new RepositorySingleKeyInstanceFactory(configuration, repositoryName));
init.For(typeof(ICompoundKeyRepository <, ,>))
.LifecycleIs(lifeCycle)
.Use(new RepositoryDoubleKeyInstanceFactory(configuration, repositoryName));
init.For(typeof(ICompoundKeyRepository <, , ,>))
.LifecycleIs(lifeCycle)
.Use(new RepositoryTripleKeyInstanceFactory(configuration, repositoryName));
init.For(typeof(ICompoundKeyRepository <>))
.LifecycleIs(lifeCycle)
.Use(new RepositoryCompoundKeyInstanceFactory(configuration, repositoryName));
}
public RepositoryNoKeyInstanceFactory(ISharpRepositoryConfiguration configuration, string repositoryName = null)
{
this.configuration = configuration;
this.repositoryName = repositoryName;
}
public static object GetInstance(Type entityType, ISharpRepositoryConfiguration configuration, string repositoryName = null)
{
return(GetInstance(entityType, typeof(int), configuration, repositoryName));
}
public RepositoryInstance(ISharpRepositoryConfiguration configuration, string repositoryName = null)
: base(() => (IRepository <T>)RepositoryFactory.GetInstance(typeof(T), configuration, null))
{
}
public static ICompoundKeyRepository <T, TKey, TKey2, TKey3> GetInstance <T, TKey, TKey2, TKey3>(ISharpRepositoryConfiguration configuration, string repositoryName = null) where T : class, new()
{
if (String.IsNullOrEmpty(repositoryName))
{
// if no specific repository is provided then check to see if the SharpRepositoryConfigurationAttribute is used
repositoryName = GetAttributeRepositoryName(typeof(T));
}
return(configuration.GetInstance <T, TKey, TKey2, TKey3>(repositoryName));
}
public static LambdaInstance <object> ForRepositoriesUseSharpRepository(this IInitializationExpression initialization, ISharpRepositoryConfiguration configuration)
{
initialization.Scan(scan => scan.IncludeNamespaceContainingType <IAmInRepository>());
initialization.For(typeof(IRepository <>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return(RepositoryFactory.GetInstance(genericArgs[0], configuration));
}
);
initialization.For(typeof(IRepository <,>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return(RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], configuration));
}
);
return(initialization.For(typeof(ICompoundKeyRepository <, ,>))
.Use(context =>
{
var genericArgs = context.BuildStack.Current.RequestedType.GetGenericArguments();
return RepositoryFactory.GetInstance(genericArgs[0], genericArgs[1], genericArgs[2], configuration);
}
));
}
public AreaRepository(ISharpRepositoryConfiguration configuration, string repositoryName = null) : base(configuration, repositoryName)
{
}
public RepositoryInstance(ISharpRepositoryConfiguration configuration)
: base(() => RepositoryFactory.GetInstance <T, TKey>(configuration, null))
{
}
public RepositorySingleKeyInstanceFactory(ISharpRepositoryConfiguration configuration)
{
this.configuration = configuration;
}
public RepositoryCompoundKeyInstance(ISharpRepositoryConfiguration configuration, string repositoryName = null)
: base(() => RepositoryFactory.GetCompoundKeyInstance <T>(configuration, repositoryName))
{
}
