internal static IObservable <Unit> MarkupContentPropertyEditor(this ApplicationModulesManager manager)
=> manager.WhenGeneratingModelNodes <IModelBOModel>().SelectMany().Cast <IModelClass>()
.SelectMany(modelClass => modelClass.OwnMembers.ToObservable())
.UrlPropertyAttribute().ImgPropertyAttribute()
.ToUnit()
.Merge(manager.WhenGeneratingModelNodes <IModelViews>().SelectMany()
.ReaOnlyViewAttribute());
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 static void AddModelReferences(this ApplicationModulesManager _, params string[] references)
{
foreach (var reference in references)
{
References.Add(reference);
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
Application.Connect()
.TakeUntilDisposed(this)
.Subscribe(unit => { }, () => { });
}
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);
if (Application != null) {
Application.UserDifferencesLoaded += OnUserDifferencesLoaded;
Application.CreateCustomUserModelDifferenceStore += ApplicationOnCreateCustomUserModelDifferenceStore;
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (RuntimeMode && !_comparerIsLock && typeof(IUser).IsAssignableFrom(Application.Security.UserType)) {
ObjectAccessComparerBase.SetCurrentComparer(new MemberLevelObjectAccessComparer());
_comparerIsLock = true;
}
}
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;
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.Extend(PredefinedMap.LayoutControlGroup);
moduleManager.Extend(PredefinedMap.AdvBandedGridView, configuration => configuration.MapName = AdvBandedGridViewMapName);
moduleManager.Extend(PredefinedMap.BandedGridColumn, configuration => configuration.MapName = BandedGridColumnMapName);
moduleManager.Extend(PredefinedMap.GridView, configuration => configuration.MapName = GridViewMapName);
moduleManager.ExtendMap(PredefinedMap.GridView)
.Subscribe(_ => _.extenders.Add(_.targetInterface, typeof(IModelOptionsGridViewRules)));
moduleManager.Extend(PredefinedMap.GridColumn, configuration => configuration.MapName = GridColumnMapName);
moduleManager.Extend(PredefinedMap.XafLayoutControl);
moduleManager.Extend(PredefinedMap.SplitContainerControl);
moduleManager.Extend(PredefinedMap.LayoutView, configuration => configuration.MapName = LayoutViewMapName);
moduleManager.Extend(PredefinedMap.LayoutViewColumn, configuration => configuration.MapName = LayoutViewColumnMapName);
moduleManager.ExtendMap(PredefinedMap.LayoutView)
.Subscribe(_ => _.extenders.Add(_.targetInterface, typeof(IModelLayoutViewDesign)));
var repositoryItems = EnumsNET.Enums.GetValues <PredefinedMap>().Where(map => map.IsRepositoryItem()).ToArray();
moduleManager.Extend(repositoryItems);
moduleManager.Extend(PredefinedMap.RichEditControl);
moduleManager.ExtendMap(PredefinedMap.RichEditControl)
.Subscribe(_ => _.extenders.Add(_.targetInterface, typeof(IModelRichEditEx)));
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (RuntimeMode) {
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.ImportExport");
Core.TypesInfo.Instance.RegisterTypes(GetAdditionalClasses(moduleManager));
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.PivotChart");
try {
if (RuntimeMode)
{
AppDomain.CurrentDomain.AssemblyResolve += DXAssemblyResolve;
Assembly assembly = Assembly.Load("DevExpress.Persistent.BaseImpl" + XafAssemblyInfo.VersionSuffix);
Application.TypesInfo.LoadTypes(assembly);
var info = Application.TypesInfo.FindTypeInfo("DevExpress.Persistent.BaseImpl.Analysis");
if (info == null)
{
throw new FileNotFoundException();
}
Type typeInfo = info.Type;
AdditionalExportedTypes.Add(typeInfo);
}
}
catch (FileNotFoundException) {
throw new FileNotFoundException(
"Please make sure DevExpress.Persistent.BaseImpl is referenced from your application project and has its Copy Local==true");
}
finally {
AppDomain.CurrentDomain.AssemblyResolve -= DXAssemblyResolve;
}
}
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;
}
internal static IObservable <Unit> Connect(this ApplicationModulesManager manager)
=> manager.WhenApplication(application => {
var whenModelReady = application.WhenModelChanged().Skip(1).Publish().RefCount();
return(application.WhenStartupView()
.Merge(application.WhenModelChanged().FirstAsync().RegisterOrganizationNonSecured(application))
.Merge(whenModelReady.MarkupMessage()));
});
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.Connect(Application)
.TakeUntilDisposed(this)
.Subscribe();
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.ConnectMicrosoftService()
.Merge(moduleManager.ConnectMicrosoftTodoService())
.Subscribe(this);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
ValidationRulesRegistrator.RegisterRule(moduleManager,
typeof(PasswordStrengthCodeRule),
typeof(IRuleBaseProperties));
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
Application?.Connect()
.TakeUntil(Application.WhenDisposed())
.Subscribe();
}
public static IObservable <Unit> PushTheToken <TObject>(this ApplicationModulesManager manager, string serviceName, Func <TObject, string> tokenFactory) where TObject : CloudOfficeBaseObject
=> manager.RegisterViewSimpleAction($"Push{serviceName}Token", typeof(User), ViewType.DetailView)
.ActivateInUserDetails().FirstAsync()
.WhenExecute(e => {
#if !NETCOREAPP3_1
using (var objectSpace = e.Action.Application.CreateObjectSpace()) {
var authentication = objectSpace.GetObjectByKey <TObject>(SecuritySystem.CurrentUserId);
var token = tokenFactory(authentication);
var fullPath = Path.GetFullPath($"{AppDomain.CurrentDomain.ApplicationPath()}\\..\\PushToken.ps1");
File.WriteAllText($"{Path.GetDirectoryName(fullPath)}\\{serviceName}Token.txt", token);
var processStartInfo = new ProcessStartInfo("powershell.exe", $@"""{fullPath}"" '{serviceName}' -SkipPushToken")
{
WorkingDirectory = Directory.GetCurrentDirectory()
};
var process = new Process()
{
StartInfo = processStartInfo
};
process.StartWithEvents(createNoWindow: false);
var output = process.WhenOutputDataReceived().Buffer(process.WhenExited).WhenNotEmpty().Do(t => {
Tracing.Tracer.LogSeparator("PushToken");
Tracing.Tracer.LogText(t.Join(Environment.NewLine));
}).Publish();
output.Connect();
process.WaitForExit();
return(output.ToUnit());
}
#else
return(Observable.Empty <Unit>());
#endif
});
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.Extend(PredefinedMap.RichEditControl);
moduleManager.ExtendMap(PredefinedMap.RichEditControl)
.Subscribe(_ => _.extenders.Add(_.targetInterface, typeof(IModelRichEditEx)));
}
public override void Setup(ApplicationModulesManager moduleManager){
base.Setup(moduleManager);
// moduleManager.Extend(Enum.GetValues(typeof(PredefinedMap)).OfType<PredefinedMap>().Where(map =>map!=PredefinedMap.None&& map.Platform()==Platform.Web));
moduleManager.LookupCascade().ToUnit()
.Subscribe(this);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
ValidationRulesRegistrator.RegisterRule(moduleManager,
typeof(ClaveFuerte),
typeof(IRuleBaseProperties));
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
ValidationRulesRegistrator.RegisterRule(moduleManager,
typeof(RequiredField),
typeof(IRequiredFieldProperties));
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
// var directoryName = Path.GetDirectoryName(new Uri(GetType().Assembly.Location + "").LocalPath);
// var xpandDllPath = MainDemoModule.GetXpandDllPath(directoryName);
// this.AddModules(xpandDllPath);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.Connect()
.Merge(moduleManager.SwapPosition())
.Subscribe(this);
}
private static bool SetupModules(ApplicationModulesManager applicationModulesManager)
{
SettingUpSubject.OnNext(applicationModulesManager);
foreach (var module in applicationModulesManager.Modules)
{
try {
module.Setup(applicationModulesManager);
if (module is ReactiveModuleBase reactiveModuleBase)
{
reactiveModuleBase.SetupCompletedSubject.OnNext(reactiveModuleBase);
reactiveModuleBase.SetupCompletedSubject.OnCompleted();
}
}
catch (Exception e) {
throw new InvalidOperationException($"Exception occurs while initializing the '{module.GetType().FullName}' module: {e.Message}", e);
}
}
foreach (var controller in ((ReadOnlyCollection <Controller>)applicationModulesManager.ControllersManager.GetPropertyValue("Controllers")))
{
if (controller is ISupportSetup supportSetupItem)
{
try {
supportSetupItem.Setup(applicationModulesManager);
}
catch (Exception e) {
throw new InvalidOperationException($"Exception occurs while initializing the '{controller.GetType().FullName}' controller: {e.Message}", e);
}
}
}
return(false);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
ReportsModuleV2 reportModule = moduleManager.Modules.FindModule <ReportsModuleV2>();
reportModule.ReportDataType = typeof(DevExpress.Persistent.BaseImpl.EF.ReportDataV2);
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
var additionalViewControlsModule = (AdditionalViewControlsModule)moduleManager.Modules.FindModule(typeof(AdditionalViewControlsModule));
additionalViewControlsModule.RulesCollected += AdditionalViewControlsModuleOnRulesCollected;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application != null) {
Application.LoggedOff += Application_LoggedOff;
Application.Disposed += Application_Disposed;
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
var registrator = new ValidationRulesRegistrator(moduleManager);
registrator.RegisterRule(typeof(RuleRequiredForAtLeast1Property), typeof(IRuleRequiredForAtLeast1PropertyProperties));
registrator.RegisterRule(typeof(RuleFromIPropertyValueValidator), typeof(IRuleFromIPropertyValueValidatorProperties));
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
moduleManager.Connect()
.Subscribe(this);
moduleManager.Extend(PredefinedMap.GridView);
}
internal static IObservable <Unit> Connect(this ApplicationModulesManager manager)
=> manager.WhenApplication(application => {
var positionInListCreated = application.WhenPositionInListCreated();
return(positionInListCreated.SortCollectionSource()
.Merge(positionInListCreated.DisableSorting())
.Merge(application.ReturnObservable().PositionNewObjects()));
});
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
AutoCommitService.Connect()
.TakeUntil(this.WhenDisposed().Select(tuple => tuple))
.Subscribe();
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
ReportsModuleV2 reportModule = moduleManager.Modules.FindModule <ReportsModuleV2>();
reportModule.ReportDataType = typeof(MRS.Module.BusinessObjects.ReportDataV2);
}
public static IObservable <Unit> Connect(this ApplicationModulesManager modulesManager)
{
return(CloneMemberValues
.Tracer(true)
.TakeUntilDisposingMainWindow()
.ToUnit());
}
void AddLayers(ModelApplicationBase modelApplication, ApplicationModulesManager applicationModulesManager, PathInfo pathInfo) {
var resourceModelCollector = new ResourceModelCollector();
var dictionary = resourceModelCollector.Collect(applicationModulesManager.Modules.Select(@base => @base.GetType().Assembly), null);
AddLayersCore(dictionary.Where(pair => !PredicateLastLayer(pair, pathInfo)), modelApplication);
ModelApplicationBase lastLayer = modelApplication.CreatorInstance.CreateModelApplication();
modelApplication.AddLayer(lastLayer);
}
public static void RemoveCall(string name, ApplicationModulesManager applicationModulesManager)
{
if (CallMonitor != null)
{
CallMonitor.Remove(new KeyValuePair <string, ApplicationModulesManager>(name, applicationModulesManager));
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (RuntimeMode){
_authentication = new Authentication();
_authentication.Attach(this);
}
}
internal static IObservable <Unit> Content(this ApplicationModulesManager manager) =>
manager.DocumentStyleManagerDetailView(detailView => {
var contentRichEditServer = detailView.DocumentManagerContentRichEditServer();
return(detailView.SelectActiveStyle(contentRichEditServer)
.Merge(detailView.WhenControlsCreated().SynchronizeStylesWhenContextModified(contentRichEditServer))
.Merge(detailView.SynchronizeEditorPositions(contentRichEditServer)));
});
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (RuntimeMode) {
AddToAdditionalExportedTypes(new[] { "Xpand.Persistent.BaseImpl.SequenceObject" });
SequenceObjectType = AdditionalExportedTypes.Single(type => type.FullName == "Xpand.Persistent.BaseImpl.SequenceObject");
InitializeSequenceGenerator();
}
}
ModelApplicationBase GetModelApplication(ApplicationModulesManager applicationModulesManager, PathInfo pathInfo, FileModelStore fileModelStore) {
var modelApplication = ModelApplicationHelper.CreateModel(XafTypesInfo.Instance, applicationModulesManager.DomainComponents, applicationModulesManager.Modules, applicationModulesManager.ControllersManager, Type.EmptyTypes, fileModelStore.GetAspects(), null, null);
AddLayers(modelApplication, applicationModulesManager, pathInfo);
ModelApplicationBase lastLayer = modelApplication.CreatorInstance.CreateModelApplication();
fileModelStore.Load(lastLayer);
ModelApplicationHelper.AddLayer(modelApplication, lastLayer);
return modelApplication;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
// if (RuntimeMode)
if (Application != null) {
Application.SetupComplete += new EventHandler<EventArgs>(Application_SetupComplete);
Application.CreateCustomCollectionSource += new EventHandler<CreateCustomCollectionSourceEventArgs>(Application_CreateCustomCollectionSource);
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.Where(
mbase => typeof(ModelDifferenceBaseModule).IsAssignableFrom(mbase.GetType())).SingleOrDefault();
if (modelDifferenceBaseModule != null)
modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application != null) {
var winApplication = Application as WinApplication;
if (winApplication != null) winApplication.HandleException();
Application.LoggedOff += Application_LoggedOff;
Application.Disposed += Application_Disposed;
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.FirstOrDefault(mbase => mbase is ModelDifferenceBaseModule);
if (modelDifferenceBaseModule != null)
modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
var exceptionHandlingWinModule =
(ExceptionHandlingWinModule)moduleManager.Modules.FindModule(typeof(ExceptionHandlingWinModule));
if (exceptionHandlingWinModule != null)
exceptionHandlingWinModule.CustomHandleException += ExceptionHandlingWinModuleOnCustomHandleException;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application != null) {
Application.LoggingOn += (sender, args) => {
if (ModelsLoaded.HasValue)
LoadModels(!ModelsLoaded.Value);
ModelsLoaded = true;
};
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application == null)
return;
if (RuntimeMode) {
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.JobScheduler");
Application.LoggedOn += ApplicationOnLoggedOn;
}
}
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();
}
/// <summary>
/// Для модулей
/// </summary>
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
// Убираем My Details(информация о текущем пользователе) из панели меню
DevExpress.ExpressApp.Security.MyDetailsController.CanGenerateMyDetailsNavigationItem = false;
fileAttachmentsModule = moduleManager.Modules.FindModule<FileAttachmentsWindowsFormsModule>();
if (fileAttachmentsModule != null)
fileAttachmentsModule.CustomOpenFileWithDefaultProgram += fileAttachmentsModule_CustomOpenWithDefaultProgram;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(Analysis)), IsExportedType));
AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(SequenceObject)), IsExportedType));
AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(ThresholdSeverity)), IsExportedType));
AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(Customer)), IsExportedType));
var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.SingleOrDefault(mbase => mbase is ModelDifferenceBaseModule);
if (modelDifferenceBaseModule != null)
modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application != null)
Application.LogonFailed += (o, eventArgs) => {
var logonParameters = SecuritySystem.LogonParameters as IXpandLogonParameters;
if (logonParameters != null && logonParameters.RememberMe) {
eventArgs.Handled = true;
logonParameters.RememberMe = false;
((ISupportLogonParameterStore)Application).WriteLastLogonParameters(null, SecuritySystem.LogonParameters);
}
};
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.PivotChart");
try {
var assembly = Assembly.Load("DevExpress.Persistent.BaseImpl" + XafAssemblyInfo.VersionSuffix);
TypesInfo.LoadTypes(assembly);
} catch (FileNotFoundException) {
throw new TypeLoadException("Please make sure DevExpress.Persistent.BaseImpl is referenced from your application project and has its Copy Local==true");
}
var typeInfo = TypesInfo.FindTypeInfo("DevExpress.Persistent.BaseImpl.Analysis").Type;
AdditionalExportedTypes.Add(typeInfo);
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (RuntimeMode) {
Application.SetupComplete += ApplicationOnSetupComplete;
Application.LogonFailed += (o, eventArgs) => {
var logonParameters = SecuritySystem.LogonParameters as IXpandLogonParameters;
if (logonParameters != null && logonParameters.RememberMe) {
logonParameters.RememberMe = false;
ObjectSerializer.WriteObjectPropertyValues(null, logonParameters.Storage, logonParameters);
}
};
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application == null)
return;
TypesInfo.Instance.AddTypes(GetAdditionalClasses());
var unitOfWork = new UnitOfWork { ConnectionString = _connectionString };
unitOfWork.UpdateSchema();
AddDynamicModules(moduleManager, unitOfWork, TypesInfo.Instance.PersistentAssemblyInfoType);
Application.SetupComplete += (sender, args) => mergeTypes(unitOfWork);
var existentTypesMemberCreator = new ExistentTypesMemberCreator();
existentTypesMemberCreator.CreateMembers(unitOfWork, TypesInfo.Instance);
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application==null)
return;
ISchedulerFactory stdSchedulerFactory = new XpandSchedulerFactory(Application);
try {
IScheduler scheduler = stdSchedulerFactory.AllSchedulers.SingleOrDefault();
_scheduler = scheduler ?? stdSchedulerFactory.GetScheduler();
}
catch (Exception e) {
if (!Debugger.IsAttached)
Tracing.Tracer.LogError(e);
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
var validationModule =
(ValidationModule) moduleManager.Modules.FindModule(typeof (ValidationModule));
validationModule.CustomizeRegisteredRuleTypes += (o, eventArgs) => {
CThruEngine.AddAspect(new ExistentMembersEnableValidationAspect());
CThruEngine.StartListening();
};
validationModule.RuleSetInitialized += (sender, args) => {
CThruEngine.StopListeningAndReset();
InternalMockManager.Locked = true;
};
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (Application == null)
return;
if (RuntimeMode)
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.JobScheduler");
ISchedulerFactory stdSchedulerFactory = new XpandSchedulerFactory(Application);
try {
IScheduler scheduler = stdSchedulerFactory.AllSchedulers.SingleOrDefault();
_scheduler = scheduler ?? stdSchedulerFactory.GetScheduler();
} catch (Exception e) {
if (!Debugger.IsAttached)
Tracing.Tracer.LogError(e);
}
}
public override void Setup(ApplicationModulesManager moduleManager)
{
base.Setup(moduleManager);
if (Application == null||GetPath()== null)
return;
TypesInfo.Instance.AddTypes(GetAdditionalClasses());
Application.SettingUp+=ApplicationOnSettingUp;
SimpleDataLayer simpleDataLayer = XpoMultiDataStoreProxy.GetDataLayer(_connectionString, GetReflectionDictionary(), TypesInfo.Instance.PersistentAssemblyInfoType);
var unitOfWork = new UnitOfWork(simpleDataLayer);
AddDynamicModules(moduleManager, unitOfWork);
Application.SetupComplete += (sender, args) => {
mergeTypes(unitOfWork);
Application.ObjectSpaceProvider.CreateUpdatingSession().UpdateSchema();
};
var existentTypesMemberCreator = new ExistentTypesMemberCreator();
existentTypesMemberCreator.CreateMembers(unitOfWork, TypesInfo.Instance);
}
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);
AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.PivotChart");
try {
if (RuntimeMode) {
AppDomain.CurrentDomain.AssemblyResolve += DXAssemblyResolve;
Assembly assembly = Assembly.Load("DevExpress.Persistent.BaseImpl" + XafAssemblyInfo.VersionSuffix);
Application.TypesInfo.LoadTypes(assembly);
var info = Application.TypesInfo.FindTypeInfo("DevExpress.Persistent.BaseImpl.Analysis");
if (info==null)
throw new FileNotFoundException();
Type typeInfo = info.Type;
AdditionalExportedTypes.Add(typeInfo);
}
}
catch (FileNotFoundException) {
throw new FileNotFoundException(
"Please make sure DevExpress.Persistent.BaseImpl is referenced from your application project and has its Copy Local==true");
}
finally {
AppDomain.CurrentDomain.AssemblyResolve-=DXAssemblyResolve;
}
}
public override void Setup(ApplicationModulesManager moduleManager) {
base.Setup(moduleManager);
if (FilterProviderManager.IsRegistered && ProxyEventsSubscribed.HasValue && ProxyEventsSubscribed.Value) {
SubscribeToDataStoreProxyEvents();
}
}
