public static void CreateRuntimeMembers(IModelApplication model)
{
using (var objectSpace = CreateObjectSpace()) {
Tracing.Tracer.LogVerboseSubSeparator("RuntimeMembers Creation started");
var modelMemberOneToManyCollections = new List <IModelMemberOneToManyCollection>();
var xpObjectSpace = objectSpace as XPObjectSpace;
var modelMemberExs = GetMembersEx(model).ToArray();
foreach (var memberEx in modelMemberExs)
{
var customCreateMemberArgs = new CustomCreateMemberArgs(memberEx);
OnCustomCreateMember(customCreateMemberArgs);
if (!customCreateMemberArgs.Handled)
{
var modelMemberOneToManyCollection = memberEx as IModelMemberOneToManyCollection;
if (modelMemberOneToManyCollection == null)
{
CreateXpandCustomMemberInfo(memberEx, xpObjectSpace);
}
else
{
modelMemberOneToManyCollections.Add(modelMemberOneToManyCollection);
}
}
}
RefreshTypes(model.GetTypesInfo(), modelMemberExs.Select(ex => ex.ModelClass.TypeInfo).Distinct());
CreateAssociatedCollectionMembers(modelMemberOneToManyCollections, xpObjectSpace);
RefreshTypes(model.GetTypesInfo(), modelMemberOneToManyCollections.Select(collection => collection.CollectionType.TypeInfo).Distinct());
}
Tracing.Tracer.LogVerboseSubSeparator("RuntimeMembers Creation finished");
}
public static T ReadViewInLayer <T>(this IModelApplication modelApplication, T modelView, string newViewId) where T : IModelView
{
var modelViews = modelApplication.Application.Views ?? modelApplication.AddNode <IModelViews>();
if (modelViews[modelView.Id] != null)
{
throw new NotSupportedException($"{modelView.Id} already exists");
}
IModelView newNode;
switch (modelView)
{
case IModelDetailView _:
newNode = modelViews.AddNode <IModelDetailView>();
break;
case IModelListView _:
newNode = modelViews.AddNode <IModelListView>();
break;
case IModelDashboardView _:
newNode = modelViews.AddNode <IModelDashboardView>();
break;
default:
throw new NotImplementedException();
}
newNode.ReadFromModel(modelView);
newNode.Id = newViewId;
return((T)newNode);
}
public IModelLogicWrapper GetModelLogic(IModelApplication applicationModel)
{
var modelLogicWrapper = GetModelLogicCore(applicationModel);
modelLogicWrapper.RuleType = typeof(TLogicRule);
return(modelLogicWrapper);
}
static void AddRuntimeMembers(IModelApplication model) {
foreach (IModelRuntimeMember modelRuntimeMember in GetCustomFields(model))
try {
Type classType = modelRuntimeMember.ModelClass.TypeInfo.Type;
XPClassInfo typeInfo = _dictionary.GetClassInfo(classType);
lock (typeInfo) {
var xpMemberInfo = typeInfo.FindMember(modelRuntimeMember.Name);
if (xpMemberInfo == null) {
XpandCustomMemberInfo memberInfo = GetMemberInfo(modelRuntimeMember, typeInfo);
AddAttributes(modelRuntimeMember, memberInfo);
XafTypesInfo.Instance.RefreshInfo(classType);
} else {
UpdateMember(modelRuntimeMember, xpMemberInfo);
}
}
} catch (Exception exception) {
throw new Exception(
ExceptionLocalizerTemplate<SystemExceptionResourceLocalizer, ExceptionId>.GetExceptionMessage(
ExceptionId.ErrorOccursWhileAddingTheCustomProperty,
modelRuntimeMember.MemberInfo.MemberType,
((IModelClass)modelRuntimeMember.Parent).Name,
modelRuntimeMember.Name,
exception.Message));
}
}
public static void CreateRuntimeMembers(IModelApplication model) {
using (var objectSpace = CreateObjectSpace()) {
Tracing.Tracer.LogVerboseSubSeparator("RuntimeMembers Creation started");
var modelMemberOneToManyCollections = new List<IModelMemberOneToManyCollection>();
var xpObjectSpace = objectSpace as XPObjectSpace;
var modelMemberExs = GetMembersEx(model);
foreach (var memberEx in modelMemberExs) {
var customCreateMemberArgs = new CustomCreateMemberArgs(memberEx);
OnCustomCreateMember(customCreateMemberArgs);
if (!customCreateMemberArgs.Handled) {
var modelMemberOneToManyCollection = memberEx as IModelMemberOneToManyCollection;
if (modelMemberOneToManyCollection == null) {
CreateXpandCustomMemberInfo(memberEx, xpObjectSpace);
}
else {
modelMemberOneToManyCollections.Add(modelMemberOneToManyCollection);
}
}
}
RefreshTypes(model.GetTypesInfo(), modelMemberExs.Select(ex => ex.ModelClass.TypeInfo).Distinct());
CreateAssociatedCollectionMembers(modelMemberOneToManyCollections, xpObjectSpace);
RefreshTypes(model.GetTypesInfo(), modelMemberOneToManyCollections.Select(collection => collection.CollectionType.TypeInfo).Distinct());
}
Tracing.Tracer.LogVerboseSubSeparator("RuntimeMembers Creation started");
}
static void AddRuntimeMembers(IModelApplication model, XPDictionary dictionary)
{
foreach (IModelRuntimeMember modelRuntimeMember in GetCustomFields(model))
{
try {
Type classType = modelRuntimeMember.ModelClass.TypeInfo.Type;
XPClassInfo typeInfo = dictionary.GetClassInfo(classType);
lock (typeInfo) {
if (typeInfo.FindMember(modelRuntimeMember.Name) == null)
{
XpandCustomMemberInfo memberInfo = GetMemberInfo(modelRuntimeMember, typeInfo);
AddAttributes(modelRuntimeMember, memberInfo);
XafTypesInfo.Instance.RefreshInfo(classType);
}
}
} catch (Exception exception) {
throw new Exception(
ExceptionLocalizerTemplate <SystemExceptionResourceLocalizer, ExceptionId> .GetExceptionMessage(
ExceptionId.ErrorOccursWhileAddingTheCustomProperty,
modelRuntimeMember.MemberInfo.MemberType,
((IModelClass)modelRuntimeMember.Parent).Name,
modelRuntimeMember.Name,
exception.Message));
}
}
}
public virtual void SetUp()
{
Tracing.Close();
Tracing.Initialize("", "0");
CaptionHelper.Setup(null);
if (NeedHardResetTypesInfo)
{
typesInfo = CreateTypesInfo();
typesInfo.LoadTypesForTestFixture(this, assemblyName => IsRequiredAssembly(assemblyName.Name));
}
testContext = CreateTestContext(typesInfo);
modelApplication = (IModelApplication)testContext.GetModelApplicationCreator().CreateModelApplication();
modelApplication.
AddLayer(testContext, "AutoGeneratedLayer").
AddLayer(testContext, "DiffLayer").
SetEditorDescriptors(testContext);
List <IXafResourceLocalizer> localizers = new List <IXafResourceLocalizer>();
AddResourceLocalizers(localizers);
if (localizers.Count > 0)
{
modelApplication.SetLocalizers(localizers);
CaptionHelper.Setup(modelApplication);
}
}
IEnumerable <IModelListView> GetListViewInfoNodeWrappers(IModelApplication application)
{
return(application.Views.OfType <IModelListView>().Where(
view => view.ModelClass.TypeInfo.Type == _extendedReferenceType ||
view.ModelClass.TypeInfo.Type == _extendedCollectionMemberType ||
view.ModelClass.TypeInfo.Type == _extendedCoreTypeMemberType));
}
public void Verify(IModelApplication modelApplication)
{
var modelClassB = modelApplication.BOModel.GetClass(typeof(AMvi));
var viewB = _viewType == ViewType.ListView? modelClassB.DefaultListView.AsObjectView:modelClassB.DefaultDetailView;
viewB.Caption.ShouldBe("Changed");
viewB.AllowDelete.ShouldBe(false);
if (viewB is IModelListView modelListView)
{
modelListView.Columns[nameof(ABaseMvi.Description)].Caption.ShouldBe("New");
modelListView.Columns[nameof(ABaseMvi.Name)].ShouldBeNull();
modelListView.Columns[nameof(ABaseMvi.Oid)].Index.ShouldBe(100);
((IModelViewHiddenActions)modelListView).HiddenActions.Any().ShouldBeTrue();
}
else
{
var modelDetailView = ((IModelDetailView)viewB);
modelDetailView.Layout.GetNodeByPath($"Main/SimpleEditors/{nameof(AMvi)}/{nameof(ABaseMvi.Name)}").ShouldBeNull();
modelDetailView.Layout.GetNodeByPath($"Main/SimpleEditors/{nameof(ABaseMvi)}/{nameof(ABaseMvi.Description)}").ShouldNotBeNull();
modelDetailView.Layout.GetNodeByPath("Main/Oid").ShouldNotBeNull();
modelDetailView.Layout.GetNodeByPath("Main/Tags_Groups").ShouldBeNull();
modelDetailView.Layout.GetNodeByPath("Main/Tabs/FileMvis/FileMvis").ShouldNotBeNull();
modelDetailView.Layout.GetNodeByPath("Main/Tabs/Tags/Tags");
modelDetailView.Layout.GetNode("Main").NodeCount.ShouldBe(3);
}
}
protected override IModelLogicWrapper GetModelLogicCore(IModelApplication applicationModel)
{
var auditTrail = ((IModelApplicationAudiTrail)applicationModel).AudiTrail;
return(new ModelLogicWrapper(auditTrail.Rules, auditTrail.ExecutionContextsGroup,
auditTrail.ViewContextsGroup, auditTrail.FrameTemplateContextsGroup));
}
public static void ApplyModel(this DevExpress.DashboardCommon.Dashboard dashboard, RuleMode ruleMode,
IDashboardDefinition template, IModelApplication model)
{
var dataSources = GetDataSources(dashboard, ruleMode, template, model);
foreach (var adapter in dataSources)
{
if (adapter.ModelDataSource is IModelDashboardDataSourceFilter filter)
{
var criteria = ApplyFilter(filter.Filter, adapter.DataSource.Filter);
adapter.DataSource.Filter = criteria?.ToString();
if (adapter.DataSource is DashboardSqlDataSource dashboardSqlDataSource)
{
foreach (var selectQuery in dashboardSqlDataSource.Queries.OfType <SelectQuery>().Where(query => Regex.IsMatch(query.Name, filter.TableName)))
{
if (filter.TopReturnedRecords > 0)
{
selectQuery.Top = filter.TopReturnedRecords;
}
selectQuery.FilterString = criteria?.ToString();
}
}
}
else if (adapter.ModelDataSource is IModelDashboardDataSourceParameter parameter)
{
parameter.ApplyValue(dashboard.Parameters[parameter.ParameterName]);
}
}
}
protected override IModelLogicWrapper GetModelLogicCore(IModelApplication applicationModel)
{
var additionalViewControls = ((IModelApplicationAdditionalViewControls)applicationModel).AdditionalViewControls;
return(new ModelLogicWrapper(additionalViewControls.Rules, additionalViewControls.ExecutionContextsGroup,
additionalViewControls.ViewContextsGroup,
additionalViewControls.FrameTemplateContextsGroup));
}
protected override IModelLogicWrapper GetModelLogicCore(IModelApplication applicationModel)
{
var modelLogicMasterDetail = ((IModelApplicationMasterDetail)applicationModel).MasterDetail;
return(new ModelLogicWrapper(modelLogicMasterDetail.Rules, modelLogicMasterDetail.ExecutionContextsGroup,
modelLogicMasterDetail.ViewContextsGroup,
modelLogicMasterDetail.FrameTemplateContextsGroup));
}
IEnumerable <IModelListView> GetListViewInfoNodeWrappers(IModelApplication application)
{
return
(application.Views.OfType <IModelListView>().Where(
view => view.ModelClass.TypeInfo.Type == WCTypesInfo.Instance.FindBussinessObjectType <IExtendedReferenceMemberInfo>() ||
view.ModelClass.TypeInfo.Type == WCTypesInfo.Instance.FindBussinessObjectType <IExtendedCollectionMemberInfo>() ||
view.ModelClass.TypeInfo.Type == WCTypesInfo.Instance.FindBussinessObjectType <IExtendedCoreTypeMemberInfo>()));
}
void AddAfterSetupLayer(IModelApplication modelApplication)
{
var modelApplicationBase = ((ModelApplicationBase)modelApplication);
ModelApplicationBase afterSetup = modelApplicationBase.CreatorInstance.CreateModelApplication();
afterSetup.Id = "After Setup";
modelApplicationBase.AddLayer(afterSetup);
}
public TestApplication(IXpoDataStoreProvider dsProvider, IModelApplication modelApplication)
: this()
{
objectSpaceProvider = new XPObjectSpaceProvider(dsProvider, true);
Setup(new ExpressApplicationSetupParameters("test app",
objectSpaceProvider,
new ControllersManager(), Modules));
SetModelApplication(modelApplication);
}
protected override Controller CreateController(Controller sourceController, IModelApplication modelApplication)
{
var controller = base.CreateController(sourceController, modelApplication);
// if (typeof(WindowTemplateController).IsAssignableFrom(controller.GetType()))
// Debug.WriteLine("");
ControllersSubject.OnNext(controller);
return(controller);
}
public static void ConfigureMicrosoft(this IModelApplication application)
{
var json = JsonConvert.DeserializeObject <dynamic>(
File.ReadAllText($"{AppDomain.CurrentDomain.ApplicationPath()}\\MicrosoftAppCredentials.json"));
IModelOAuthRedirectUri modelOAuth = application.ToReactiveModule <IModelReactiveModuleOffice>().Office.Microsoft().OAuth;
modelOAuth.ClientId = json.MSClientId;
modelOAuth.RedirectUri = json.RedirectUri;
modelOAuth.ClientSecret = json.MSClientSecret;
}
ILogicInstaller this[Type ruleType, IModelApplication application] {
get {
if (!_logicInstallerTypes.ContainsKey(ruleType))
{
_logicInstallerTypes[ruleType] = _logicInstallers.First(installer =>
ruleType == installer.GetModelLogic(application).RuleType);
}
return(_logicInstallerTypes[ruleType]);
}
}
ILogicInstaller this[Type ruleType,IModelApplication application ] {
get {
if (!_logicInstallerTypes.ContainsKey(ruleType)) {
_logicInstallerTypes[ruleType] = _logicInstallers.First(installer =>
ruleType == installer.GetModelLogic(application).RuleType);
}
return _logicInstallerTypes[ruleType];
}
}
public static void EnableShowStyleManager(this IModelApplication application)
{
var modelDocumentStyleManager = application.DocumentStyleManager();
var modelDesignTemplateDetailView = modelDocumentStyleManager.DesignTemplateDetailViews.AddNode <IModelDesignTemplateDetailView>();
modelDesignTemplateDetailView.DetailView = application.BOModel.GetClass(typeof(DataObject)).DefaultDetailView;
var modelDesignTemplateContentEditor = modelDesignTemplateDetailView.ContentEditors.AddNode <IModelDesignTemplateContentEditor>();
modelDesignTemplateContentEditor.ContentEditor = modelDesignTemplateContentEditor.ContentEditors.First();
}
void RemoveUnrelatedNodes(ModelMergedDifferenceInfo mergedDifference, IModelApplication application)
{
var mergedDifferenceViewId = mergedDifference.MergedViewId;
var strategy = mergedDifference.ModelMergedDifference.Strategy;
var modelObjectView = application.Views[mergedDifferenceViewId].AsObjectView;
RemoveUnrelatedNodesExceptViews(application);
RemoveUnrelatedViewExceptDifferenceView(mergedDifferenceViewId, application.Views);
RemoveStrategyUnrelatedNodes(modelObjectView, strategy);
ClearViewAttributes(strategy, modelObjectView);
}
void RemoveUnrelatedNodesExceptViews(IModelApplication application)
{
for (int i = application.NodeCount - 1; i >= 0; i--)
{
var modelNode = application.GetNode(i);
if (((ModelNode)modelNode).Id != "Views")
{
modelNode.Remove();
}
}
}
private IEnumerable <ITypeInfo> GetInstalledAdapters(ITypeInfo[] typeInfos, IModelApplication application)
{
var modules = ((IModelSources)application).Modules.ToArray();
var moduleAssemblies = modules.Select(@base => @base.GetType().Assembly);
var installedInfos = typeInfos.Where(info => moduleAssemblies.Contains(info.Type.Assembly));
var infos = typeInfos.Where(info => info.FindAttribute <ModuleUserAttribute>() != null)
.Select(source => new{ source, moduleUserAttribute = source.FindAttribute <ModuleUserAttribute>() })
.Where(t => modules.Any(@base => t.moduleUserAttribute.ModuleType.IsInstanceOfType(@base)))
.Select(t => t.source);
return(installedInfos.Concat(infos).Distinct());
}
public static IModelDashboardView NewMasterDetailModelDashboardView(this IModelApplication modelApplication, Type objectType)
{
var modelDashboardView = modelApplication.Views.AddNode <IModelDashboardView>();
var modelClass = modelApplication.BOModel.GetClass(objectType);
var modelListViewItem = modelDashboardView.Items.AddNode <IModelDashboardViewItem>();
modelListViewItem.View = modelClass.DefaultListView;
var modelDetailViewItem = modelDashboardView.Items.AddNode <IModelDashboardViewItem>();
modelDetailViewItem.View = modelClass.DefaultDetailView;
return(modelDashboardView);
}
public static bool GetIsHosted(IModelApplication application)
{
var modelSources = application as IModelSources;
if (modelSources == null)
{
return(Assembly.GetEntryAssembly() == null);
}
var moduleBases = modelSources.Modules;
return(GetIsHosted(moduleBases));
}
public void UpdateNode(IModelViews node, IModelApplication application)
{
foreach (var item in ViewsManager.ViewObjects)
{
var view = node.GetNode(item.GetType().Name) as IModelListView;
if (view == null)
{
throw new UserFriendlyException("没有找到视图：" + item.GetType().Name);
}
item.UpdateNode(view);
}
}
public XpandDataSourceStorage(IModelApplication application)
{
Dictionary <Type, string> typesCaptions = application.BOModel.ToDictionary(modelClass => modelClass.TypeInfo.Type, modelClass => modelClass.Caption);
foreach (Type dashboardType in typesCaptions.Keys)
{
DashboardObjectDataSource dataSource = new DashboardObjectDataSource {
DataSource = dashboardType
};
string name = typesCaptions[dashboardType];
dataSource.Name = name;
_dataSources.Add($"{dashboardType.FullName}", new XDocument(dataSource.SaveToXml()));
}
}
public static ModelApplicationBase StrategiesModel(this IModelApplication application, IEnumerable <ModelApplicationBase> modelApplicationBases)
{
if (_strategiesModel == null)
{
var strategies = ((IModelOptionsMergedDifferenceStrategy)application.Application.Options).MergedDifferenceStrategies;
var xml = string.Format("<Application><Options>{0}</Options></Application>", ((ModelNode)strategies).Xml);
var modelApplicationBase = ((ModelApplicationBase)application).CreatorInstance.CreateModelApplication();
new ModelXmlReader().ReadFromString(modelApplicationBase, "", xml);
ReadFromOtherLayers(modelApplicationBases, strategies, modelApplicationBase);
UpdateRemovedNodes(modelApplicationBase);
_strategiesModel = modelApplicationBase;
}
return(_strategiesModel);
}
public ModelToken(IModelApplication application, string filePathImage, string filePathJson)
{
_application = application;
_filePathImage = filePathImage;
_filePathJson = filePathJson;
_bitmapSource = new Bitmap(filePathImage);
if ((_bitmapSource.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) ||
(_bitmapSource.PixelFormat == System.Drawing.Imaging.PixelFormat.Format32bppArgb))
{
_bitmapSource = ToolsConvolution.ConvertTo24(_bitmapSource);
}
Bitmap bitmapTemp = new Grayscale(1, 0, 0).Apply(_bitmapSource);
bitmapTemp = new Erosion().Apply(bitmapTemp);
bitmapTemp = new Threshold(160).Apply(bitmapTemp);
bitmapTemp = new Invert().Apply(bitmapTemp);
_kernel = ToolsConvolution.BitMapToDoubleArray(bitmapTemp, 0.5);
_threshold = new ModelValueDouble(application.EventTokenChanged, 0);
_weigth = new ModelValueDouble(application.EventTokenChanged, 0);
ModelRendererBitmapSource renderer = new ModelRendererBitmapSource(_bitmapSource);
renderer.Render();
Image = renderer.RenderedImage;
ModelRendererBitmapSource rendererProcessed = new ModelRendererBitmapSource(bitmapTemp);
rendererProcessed.Render();
ImageProcessed = rendererProcessed.RenderedImage;
if (File.Exists(filePathJson))
{
Load();
}
else
{
this._threshold = new ModelValueDouble(_application.EventTokenChanged, 0.8);
this._weigth = new ModelValueDouble(_application.EventTokenChanged, 1.0);
this._label = filePathImage.Split('_')[1];
Save();
}
}
public ModelPageLayout(IModelApplication application, string filePath, ModelPageLayout other)
{
_application = application;
_filePath = filePath;
this._rotation = new ModelValueDouble(application.EventLayoutChanged, 0);
this._threshold = new ModelValueInt(application.EventLayoutChanged, 0);
this._lineSize = new ModelValueDouble(application.EventLayoutChanged, 0);
this._lineOffset = new ModelValueDouble(application.EventLayoutChanged, 0);
this._lineCount = new ModelValueInt(application.EventLayoutChanged, 0);
this._colSize = new ModelValueDouble(application.EventLayoutChanged, 0);
this._colOffset = new ModelValueDouble(application.EventLayoutChanged, 0);
this._colCount = new ModelValueInt(application.EventLayoutChanged, 0);
this._margin = new ModelValueInt(application.EventLayoutChanged, 0);
this._overlap = new ModelValueDouble(application.EventLayoutChanged, 0);
if (File.Exists(_filePath))
{
Load();
}
else
{
if (other == null)
{
this._rotation.Value = 180;
this._threshold.Value = 100;
this._lineSize.Value = 20;
this._lineOffset.Value = 100;
this._lineCount.Value = 0;
this._colSize.Value = 20;
this._colOffset.Value = 100;
this._colCount.Value = 0;
this._margin.Value = 0;
this._overlap.Value = 0;
}
else
{
SetValue(other.GetValue());
}
Save();
}
}
public virtual void TearDown()
{
SecuritySystem.SetInstance(null);
modelApplication = null;
CaptionHelper.Setup(null);
testContext.Dispose();
testContext = null;
while (Application.OpenForms.Count != 0)
{
try {
Application.OpenForms[0].Close();
}
catch {
}
}
}
public static void AddRule(IModelApplication modelApplication, IModelClass modelClass)
{
if (modelClass.OwnMembers != null)
{
var modelMemberReminderInfo = modelClass.OwnMembers.OfType <IModelMemberReminderInfo>().FirstOrDefault();
if (modelMemberReminderInfo != null)
{
var conditionalAppearance = (IModelConditionalAppearance)modelApplication.BOModel.GetClass(modelClass.TypeInfo.Type);
var modelAppearanceRule = conditionalAppearance.AppearanceRules.AddNode <IModelAppearanceRule>("ReminderInfo.TimeBeforeStart");
modelAppearanceRule.AppearanceItemType = AppearanceItemType.ViewItem.ToString();
modelAppearanceRule.Criteria = "!" + modelMemberReminderInfo.Name + ".HasReminder";
modelAppearanceRule.Enabled = false;
modelAppearanceRule.TargetItems = modelMemberReminderInfo.Name + ".TimeBeforeStart";
}
}
}
public override void UpdateModel(IModelApplication applicationModel)
{
base.UpdateModel(applicationModel);
return;
IEnumerable<IModelClass> modelClasses =
applicationModel.BOModel.Where(cls => typeof(XPBaseObject).IsAssignableFrom(cls.TypeInfo.Type));
foreach (IModelClass modelClass in modelClasses){
foreach (IModelMember modelMember in from property in modelClass.AllMembers
let isSimpleStringEdit = (property.Type != typeof(string) || (property.RowCount == 0))
let isComboStringEdit = (isSimpleStringEdit && !string.IsNullOrEmpty(property.PredefinedValues))
where property.PropertyEditorType == typeof(StringPropertyEditor) && isSimpleStringEdit && !isComboStringEdit
select property)
modelMember.PropertyEditorType = typeof(MemberLevelSecurityStringPropertyEditor);
}
}
public ModelEditorViewController(IModelApplication modelApplication, ModelDifferenceStore diffstore)
: base(modelApplication, diffstore) {
AddNodeAction.ItemsChanged += AddNodeActionOnItemsChanged;
}
public new void SetModel(IModelApplication modelApplication)
{
_modelApplication = modelApplication;
base.SetModel(modelApplication);
}
void AddAfterSetupLayer(IModelApplication modelApplication) {
var modelApplicationBase = ((ModelApplicationBase)modelApplication);
ModelApplicationBase afterSetup = modelApplicationBase.CreatorInstance.CreateModelApplication();
afterSetup.Id = "After Setup";
modelApplicationBase.AddLayer(afterSetup);
}
public StringToModelViewConverter(IModelApplication modelApplication) {
_modelApplication = modelApplication;
}
private static IEnumerable<IModelRuntimeMember> GetCustomFields(IModelApplication model) {
return model.BOModel.SelectMany(modelClass => modelClass.AllMembers).OfType<IModelRuntimeMember>();
}
public static void AddFields(IModelApplication model, XPDictionary dictionary) {
AddRuntimeMembers(model, dictionary);
}
public static void AddFields(IModelApplication model) {
AddRuntimeMembers(model);
}
public ModelEditorViewController(IModelApplication modelApplication, ModelDifferenceStore diffstore)
: base(modelApplication, diffstore) {
}
public static void CreateSystemTypes(IObjectSpace ObjectSpace,IModelApplication app,bool deleteExists)
{
var objs = ObjectSpace.GetObjects<BusinessObject>(new BinaryOperator("IsRuntimeDefine", false));
if (objs.Count > 0)
return;
ObjectSpace.Delete(objs);
#region 系统类型
AddBusinessObject(typeof (单据<>), "单据<明细>", CreateNameSpace(typeof (单据<>).Namespace,ObjectSpace),
"单据<明细>,继承自单据基类,支持将明细类型做为参数传入(内部使用泛型实现)", false,ObjectSpace);
//AddBusinessObject(typeof (订单<>), "订单<明细>", CreateNameSpace(typeof (订单<>).Namespace, ObjectSpace),
// "订单<明细>,继承自 单据<明细>基类 ,支持将明细类型做为参数传入(内部使用泛型实现),并支持各类订单类型的抽象实现.", false, ObjectSpace);
//AddBusinessObject(typeof (仓库单据基类<>), "仓库单据基类<明细>", CreateNameSpace(typeof (仓库单据基类<>).Namespace,ObjectSpace),
// "仓库单据基类<明细>,继承自 单据<明细>基类,支持将明细类型做为参数传入(内部使用泛型实现),并支持各类仓库类单据的抽象实现.", false,ObjectSpace);
//AddBusinessObject(typeof (库存单据明细<>), "库存单据明细<单据>", CreateNameSpace(typeof (库存单据明细<>).Namespace,ObjectSpace),
// "继承自库存流水,用于库存单据明细的基类,需要传入单据类型.", false,ObjectSpace);
//AddBusinessObject(typeof (订单明细<>), "订单明细<订单>", CreateNameSpace(typeof (订单明细<>).Namespace,ObjectSpace), "可以与订单<订单明细>成对出现使用.",false,ObjectSpace);
AddBusinessObject(typeof (明细<>), "明细<单据>", CreateNameSpace(typeof (明细<>).Namespace, ObjectSpace),
"可以与单据<明细>成对继承使用.", false, ObjectSpace);
//第一步,创建出所有基类类型
var exists = ObjectSpace.GetObjects<BusinessObjectBase>(null, true);
foreach (var bom in app.BOModel)
{
if (!bom.TypeInfo.Type.IsGenericType && bom.TypeInfo.Type.Assembly.Location != AdmiralEnvironment.UserDefineBusinessFile.FullName)
{
var ns = CreateNameSpace(bom.TypeInfo.Type.Namespace, ObjectSpace);
AddBusinessObject(bom.TypeInfo.Type, bom.Caption, ns, "", false, ObjectSpace);
}
}
//第二步,创建这些类的属性,因为属性中可能使用了类型,所以先要创建类型.
var bos = ObjectSpace.GetObjects<BusinessObject>(null, true);
foreach (var bob in bos.Where(x => !x.IsRuntimeDefine))
{
var type = ReflectionHelper.FindType(bob.FullName);
if (type.BaseType != null && type.BaseType != typeof (object))
{
var fullName = type.BaseType.Namespace + "." + type.BaseType.Name;
var baseType = bos.SingleOrDefault(x => x.FullName == fullName);
bob.Base = baseType;
if (bob.Base == null)
{
Debug.WriteLine(type.FullName + "没有找到基类:" + fullName);
}
}
if (type.IsGenericType)
{
bob.DisableCreateGenericParameterValues = true;
foreach (var item in type.GetGenericArguments())
{
var gp = ObjectSpace.CreateObject<GenericParameter>();
gp.Owner = bob;
gp.Name = item.Name;
if (item.IsGenericParameter)
{
gp.ParameterIndex = item.GenericParameterPosition;
}
else
{
}
if (!string.IsNullOrEmpty(item.FullName))
gp.ParameterValue = exists.SingleOrDefault(x => x.FullName == item.FullName);
var att =
item.GetCustomAttributes(typeof (ItemTypeAttribute), false)
.OfType<ItemTypeAttribute>()
.FirstOrDefault();
if (att != null)
{
var gi = bos.SingleOrDefault(x => x.FullName == att.ItemType.FullName);
gp.DefaultGenericType = gi;
}
}
}
var typeInfo = CaptionHelper.ApplicationModel.BOModel.GetClass(type);
if (typeInfo != null && false)
{
foreach (var tim in typeInfo.OwnMembers)
{
if (tim.MemberInfo.IsAssociation)
{
var collectionMember = ObjectSpace.CreateObject<CollectionProperty>();
collectionMember.Owner = bob;
collectionMember.Aggregated = tim.MemberInfo.IsAggregated;
collectionMember.名称 = tim.Name;
collectionMember.PropertyType = bos.SingleOrDefault(x => x.FullName == tim.Type.FullName);
if (collectionMember.PropertyType == null)
{
Debug.WriteLine("没有找到属性类型:" + tim.Type.FullName);
//throw new Exception("没有找到属性类型" + tim.Type.FullName);
}
}
else
{
var member = ObjectSpace.CreateObject<Property>();
member.Owner = bob;
member.名称 = tim.Name;
member.PropertyType = exists.SingleOrDefault(x => x.FullName == tim.Type.FullName);
member.Owner = bob;
if (member.PropertyType == null)
{
Debug.WriteLine("没有找到属性类型:" + tim.Type.FullName);
//throw new Exception("没有找到属性类型" + tim.Type.FullName);
}
}
}
}
else
{
Debug.WriteLine("没有找到类型:" + type.FullName);
}
}
//第三步,设置属性的关联属性,因为可能用到第二步中创建的属性,及,创建关系.
foreach (var bob in bos.Where(x => !x.IsRuntimeDefine))
{
if (bob.CollectionProperties.Count > 0)
{
var type = ReflectionHelper.FindType(bob.FullName);
var typeInfo = CaptionHelper.ApplicationModel.BOModel.GetClass(type);
foreach (var cp in bob.CollectionProperties)
{
var mi = typeInfo.FindMember(cp.名称);
cp.RelationProperty = cp.PropertyType.FindProperty(mi.MemberInfo.AssociatedMemberInfo.Name);
}
}
}
#endregion
ObjectSpace.CommitChanges();
}
private static IEnumerable<IModelMemberEx> GetMembersEx(IModelApplication model) {
return model.BOModel.SelectMany(modelClass => modelClass.AllMembers).OfType<IModelMemberEx>().Distinct();
}
public StringToModelMemberConverter(IModelApplication modelApplication) {
_modelApplication = modelApplication;
}
