static public IModuleDescriptor GetDescriptorById(Guid moduleTypeId)
{
IModuleDescriptor descriptor = null;
_moduleDescriptors.TryGetValue(moduleTypeId, out descriptor);
return(descriptor);
}
/// <summary>
/// 添加数据库上下文
/// </summary>
private static void AddDbContext(this IServiceCollection services, IModuleDescriptor module, DbModuleOptions options, DbOptions dbOptions)
{
var dbContextType = module.AssemblyDescriptor.Infrastructure.GetTypes().FirstOrDefault(m => m.Name.EqualsIgnoreCase(options.Name + "DbContext"));
if (dbContextType != null)
{
var dbContextOptionsAssemblyName = AssemblyHelper.GetCurrentAssemblyName().Replace("Integration", "") + dbOptions.Dialect;
var dbContextOptionsTypeName = dbOptions.Dialect + "DbContextOptions";
var dbContextOptionsType = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(dbContextOptionsAssemblyName)).GetType($"{dbContextOptionsAssemblyName}.{dbContextOptionsTypeName}");
var sp = services.BuildServiceProvider();
//日志工厂
var loggerFactory = dbOptions.Logging ? sp.GetService <ILoggerFactory>() : null;
//登录信息
var loginInfo = sp.GetService <ILoginInfo>();
//数据库上下文配置项
var contextOptions = (IDbContextOptions)Activator.CreateInstance(dbContextOptionsType, dbOptions, options, loggerFactory, loginInfo);
//数据库创建事件
var createDatabaseEvent = module.AssemblyDescriptor.Infrastructure.GetTypes().FirstOrDefault(m => typeof(IDatabaseCreateEvents).IsAssignableFrom(m));
if (createDatabaseEvent != null)
{
contextOptions.DatabaseCreateEvents = (IDatabaseCreateEvents)Activator.CreateInstance(createDatabaseEvent);
}
//注入数据库上下文
var dbContext = Activator.CreateInstance(dbContextType, contextOptions, sp);
services.AddSingleton(dbContextType, dbContext);
services.AddRepositories(module, (IDbContext)dbContext, dbOptions);
}
}
/// <summary>
/// 添加数据库上下文
/// </summary>
private static void AddDbContext(this IServiceCollection services, IModuleDescriptor module, DbConnectionOptions options, DbOptions dbOptions)
{
var dbContextType = module.AssemblyDescriptor.Infrastructure.GetTypes().FirstOrDefault(m => m.Name.EqualsIgnoreCase(options.Name + "DbContext"));
if (dbContextType != null)
{
var assemblyHelper = new AssemblyHelper();
var currAssemblyName = assemblyHelper.GetCurrentAssemblyName();
var dbContextOptionsAssemblyName = currAssemblyName.Substring(0, currAssemblyName.LastIndexOf('.') + 1) + options.Dialect;
var dbContextOptionsTypeName = options.Dialect + "DbContextOptions";
var dbContextOptionsType = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(dbContextOptionsAssemblyName)).GetType($"{dbContextOptionsAssemblyName}.{dbContextOptionsTypeName}");
//日志工厂
var loggerFactory = dbOptions.Logging ? services.BuildServiceProvider().GetService <ILoggerFactory>() : null;
//登录信息
var loginInfo = services.BuildServiceProvider().GetService <ILoginInfo>();
var contextOptions = (IDbContextOptions)Activator.CreateInstance(dbContextOptionsType, dbOptions, options, loggerFactory, loginInfo);
services.AddSingleton(typeof(IDbContext), sp => Activator.CreateInstance(dbContextType, contextOptions));
services.AddUnitOfWork(dbContextType, options);
services.AddRepositories(module, options);
}
}
public void AddDependency(IModuleDescriptor descriptor)
{
if (!_dependencies.Contains(descriptor))
{
_dependencies.Add(descriptor);
}
}
public static Dictionary <string, string> GetGroups(this IModuleDescriptor descriptor)
{
var dictionary = new Dictionary <string, string>
{
{
descriptor.Code,
descriptor.Name
}
};
var moduleAssemblyDescriptor = (ModuleAssemblyDescriptor)descriptor.AssemblyDescriptor;
var controllerTypes = (moduleAssemblyDescriptor.Web ?? moduleAssemblyDescriptor.Api).GetTypes()
.Where(m => m.Name.EndsWith("Controller"));
foreach (var type in controllerTypes)
{
var array = type.FullName.Split('.');
if (array.Length == 7)
{
string text = array[5];
var key = descriptor.Code + "_" + text;
if (text != "Controllers" && !dictionary.ContainsKey(key))
{
dictionary.Add(key, descriptor.Name + "_" + text);
}
}
}
return(dictionary);
}
/// <summary>
/// 添加仓储
/// </summary>
private static void AddRepositories(this IServiceCollection services, IModuleDescriptor module, DbConnectionOptions options)
{
var interfaceList = module.AssemblyDescriptor.Domain.GetTypes().Where(t => t.IsInterface && typeof(IRepository <>).IsImplementType(t)).ToList();
if (!interfaceList.Any())
{
return;
}
//根据仓储的命名空间名称来注入不同数据库的仓储
var entityNamespacePrefix = $"{module.AssemblyDescriptor.Infrastructure.GetName().Name}.Repositories.{options.Dialect}.";
foreach (var serviceType in interfaceList)
{
var implementType = module.AssemblyDescriptor.Infrastructure.GetTypes().FirstOrDefault(m => m.FullName.NotNull() && m.FullName.StartsWith(entityNamespacePrefix) && serviceType.IsAssignableFrom(m));
if (implementType != null)
{
services.AddSingleton(serviceType, sp =>
{
var dbContext = sp.GetServices <IDbContext>().FirstOrDefault(m => m.Options.Name.Equals(options.Name));
return(Activator.CreateInstance(implementType, dbContext));
});
}
}
}
public async Task OnMagicCombinationPressed()
{
//fetch currently selected text, set up search context
string selectedTxt = _textFetcher.FetchSelectedText();
if (String.IsNullOrEmpty(selectedTxt))
{
//nothing to search
return;
}
if (_globalCtx.InitSearchContext(selectedTxt))
{
var searchCtx = _globalCtx.CurrentSearch;
IModuleDescriptor currentModule = _globalCtx.CurrentModule;
//asynchronously run the searching process using currently selected module
Task <object> adapterResponseTask = currentModule.DataAdapter.GetAsync(searchCtx);
//meanwhile, update the UI: ask user to wait for search results
WaitForReplyVm waitVm = currentModule.VmFactory.CreateWaitForReply(searchCtx);
_globalCtx.CurrentVm = waitVm;
//wait for the task to finish, get its result
searchCtx.Response = await adapterResponseTask;
//update the UI accordingly: show the result to user
SearchFinishedVm finishedVm = currentModule.VmFactory.CreateSearchFinished(searchCtx);
_globalCtx.CurrentVm = finishedVm;
}
}
/// <summary>
/// 添加仓储
/// </summary>
private static void AddRepositories(this IServiceCollection services, IModuleDescriptor module, IDbContext dbContext, IQueryFilter filter)
{
var interfaceList = module.AssemblyDescriptor.Domain.GetTypes().Where(t => t.FullName != null && t.IsInterface && t.FullName.EndsWith("Repository", StringComparison.OrdinalIgnoreCase)).ToList();
if (!interfaceList.Any())
{
return;
}
foreach (var repositoryType in interfaceList)
{
var implementType = module.AssemblyDescriptor.Infrastructure.GetTypes().FirstOrDefault(m => m.FullName != null && m.IsClass && m.FullName.EndsWith("Repository", StringComparison.OrdinalIgnoreCase) && repositoryType.IsAssignableFrom(m));
if (implementType == null)
{
continue;
}
if (filter != null)
{
services.AddSingleton(repositoryType, Activator.CreateInstance(implementType, dbContext, filter));
}
else
{
services.AddSingleton(repositoryType, Activator.CreateInstance(implementType, dbContext));
}
}
}
private void LoadDictNameSyncDescriptors(IServiceCollection services, IModuleDescriptor moduleDescriptor)
{
var collection = new DictSyncDescriptorCollection();
//因为EntityDescriptorCollection未提供获取所有实体描述符的方法，所以暂时只能通过模块查询
var entityDescriptors = EntityDescriptorCollection.Get(moduleDescriptor.Code);
foreach (var entityDescriptor in entityDescriptors)
{
foreach (var column in entityDescriptor.Columns)
{
var attr = (DictSyncAttribute)Attribute.GetCustomAttribute(column.PropertyInfo, typeof(DictSyncAttribute));
if (attr != null)
{
collection.Add(new DictSyncDescriptor
{
GroupCode = attr.GroupCode,
DictCode = attr.DictCode,
DictNameColName = attr.DictNameColName,
EntityDescriptor = entityDescriptor,
ColumnDescriptor = column
});
}
}
}
services.AddSingleton(collection);
}
internal static StringBuilder InternalToMermaidString(this IModuleDescriptor descriptor, HashSet <IModuleDescriptor> processed, Func <Type, string> getTypeDisplayNameFunc)
{
if (processed.Contains(descriptor) ||
descriptor.Dependencies.IsNullOrEmpty())
{
return(EmptyStringBuilder);
}
var builder = new StringBuilder();
var typeName = getTypeDisplayNameFunc(descriptor.Type);
foreach (var dependency in descriptor.Dependencies)
{
var dependenceTypeName = getTypeDisplayNameFunc(dependency.Type);
builder.AppendLine($"{typeName}[\"{typeName}\"] --> {dependenceTypeName}[\"{dependenceTypeName}\"]");
processed.Add(dependency);
builder.Append(dependency.InternalToMermaidString(processed, getTypeDisplayNameFunc));
}
return(builder);
}
private string _GetModuleAuthor(IModuleDescriptor descriptor)
{
try {
return(descriptor.Author);
} catch {
return(NOT_PROVIDED);
}
}
static public void ReloadModule(Guid moduleTypeId)
{
IModuleDescriptor descriptor = Modules.GetDescriptorById(moduleTypeId);
string moduleFilePath = descriptor.Assembly.Location;
Modules.UnloadModule(descriptor);
Modules.LoadModule(moduleFilePath, new[] { moduleTypeId });
}
private string _GetModuleAuthor(IModuleDescriptor descriptor)
{
try {
return descriptor.Author;
} catch {
return NOT_PROVIDED;
}
}
static void VisitDependencyNode(IModuleDescriptor descriptor, List <KeyValuePair <string, string[]> > orderList)
{
orderList.Add(new KeyValuePair <string, string[]>(descriptor.Type.Name, descriptor.Dependencies.Select(m => m.Type.Name).ToArray()));
foreach (var item in descriptor.Dependencies)
{
VisitDependencyNode(item, orderList);
}
}
private string _GetModuleVersion(IModuleDescriptor descriptor)
{
try {
return descriptor.Version;
} catch {
return NOT_PROVIDED;
}
}
private string _GetModuleVersion(IModuleDescriptor descriptor)
{
try {
return(descriptor.Version);
} catch {
return(NOT_PROVIDED);
}
}
public IModuleDataModel ReadObject(XElement element)
{
try {
string dataModelTypeString = XmlHelper.GetAttribute(element, ATTR_DATA_MODEL_TYPE);
if (dataModelTypeString == null)
{
return(null);
}
Type dataModelType = Type.GetType(dataModelTypeString);
if (dataModelType == null)
{
return(null);
}
Guid?moduleTypeId = XmlHelper.GetGuidAttribute(element, ATTR_MODULE_TYPE);
if (moduleTypeId == null)
{
return(null);
}
Guid?moduleInstanceId = XmlHelper.GetGuidAttribute(element, ATTR_MODULE_INSTANCE);
if (moduleInstanceId == null)
{
return(null);
}
// Get the descriptor for the type.
IModuleDescriptor descriptor = Modules.GetDescriptorById(moduleTypeId.Value);
if (descriptor == null)
{
Logging.Error("Could not get module data for module type " + moduleTypeId.Value +
" because the module type does not exist.");
return(null);
}
IModuleDataModel dataModel;
try {
dataModel = _DeserializeDataModel(dataModelType, element);
}
catch (Exception ex) {
Logging.ErrorException("The data for module \"" + descriptor.TypeName + "\" was not loaded due to errors.", ex);
return(null);
}
if (dataModel != null)
{
dataModel.ModuleTypeId = moduleTypeId.Value;
dataModel.ModuleInstanceId = moduleInstanceId.Value;
}
return(dataModel);
} catch (Exception e) {
logging.ErrorException("Error loading Module Data Model from XML", e);
return(null);
}
}
static public void UnloadModule(Guid moduleTypeId)
{
IModuleDescriptor descriptor = Modules.GetDescriptorById(moduleTypeId);
if (descriptor != null)
{
Modules.UnloadModule(descriptor);
}
}
public ITiming GetTimingSource(ISequence sequence, string sourceName)
{
IModuleDescriptor moduleDescriptor = Modules.GetDescriptors <ITimingModuleInstance>().FirstOrDefault(x => x.TypeName == sourceName);
if (moduleDescriptor != null)
{
return(Modules.ModuleManagement.GetTiming(moduleDescriptor.TypeId));
}
return(null);
}
/// <summary>
/// 自动注入单例服务
/// </summary>
/// <param name="services"></param>
/// <param name="module"></param>
private static void AddSingleton(this IServiceCollection services, IModuleDescriptor module)
{
if (module.AssemblyDescriptor != null && module.AssemblyDescriptor is ModuleAssemblyDescriptor descriptor)
{
services.AddSingletonFromAssembly(descriptor.Domain);
services.AddSingletonFromAssembly(descriptor.Infrastructure);
services.AddSingletonFromAssembly(descriptor.Application);
services.AddSingletonFromAssembly(descriptor.Web);
}
}
/// <summary>
/// 自动注入单例服务
/// </summary>
/// <param name="services"></param>
/// <param name="module"></param>
private static void AddSingleton(this IServiceCollection services, IModuleDescriptor module)
{
if (module.AssemblyDescriptor == null)
{
return;
}
services.AddSingletonFromAssembly(module.AssemblyDescriptor.Domain);
services.AddSingletonFromAssembly(module.AssemblyDescriptor.Infrastructure);
services.AddSingletonFromAssembly(module.AssemblyDescriptor.Application);
}
/// <summary>
/// 获取最大深度
/// </summary>
/// <param name="moduleDescriptor"></param>
/// <returns></returns>
private static int GetMaxDependencyDepth(IModuleDescriptor moduleDescriptor)
{
if (moduleDescriptor.Dependencies.Count == 0)
{
return(1);
}
else
{
return(1 + moduleDescriptor.Dependencies.Max(GetMaxDependencyDepth));
}
}
static public void UnloadModule(IModuleDescriptor descriptor)
{
//*** what about the dependencies upon this module?
//-> And if there are lists that reference a dependency, they won't know that
// it's been unloaded
_activators.Remove(descriptor.TypeId);
_moduleDescriptors.Remove(descriptor.TypeId);
// We don't know the ModuleImplementation that the descriptor belongs to.
foreach (HashSet <IModuleDescriptor> moduleImplementationDescriptors in _moduleImplementationDescriptors.Values)
{
moduleImplementationDescriptors.Remove(descriptor);
}
}
public bool AddNewControllerOfTypeWithPrompts(Guid controllerTypeId)
{
IModuleDescriptor moduleDescriptor = ApplicationServices.GetModuleDescriptor(controllerTypeId);
if (moduleDescriptor == null)
{
Logging.Error("couldn't get descriptor for controller of type ID: " + controllerTypeId);
return(false);
}
string defaultName = moduleDescriptor.TypeName;
string name;
using (TextDialog textDialog = new TextDialog("New Controller Name?", "Controller Name", defaultName, true)) {
if (textDialog.ShowDialog() != DialogResult.OK)
{
return(false);
}
name = textDialog.Response;
if (name.Length <= 0)
{
name = defaultName;
}
}
int outputCount;
using (NumberDialog nd = new NumberDialog("Controller Output Count", "Outputs on this controller?", 0)) {
if (nd.ShowDialog() != DialogResult.OK)
{
return(false);
}
outputCount = nd.Value;
}
ControllerFactory controllerFactory = new ControllerFactory();
OutputController oc = (OutputController)controllerFactory.CreateDevice(controllerTypeId, name);
oc.OutputCount = outputCount;
VixenSystem.OutputControllers.Add(oc);
//PopulateControllerTree(oc);
AddControllerToTree(oc);
OnControllersChanged();
return(true);
}
private void toolStripItemAddInputModule_Click(object sender, EventArgs e)
{
try {
ToolStripItem toolStripItem = sender as ToolStripItem;
IModuleDescriptor descriptor = toolStripItem.Tag as IModuleDescriptor;
IInputModuleInstance inputModule = ApplicationServices.Get <IInputModuleInstance>(descriptor.TypeId);
_inputModules.Add(inputModule);
_RefreshInputModuleList();
_SetupInputDevice(inputModule);
} catch (Exception ex) {
MessageBox.Show(ex.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
}
/// <summary>
/// 注入实体观察者
/// </summary>
/// <param name="services"></param>
/// <param name="module"></param>
private static void AddEntityObserver(this IServiceCollection services, IModuleDescriptor module)
{
var observers = module.AssemblyDescriptor.Application.GetTypes().Where(t => typeof(IEntityObserver <>).IsImplementType(t)).ToList();
observers.AddRange(module.AssemblyDescriptor.Infrastructure.GetTypes().Where(t => typeof(IEntityObserver <>).IsImplementType(t)).ToList());
observers.AddRange(module.AssemblyDescriptor.Domain.GetTypes().Where(t => typeof(IEntityObserver <>).IsImplementType(t)).ToList());
observers.ForEach(m =>
{
var interfaceType = m.GetInterfaces().FirstOrDefault();
if (interfaceType != null)
{
services.AddSingleton(interfaceType, m);
}
});
services.AddSingleton <IEntityObserverHandler, EntityObserverHandler>();
}
/// <summary>
/// 检查节点
/// </summary>
/// <param name="moduleDescriptor"></param>
private static void DependencyNodeCheck(IModuleDescriptor moduleDescriptor)
{
if (moduleDescriptor.Dependencies.Count > 0)
{
var dependencies = DefaultModuleDescriptorBuilder.Default.GetDependedModuleTypes(moduleDescriptor.Type);
Assert.AreEqual(dependencies.Count(), moduleDescriptor.Dependencies.Count);
foreach (var item in dependencies)
{
Assert.IsTrue(moduleDescriptor.Dependencies.Select(md => md.Type).Contains(item));
}
foreach (var dependency in moduleDescriptor.Dependencies)
{
Assert.IsTrue(dependency.Dependents.Contains(moduleDescriptor));
DependencyNodeCheck(dependency);
}
}
}
/*
* from http://www.electricmonk.nl/docs/dependency_resolving_algorithm/dependency_resolving_algorithm.html
* def dep_resolve(node, resolved, unresolved):
* unresolved.append(node)
* for edge in node.edges:
* if edge not in resolved:
* if edge in unresolved:
* raise Exception('Circular reference detected: %s -> %s' % (node.name, edge.name))
* dep_resolve(edge, resolved, unresolved)
* resolved.append(node)
* unresolved.remove(node)
*/
static void ResolveDependencies(IModuleDescriptor node, Collection <FileModuleDescriptor> resolved, Collection <FileModuleDescriptor> unresolved)
{
if (node is FileModuleDescriptor)
{
unresolved.Add((FileModuleDescriptor)node);
}
foreach (var edge in node.Dependencies)
{
if (!resolved.Any(Compare(edge)))
{
if (unresolved.Any(Compare(edge)))
{
throw new ArgumentException("circulat dependency: " + edge.FileInfo.FullName);
}
ResolveDependencies(edge, resolved, unresolved);
}
}
if (node is FileModuleDescriptor)
{
resolved.Add((FileModuleDescriptor)node);
unresolved.Remove((FileModuleDescriptor)node);
}
}
/// <summary>
/// 获取分组
/// </summary>
/// <param name="descriptor"></param>
/// <returns></returns>
public static Dictionary <string, string> GetGroups(this IModuleDescriptor descriptor)
{
var groups = new Dictionary <string, string> {
{ descriptor.Code, descriptor.Name }
};
var assemblies = (ModuleAssemblyDescriptor)descriptor.AssemblyDescriptor;
var controllers = (assemblies.Web ?? assemblies.Api).GetTypes().Where(m => m.Name.EndsWith("Controller"));
foreach (var controller in controllers)
{
var arr = controller.FullName.Split('.');
if (arr.Length == 7)
{
var dic = arr[5];
if (dic != "Controllers" && !groups.ContainsKey(dic))
{
groups.Add(descriptor.Code + "_" + dic, descriptor.Name + "_" + dic);
}
}
}
return(groups);
}
public void ModuleUnloading(IModuleDescriptor descriptor)
{
}
/// <summary>
/// 注入配置对象
/// </summary>
private static ModuleOptionsDescriptor GetDescriptor(IServiceCollection services, IModuleDescriptor module)
{
var descriptor = new ModuleOptionsDescriptor
{
Module = module
};
//一个模块中只能有一个配置项，且必须按照“模块名称+Options”的命名方式
var optionsType = module.AssemblyDescriptor.Infrastructure.GetTypes()
.FirstOrDefault(m => typeof(IModuleOptions).IsAssignableFrom(m) && m.Name.EqualsIgnoreCase($"{module.Id}Options"));
if (optionsType != null)
{
descriptor.OptionsType = optionsType;
var properties = optionsType.GetProperties().Where(m => m.GetCustomAttributes(false).Any(n => n.GetType() == typeof(ModuleOptionDefinitionAttribute)));
foreach (var p in properties)
{
descriptor.Definitions.Add(GetDefinition(optionsType, p));
}
//这里注入是为了能够通过依赖注入获取模块配置实例，这样模块配置就可以使用以来注入来注入任意服务了
//在IModuleOptionsEngine的LoadFromStorage方法中会删除并重新注入
services.AddSingleton(optionsType);
}
return(descriptor);
}
protected abstract Type _GetDataModelType(IModuleDescriptor descriptor);
protected override Type _GetDataModelType(IModuleDescriptor descriptor)
{
return descriptor.ModuleStaticDataClass;
}
protected override Type _GetDataModelType(IModuleDescriptor descriptor)
{
return _GetModuleDataSetType(descriptor);
}
private static Type _GetModuleDataSetType(IModuleDescriptor descriptor)
{
return descriptor.ModuleDataClass;
}
public void ModuleLoaded(IModuleDescriptor descriptor)
{
}
public void ModuleUnloading(IModuleDescriptor descriptor)
{
Modules.ModuleRepository.RemoveFileTemplate(descriptor.TypeId);
}
public void ModuleLoaded(IModuleDescriptor descriptor)
{
Modules.ModuleRepository.AddFileTemplate(descriptor.TypeId);
}
public void ModuleLoaded(IModuleDescriptor descriptor)
{
Modules.ModuleRepository.AddEffect(descriptor.TypeId);
}
public void ModuleLoaded(IModuleDescriptor descriptor)
{
// Add it to the repository.
Modules.ModuleRepository.AddApp(descriptor.TypeId);
}
public void ModuleUnloading(IModuleDescriptor descriptor)
{
Modules.ModuleRepository.RemoveApp(descriptor.TypeId);
}
