public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
var businessClassesList = GetAdditionalClasses(moduleManager);
WCTypesInfo.Instance.Register(businessClassesList);
if (Application == null || GetPath() == null)
return;
Application.SettingUp += ApplicationOnSettingUp;
if (FullConnectionString != null) {
var xpoMultiDataStoreProxy = new SqlMultiDataStoreProxy(FullConnectionString, GetReflectionDictionary());
using (var dataLayer = new SimpleDataLayer(xpoMultiDataStoreProxy)) {
using (var session = new Session(dataLayer)) {
using (var unitOfWork = new UnitOfWork(session.DataLayer)) {
RunUpdaters(session);
AddDynamicModules(moduleManager, unitOfWork);
}
}
}
} else {
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(CompileEngine.XpandExtension));
foreach (var assembly1 in assemblies) {
moduleManager.AddModule(assembly1.GetTypes().Where(type => typeof(ModuleBase).IsAssignableFrom(type)).Single());
}
}
Application.SetupComplete += ApplicationOnSetupComplete;
}
bool ValidateBOModel(IPersistentAssemblyInfo persistentAssemblyInfo, Type compileCore)
{
if (persistentAssemblyInfo.ValidateModelOnCompile)
{
var instance = XafTypesInfo.Instance;
try {
var typesInfo = new TypesInfoBuilder.TypesInfo();
typesInfo.AddEntityStore(new NonPersistentEntityStore(typesInfo));
typesInfo.AddEntityStore(new XpoTypeInfoSource(typesInfo));
typesInfo.AssignAsInstance();
typesInfo.LoadTypes(compileCore.Assembly);
var applicationModulesManager = new ApplicationModulesManager();
applicationModulesManager.AddModule(compileCore);
applicationModulesManager.Load(typesInfo, true);
}
catch (Exception exception) {
persistentAssemblyInfo.CompileErrors = exception.ToString();
return(false);
}
finally {
instance.AssignAsInstance();
}
}
return(true);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
WCTypesInfo.Instance.Register(GetAdditionalClasses(moduleManager));
if (Application == null || GetPath() == null || !RuntimeMode)
{
return;
}
if (!string.IsNullOrEmpty(ConnectionString) || Application.ObjectSpaceProvider is DataServerObjectSpaceProvider)
{
using (var unitOfWork = GetUnitOfWork()) {
RunUpdaters(unitOfWork);
AddDynamicModules(moduleManager, unitOfWork);
if (unitOfWork.DataLayer != null)
{
unitOfWork.DataLayer.Dispose();
}
}
}
else
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(CompileEngine.XpandExtension));
foreach (var assembly1 in assemblies)
{
moduleManager.AddModule(assembly1.GetTypes().Single(type => typeof(ModuleBase).IsAssignableFrom(type)));
}
}
Application.LoggedOn += ApplicationOnLoggedOn;
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
WCTypesInfo.Instance.Register(GetAdditionalClasses(moduleManager));
if (Application == null || GetPath() == null)
{
return;
}
Application.SettingUp += ApplicationOnSettingUp;
if (FullConnectionString != null)
{
var xpoMultiDataStoreProxy = new MultiDataStoreProxy(FullConnectionString, GetReflectionDictionary());
using (var dataLayer = new SimpleDataLayer(xpoMultiDataStoreProxy)) {
using (var session = new Session(dataLayer)) {
using (var unitOfWork = new UnitOfWork(session.DataLayer)) {
RunUpdaters(session);
AddDynamicModules(moduleManager, unitOfWork);
}
}
}
}
else
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(CompileEngine.XpandExtension));
foreach (var assembly1 in assemblies)
{
moduleManager.AddModule(assembly1.GetTypes().Single(type => typeof(ModuleBase).IsAssignableFrom(type)));
}
}
Application.SetupComplete += ApplicationOnSetupComplete;
}
public ApplicationModulesManager CreateApplicationModulesManager(XafApplication application, string configFileName, string assembliesPath, ITypesInfo typesInfo)
{
if (!string.IsNullOrEmpty(configFileName))
{
bool isWebApplicationModel =
String.Compare(Path.GetFileNameWithoutExtension(configFileName), "web", StringComparison.OrdinalIgnoreCase) == 0;
if (string.IsNullOrEmpty(assembliesPath))
{
assembliesPath = Path.GetDirectoryName(configFileName);
if (isWebApplicationModel)
{
assembliesPath = Path.Combine(assembliesPath + "", "Bin");
}
}
}
ReflectionHelper.AddResolvePath(assembliesPath);
try {
var result = new ApplicationModulesManager(new ControllersManager(), assembliesPath);
foreach (ModuleBase module in application.Modules)
{
result.AddModule(module);
}
result.Security = application.Security;
if (GetModulesFromConfig(application) != null)
{
result.AddModuleFromAssemblies(GetModulesFromConfig(application));
}
return(result);
} finally {
ReflectionHelper.RemoveResolvePath(assembliesPath);
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application.GetEasyTestParameter("ColumnChooser"))
{
moduleManager.AddModule(Application, new XpandTreeListEditorsAspNetModule());
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application != null && Application.GetEasyTestParameter(EasyTestParameters.WCModel))
{
moduleManager.AddModule(Application, new WorldCreatorWinModule());
}
}
private void TypesInfoValidation(string assemblyFile, TypesInfo typesInfo)
{
var applicationModulesManager = new ApplicationModulesManager();
var types = Assembly.LoadFile(assemblyFile).GetTypes();
applicationModulesManager.AddModule(types.First(type => typeof(ModuleBase).IsAssignableFrom(type)));
applicationModulesManager.Load(typesInfo);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application != null && Application.GetEasyTestParameter("WorldCreator"))
{
moduleManager.AddModule(Application, (ModuleBase)Activator.CreateInstance(typeof(WorldCreatorWinModule)));
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application != null && Application.GetEasyTestParameter("NorthWind"))
{
moduleManager.AddModule(new WorldCreatorWebModule());
}
}
public void AddDynamicModules(ApplicationModulesManager moduleManager, UnitOfWork unitOfWork){
Type assemblyInfoType = TypesInfo.Instance.PersistentAssemblyInfoType;
List<IPersistentAssemblyInfo> persistentAssemblyInfos =
new XPCollection(unitOfWork, assemblyInfoType).Cast<IPersistentAssemblyInfo>().Where(info => !info.DoNotCompile &&
moduleManager.Modules.Where(@base => @base.Name == "Dynamic" + info.Name + "Module").FirstOrDefault() ==null).ToList();
_definedModules = new CompileEngine().CompileModules(persistentAssemblyInfos,GetPath());
foreach (var definedModule in _definedModules){
moduleManager.AddModule(definedModule);
}
unitOfWork.CommitChanges();
}
void AddPersistentModules(ApplicationModulesManager applicationModulesManager)
{
WorldCreatorApplication.CheckCompatibility(Application, GetWorldCreatorApplication);
if (!string.IsNullOrEmpty(ConnectionString) || Application.ObjectSpaceProviders.OfType <DataServerObjectSpaceProvider>().Any())
{
lock (_locker){
var worldCreatorObjectSpaceProvider = WorldCreatorObjectSpaceProvider.Create(Application, false);
using (var objectSpace = worldCreatorObjectSpaceProvider.CreateObjectSpace()){
var codeValidator =
new CodeValidator(new Compiler(AssemblyPathProvider.Instance.GetPath(Application)),
new AssemblyValidator());
var assemblyManager = new AssemblyManager(objectSpace, codeValidator);
foreach (var assembly in assemblyManager.LoadAssemblies())
{
var moduleType = assembly.GetTypes()
.First(type => typeof(ModuleBase).IsAssignableFrom(type));
applicationModulesManager.AddModule(Application, (ModuleBase)moduleType.CreateInstance());
}
worldCreatorObjectSpaceProvider.MakeThreadSafe();
}
worldCreatorObjectSpaceProvider.SchemaUpdateMode = SchemaUpdateMode.None;
}
}
else
{
var assemblies =
AppDomain.CurrentDomain.GetAssemblies()
.Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(Compiler.XpandExtension));
foreach (var assembly1 in assemblies)
{
applicationModulesManager.AddModule(assembly1.GetTypes()
.First(type => typeof(ModuleBase).IsAssignableFrom(type)));
}
}
XpoObjectMerger.MergeTypes(this);
}
void AddDynamicModules(ApplicationModulesManager moduleManager, UnitOfWork unitOfWork)
{
unitOfWork.LockingOption = LockingOption.None;
Type assemblyInfoType = WCTypesInfo.Instance.FindBussinessObjectType <IPersistentAssemblyInfo>();
List <IPersistentAssemblyInfo> persistentAssemblyInfos =
new XPCollection(unitOfWork, assemblyInfoType).OfType <IPersistentAssemblyInfo>().Where(IsValidAssemblyInfo(moduleManager)).ToList();
_dynamicModuleTypes = new CompileEngine().CompileModules(persistentAssemblyInfos, GetPath());
foreach (var definedModule in _dynamicModuleTypes)
{
moduleManager.AddModule(definedModule);
}
unitOfWork.CommitChanges();
}
private static void AddModule(ApplicationModulesManager applicationModulesManager, XafApplication application,
ModuleBase[] moduleBases, HashSet <string> installedModules)
{
foreach (var moduleBase in moduleBases)
{
if (!installedModules.Contains(moduleBase.Name))
{
installedModules.Add(moduleBase.Name);
var requiredModuleTypes = moduleBase.RequiredModuleTypes.Select(type => type.CreateInstance()).Cast <ModuleBase>().ToArray();
AddModule(applicationModulesManager, application, requiredModuleTypes, installedModules);
applicationModulesManager.AddModule(moduleBase);
moduleBase.Application = application;
LoadRegularTypesToTypesInfo(XafTypesInfo.Instance, moduleBase);
applicationModulesManager.ControllersManager.RegisterControllerTypes(moduleBase.GetControllerTypes().ToArray());
}
}
}
ApplicationModulesManager CreateModulesManager(XafApplication application, string configFileName, string assembliesPath, ITypesInfo typesInfo)
{
if (!string.IsNullOrEmpty(configFileName))
{
bool isWebApplicationModel = String.Compare(Path.GetFileNameWithoutExtension(configFileName), "web", StringComparison.OrdinalIgnoreCase) == 0;
if (string.IsNullOrEmpty(assembliesPath))
{
assembliesPath = Path.GetDirectoryName(configFileName);
if (isWebApplicationModel)
{
assembliesPath = Path.Combine(assembliesPath + "", "Bin");
}
}
}
ReflectionHelper.AddResolvePath(assembliesPath);
try {
var result = new ApplicationModulesManager(new ControllersManager(), assembliesPath);
if (application != null)
{
foreach (ModuleBase module in application.Modules)
{
result.AddModule(module);
}
result.Security = application.Security;
}
if (!string.IsNullOrEmpty(configFileName))
{
result.AddModuleFromAssemblies(GetModulesFromConfig(application));
}
var info = typesInfo as TypesInfoBuilder.TypesInfo;
if (info != null)
{
XpandModuleBase.Dictiorary = (info).Source.XPDictionary;
}
XpandModuleBase.TypesInfo = typesInfo;
result.Load(typesInfo, typesInfo != XafTypesInfo.Instance);
return(result);
} finally {
XpandModuleBase.Dictiorary = XpoTypesInfoHelper.GetXpoTypeInfoSource().XPDictionary;
XpandModuleBase.TypesInfo = XafTypesInfo.Instance;
ReflectionHelper.RemoveResolvePath(assembliesPath);
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
WCTypesInfo.Instance.Register(GetAdditionalClasses(moduleManager));
if (Application == null || GetPath() == null||!RuntimeMode)
return;
if (!string.IsNullOrEmpty(ConnectionString) || Application.ObjectSpaceProvider is DataServerObjectSpaceProvider) {
using (var unitOfWork = GetUnitOfWork()) {
RunUpdaters(unitOfWork);
AddDynamicModules(moduleManager, unitOfWork);
if (unitOfWork.DataLayer != null) unitOfWork.DataLayer.Dispose();
}
} else {
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(CompileEngine.XpandExtension));
foreach (var assembly1 in assemblies) {
moduleManager.AddModule(assembly1.GetTypes().Single(type => typeof(ModuleBase).IsAssignableFrom(type)));
}
}
Application.LoggedOn+=ApplicationOnLoggedOn;
}
bool ValidateBOModel(IPersistentAssemblyInfo persistentAssemblyInfo, Type compileCore) {
if (persistentAssemblyInfo.ValidateModelOnCompile) {
var instance = XafTypesInfo.Instance;
try{
var typesInfo = new TypesInfoBuilder.TypesInfo();
typesInfo.AddEntityStore(new NonPersistentEntityStore(typesInfo));
typesInfo.AddEntityStore(new XpoTypeInfoSource(typesInfo));
typesInfo.AssignAsInstance();
typesInfo.LoadTypes(compileCore.Assembly);
var applicationModulesManager = new ApplicationModulesManager();
applicationModulesManager.AddModule(compileCore);
applicationModulesManager.Load(typesInfo, true);
}
catch (Exception exception){
persistentAssemblyInfo.CompileErrors = exception.ToString();
return false;
}
finally{
instance.AssignAsInstance();
}
}
return true;
}
void AddDynamicModules(ApplicationModulesManager moduleManager, UnitOfWork unitOfWork) {
unitOfWork.LockingOption = LockingOption.None;
Type assemblyInfoType = WCTypesInfo.Instance.FindBussinessObjectType<IPersistentAssemblyInfo>();
List<IPersistentAssemblyInfo> persistentAssemblyInfos =
new XPCollection(unitOfWork, assemblyInfoType).OfType<IPersistentAssemblyInfo>().Where(IsValidAssemblyInfo(moduleManager)).ToList();
_dynamicModuleTypes = new CompileEngine().CompileModules(persistentAssemblyInfos, GetPath());
foreach (var definedModule in _dynamicModuleTypes) {
moduleManager.AddModule(definedModule);
var module = moduleManager.Modules.FindModule(definedModule);
moduleManager.ControllersManager.RegisterControllerTypes(module.GetControllerTypes().ToArray());
}
unitOfWork.CommitChanges();
}
