public NHObjectSpaceProvider(ITypesInfo typesInfo, IPersistenceManager persistenceManager)
{
Guard.ArgumentNotNull(typesInfo, "typesInfo");
Guard.ArgumentNotNull(persistenceManager, "persistenceManager");
this.typesInfo = typesInfo;
this.persistenceManager = persistenceManager;
}
internal NHNestedObjectSpace(ITypesInfo typesInfo, IEntityStore entityStore, IPersistenceManager persistenceManager,
Dictionary<object, ObjectSpaceInstanceInfo> instances, NHObjectSpace parentObjectSpace) :
base(typesInfo, entityStore, persistenceManager, instances, null)
{
this.parentObjectSpace = parentObjectSpace;
}
public CriteriaObjectReplacer(ITypesInfo typesInfo)
{
if (typesInfo == null)
throw new ArgumentNullException("typesInfo");
this.typesInfo = typesInfo;
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (!RuntimeMode) {
CreateDesignTimeCollection(typesInfo, typeof(UserModelDifferenceObject), "Users");
CreateDesignTimeCollection(typesInfo, typeof(RoleModelDifferenceObject), "Roles");
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (!RuntimeMode) {
CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Users");
CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Roles");
}
}
void CreateMember(ITypesInfo typesInfo, IRoleTypeProvider roleTypeProvider, SecurityOperationsAttribute attribute) {
var roleTypeInfo = typesInfo.FindTypeInfo(roleTypeProvider.RoleType);
if (roleTypeInfo.FindMember(attribute.OperationProviderProperty) == null) {
var memberInfo = roleTypeInfo.CreateMember(attribute.OperationProviderProperty, typeof(SecurityOperationsEnum));
memberInfo.AddAttribute(new RuleRequiredFieldAttribute());
}
}
void UpdateLayoutManager(ITypesInfo typesInfo) {
if (!(LayoutManager is ILayoutManager)) {
var typeInfo = ReflectionHelper.FindTypeDescendants(typesInfo.FindTypeInfo(typeof(ILayoutManager))).FirstOrDefault();
if (typeInfo != null)
this.SetPropertyInfoBackingFieldValue(view => view.LayoutManager, this, ReflectionHelper.CreateObject(typeInfo.Type));
}
}
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);
}
}
private XPCustomMemberInfo CreateMemberInfo(ITypesInfo typesInfo, IMemberInfo memberInfo, ProvidedAssociationAttribute providedAssociationAttribute, AssociationAttribute associationAttribute) {
var typeToCreateOn = getTypeToCreateOn(memberInfo, associationAttribute);
if (typeToCreateOn == null)
throw new NotImplementedException();
XPCustomMemberInfo xpCustomMemberInfo;
if (!(memberInfo.IsList) || (memberInfo.IsList && providedAssociationAttribute.RelationType == RelationType.ManyToMany)) {
xpCustomMemberInfo = typesInfo.CreateCollection(
typeToCreateOn,
memberInfo.Owner.Type,
associationAttribute.Name,
XpandModuleBase.Dictiorary,
providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.Type.Name + "s", false);
} else {
xpCustomMemberInfo = typesInfo.CreateMember(
typeToCreateOn,
memberInfo.Owner.Type,
associationAttribute.Name,
XpandModuleBase.Dictiorary,
providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.Type.Name, false);
}
if (!string.IsNullOrEmpty(providedAssociationAttribute.AssociationName) && memberInfo.FindAttribute<AssociationAttribute>() == null)
memberInfo.AddAttribute(new AssociationAttribute(providedAssociationAttribute.AssociationName));
typesInfo.RefreshInfo(typeToCreateOn);
return xpCustomMemberInfo;
}
void CreateMembers(ITypesInfo typesInfo, Type optionsType, Type persistentType) {
ITypeInfo typeInfo = typesInfo.FindTypeInfo(ReflectionHelper.GetType(persistentType.Name));
IEnumerable<PropertyInfo> propertyInfos = optionsType.GetProperties().Where(info => info.GetSetMethod() != null).Where(propertyInfo => typeInfo.FindMember(propertyInfo.Name) == null);
foreach (PropertyInfo propertyInfo in propertyInfos) {
OnCreateMember(typeInfo, propertyInfo.Name, propertyInfo.PropertyType);
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
var memberInfos = typesInfo.PersistentTypes.SelectMany(info => info.OwnMembers);
foreach (var memberInfo in memberInfos) {
HandleCustomAttribute(memberInfo, typesInfo);
}
}
protected override IObjectSpace CreateObjectSpaceCore(UnitOfWork unitOfWork, ITypesInfo typesInfo) {
var objectSpace = new XpandObjectSpace(new XpandUnitOfWork(unitOfWork.DataLayer), typesInfo) {
AsyncServerModeSourceResolveSession = AsyncServerModeSourceResolveSession,
AsyncServerModeSourceDismissSession = AsyncServerModeSourceDismissSession
};
return objectSpace;
}
ApplicationModulesManager CreateModulesManager(XafApplication application, string configFileName, string assembliesPath, ITypesInfo typesInfo) {
if (!string.IsNullOrEmpty(configFileName)) {
bool isWebApplicationModel = string.Compare(Path.GetFileNameWithoutExtension(configFileName), "web", true) == 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));
}
if (typesInfo is TypesInfo)
XpandModuleBase.Dictiorary = ((TypesInfo)typesInfo).Source.XPDictionary;
result.Load(typesInfo);
return result;
} finally {
XpandModuleBase.Dictiorary = XafTypesInfo.XpoTypeInfoSource.XPDictionary;
ReflectionHelper.RemoveResolvePath(assembliesPath);
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
new FullTextContainsFunction().Register();
if (Application != null && Application.Security != null) {
CreatePessimisticLockingField(typesInfo);
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (Application != null) {
typesInfo.FindTypeInfo(typeof(ShowInAnalysisPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
typesInfo.FindTypeInfo(typeof(PivotSettingsPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
}
}
protected void CreateDesignTimeCollection(ITypesInfo typesInfo, Type classType, string propertyName) {
XPClassInfo info = XafTypesInfo.XpoTypeInfoSource.XPDictionary.GetClassInfo(classType);
if (info.FindMember(propertyName) == null) {
info.CreateMember(propertyName, typeof(XPCollection), true);
typesInfo.RefreshInfo(classType);
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
InitializeInstanceXafApplicationManager();
var type = (BaseInfo)typesInfo.FindTypeInfo(typeof(IModelMember)).FindMember("Type");
var attribute = type.FindAttribute<ReadOnlyAttribute>();
if (attribute != null)
type.RemoveAttribute(attribute);
}
IEnumerable<XPMemberInfo> GetDecoratedMembers(ITypesInfo typesInfo) {
var memberInfos =
typesInfo.PersistentTypes.Where(info => (info.IsInterface && !info.IsDomainComponent) || !info.IsInterface).SelectMany(typeInfo => {
XPClassInfo xpClassInfo = XpandModuleBase.Dictiorary.QueryClassInfo(typeInfo.Type);
return xpClassInfo != null ? xpClassInfo.OwnMembers : new List<XPMemberInfo>();
});
return memberInfos.Where(memberInfo => memberInfo.HasAttribute(typeof(ProvidedAssociationAttribute)));
}
private void SetAdditionalExportedTypesProperties(ITypesInfo typesInfo)
{
foreach (var type in AdditionalExportedTypes)
{
var typeInfo = (TypeInfo)typesInfo.FindTypeInfo(type);
typeInfo.IsDomainComponent = true;
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
var memberInfos = typesInfo.PersistentTypes.SelectMany(info => info.OwnMembers);
foreach (var memberInfo in memberInfos) {
HandleNumericFormatAttribute(memberInfo);
HandleSequencePropertyAttribute(memberInfo);
}
}
public NHEntityStore(ITypesInfo typesInfo, IPersistenceManager persistenceManager)
{
Guard.ArgumentNotNull(typesInfo, "typesInfo");
Guard.ArgumentNotNull(persistenceManager, "persistenceManager");
this.typesInfo = typesInfo;
this.persistenceManager = persistenceManager;
}
void AddNewObjectCreateGroup(ITypesInfo typesInfo, IEnumerable<Type> types) {
foreach (var type in types) {
var typeDescendants = ReflectionHelper.FindTypeDescendants(typesInfo.FindTypeInfo(type));
foreach (var typeInfo in typeDescendants) {
typeInfo.AddAttribute(new NewObjectCreateGroupAttribute("Logic"));
}
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (!RuntimeMode) {
CreateDesignTimeCollection(typesInfo, typeof(DashboardDefinition), "Roles");
} else if ((Application.Security.UserType != null && !Application.Security.UserType.IsInterface)) {
BuildSecuritySystemObjects();
}
}
void CreateMembers(ITypesInfo typesInfo) {
foreach (FilterProviderBase provider in FilterProviderManager.Providers) {
FilterProviderBase provider1 = provider;
foreach (ITypeInfo typeInfo in typesInfo.PersistentTypes.Where(typeInfo => TypeMatch(typeInfo, provider1))) {
CreateMember(typeInfo, provider);
}
}
}
public void Init()
{
_TypesInfo = A.Fake<ITypesInfo>();
_TypeInfo = A.Fake<ITypeInfo>();
A.CallTo(() => _TypesInfo.FindTypeInfo(A<Type>.Ignored)).Returns(_TypeInfo);
_Builder = ModelBuilder.Create<TargetClass>(_TypesInfo);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (!RuntimeMode) {
CreateDesignTimeCollection(typesInfo, typeof(UserModelDifferenceObject), "Users");
CreateDesignTimeCollection(typesInfo, typeof(RoleModelDifferenceObject), "Roles");
} else if (Application.CanBuildSecurityObjects()) {
BuildSecuritySystemObjects();
}
}
void CreateMembers(ITypesInfo typesInfo) {
foreach (FilterProviderBase provider in FilterProviderManager.Providers) {
FilterProviderBase provider1 = provider;
foreach (ITypeInfo typeInfo in typesInfo.PersistentTypes.Where(
typeInfo => (provider1.ObjectType == null || provider1.ObjectType == typeInfo.Type) && typeInfo.FindMember(provider1.FilterMemberName) == null && typeInfo.IsPersistent)) {
CreateMember(typeInfo, provider);
}
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
base.CustomizeTypesInfo(typesInfo);
if (!RuntimeMode) {
CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Users");
CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Roles");
} else if ((Application.CanBuildSecurityObjects())) {
BuildSecuritySystemObjects();
}
}
public NHObjectSpaceProvider(ITypesInfo typesInfo, IPersistenceManager persistenceManager, ISelectDataSecurityProvider selectDataProvider)
{
Guard.ArgumentNotNull(typesInfo, "typesInfo");
Guard.ArgumentNotNull(persistenceManager, "persistenceManager");
this.typesInfo = typesInfo;
this.persistenceManager = persistenceManager;
this.selectDataProvider = selectDataProvider;
ParseCriteriaScope.Init(typesInfo);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
if (Debugger.IsAttached) {
IEnumerable<XPClassInfo> collection = XafTypesInfo.XpoTypeInfoSource.XPDictionary.Classes.Cast<XPClassInfo>();
foreach (var typeInfo in collection)
if (typeInfo.HasAttribute(typeof(RuleCombinationOfPropertiesIsUniqueAttribute)))
if (typesInfo.FindTypeInfo(typeInfo.ClassType).DefaultMember == null)
throw new NullReferenceException("DefaultMember of " + typeInfo.FullName + " is null");
}
}
public ModelApplicationBase GetMasterModel(bool tryToUseCurrentTypesInfo, Action <ITypesInfo> action = null)
{
if (!File.Exists(_moduleName))
{
throw new UserFriendlyException(_moduleName + " not found in path");
}
ModelApplicationBase masterModel = null;
Retry.Do(() => {
_typesInfo = TypesInfoBuilder.Create()
.FromModule(_moduleName)
.Build(tryToUseCurrentTypesInfo);
_xafApplication = ApplicationBuilder.Create().
UsingTypesInfo(s => _typesInfo).
FromModule(_moduleName).
Build();
masterModel = GetMasterModel(_xafApplication, action);
}, TimeSpan.FromTicks(1), 2);
return(masterModel);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
typesInfo
.RemoveXafViewsFromApplicationModel()
.RemoveXpoViewsFromApplicationModel();
var builder = ModelBuilder.Create <MailBaseObject>(typesInfo);
builder.For(m => m.IsDeleted)
.HasTooltip("");
builder.Build();
ModelBuilder.Create <MailBaseObject>(typesInfo).GenerateNoViews().Build();
ModelBuilder.Create <MailBaseObjectId>(typesInfo).GenerateNoViews().Build();
new MailClientBuilderManager(typesInfo)
.Build();
}
public static XPMemberInfo CreateMember(this ITypesInfo typesInfo, Type typeToCreateOn, Type typeOfMember, string associationName, XPDictionary dictionary, string propertyName, bool refreshTypesInfo)
{
XPMemberInfo member = null;
if (TypeIsRegister(typesInfo, typeToCreateOn))
{
XPClassInfo xpClassInfo = dictionary.GetClassInfo(typeToCreateOn);
member = xpClassInfo.FindMember(propertyName);
if (member == null)
{
member = xpClassInfo.CreateMember(propertyName, typeOfMember);
member.AddAttribute(new AssociationAttribute(associationName));
if (refreshTypesInfo)
{
typesInfo.RefreshInfo(typeToCreateOn);
}
}
}
return(member);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
ITypeInfo typeInfo1 = typesInfo.FindTypeInfo(typeof(ExternalDocument));
ITypeInfo typeInfo2 = typesInfo.FindTypeInfo(typeof(ОбъектРемонта));
IMemberInfo memberInfo1 = typeInfo1.FindMember("ОбъектРемонта");
IMemberInfo memberInfo2 = typeInfo2.FindMember("ExternalDocument");
if (memberInfo2 == null)
{
memberInfo2 = typeInfo2.CreateMember("ExternalDocument", typeof(XPCollection <ExternalDocument>));
memberInfo2.AddAttribute(new DevExpress.Xpo.AssociationAttribute("A", typeof(ExternalDocument)), true);
memberInfo2.AddAttribute(new DevExpress.Xpo.AggregatedAttribute(), true);
}
if (memberInfo1 == null)
{
memberInfo1 = typeInfo1.CreateMember("Asset", typeof(ОбъектРемонта));
memberInfo1.AddAttribute(new DevExpress.Xpo.AssociationAttribute("A", typeof(ОбъектРемонта)), true);
memberInfo1.AddAttribute(new DevExpress.Persistent.Base.ImmediatePostDataAttribute(), true);
}
((XafMemberInfo)memberInfo1).Refresh();
((XafMemberInfo)memberInfo2).Refresh();
if (typesInfo == null)
{
return;
}
ITypeInfo typeInfo;
// В класс ОбъектРемонта добавляем свойство ExternalFactor
// Ищем TypeInfo для класса Galaktika.EAM.Module.Активы.ОбъектРемонта
typeInfo = typesInfo.FindTypeInfo(typeof(ОбъектРемонта));
if (typeInfo != null)
{
// Для типа добавляем свойство Mass с типом decimal
var exfProperty = typeInfo.CreateMember("ExternalFactor", typeof(decimal));
}
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
//CalculatedPersistentAliasHelper.CustomizeTypesInfo(typesInfo);
ITypeInfo typeInfoDomainObject1 = XafTypesInfo.Instance.FindTypeInfo(typeof(PermissionPolicyUser));
typeInfoDomainObject1.CreateMember("Color", typeof(Int32));
IMemberInfo typeInfoDomainObject1Metadata = typeInfoDomainObject1.FindMember("Color");
typeInfoDomainObject1Metadata.AddAttribute(new VisibleInReportsAttribute(false));
typeInfoDomainObject1Metadata.AddAttribute(new VisibleInDetailViewAttribute(false));
typeInfoDomainObject1Metadata.AddAttribute(new VisibleInListViewAttribute(false));
typeInfoDomainObject1Metadata.AddAttribute(new VisibleInLookupListViewAttribute(false));
typeInfoDomainObject1.CreateMember("Color2", typeof(Int32));
IMemberInfo typeInfoDomainObject1Metadata2 = typeInfoDomainObject1.FindMember("Color2");
typeInfoDomainObject1Metadata2.AddAttribute(new VisibleInReportsAttribute(false));
typeInfoDomainObject1Metadata2.AddAttribute(new VisibleInDetailViewAttribute(false));
typeInfoDomainObject1Metadata2.AddAttribute(new VisibleInListViewAttribute(false));
typeInfoDomainObject1Metadata2.AddAttribute(new VisibleInLookupListViewAttribute(false));
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
CalculatedPersistentAliasHelper.CustomizeTypesInfo(typesInfo);
var dsDefaultClassOptionsTypes =
typesInfo.PersistentTypes.Where(t => t.Attributes.Any(a => a.GetType().Name.StartsWith("DS")));
foreach (var dsDefaultClassOptionsType in dsDefaultClassOptionsTypes)
{
dsDefaultClassOptionsType.AddAttribute(new DefaultClassOptionsAttribute());
}
//typesInfo.FindTypeInfo(typeof(Policy)).AddAttribute(new DSDefaultClassOptionsAttribute());
//typesInfo.FindTypeInfo(typeof(PolicyChld)).AddAttribute(new DSDefaultClassOptionsAttribute());
//typesInfo.FindTypeInfo(typeof(Client)).AddAttribute(new DSDefaultClassOptionsAttribute());
//typesInfo.FindTypeInfo(typeof(Organization)).AddAttribute(new DSDefaultClassOptionsAttribute());
//typesInfo.FindTypeInfo(typeof(DoSoUser2)).AddAttribute(new DSDefaultClassOptionsAttribute());
//var createdBy = typesInfo.FindTypeInfo(typeof(Client)).FindMember(nameof(Client.CreatedBy2));
//Client.GetCreatedBy
//createdBy.MemberType = typeof(SecuritySystemUser);
//Mapper.Initialize(cfg => cfg.CreateMap<Policy, Policy2>());
//createdBy.AddAttribute(new NonPersistentAttribute());
//createdBy.AddAttribute(new PersistentAliasAttribute("CreatedBy2.Oid"));
//Type type = typeof(Client);
//PropertyInfo prop = type.GetProperty("CreatedBy");
//prop.PropertyType = typeof(Client);
//var createdBy2 = typesInfo.FindTypeInfo(typeof(Client)).CreateMember("CreatedBy2", typeof(Guid));
//createdBy2.AddAttribute(new PersistentAttribute(nameof(Client.CreatedBy3)));
Client.OnSavingEvent += client => client.SetMemberValue("CreatedBy3", client.Session.GetObjectByKey <DoSoUser2>(SecuritySystem.CurrentUserId));
}
private XPMemberInfo CreateMemberInfo(ITypesInfo typesInfo, XPMemberInfo memberInfo, ProvidedAssociationAttribute providedAssociationAttribute, AssociationAttribute associationAttribute)
{
var typeToCreateOn = GetTypeToCreateOn(memberInfo, associationAttribute);
if (typeToCreateOn == null)
{
throw new NotImplementedException();
}
XPMemberInfo xpCustomMemberInfo;
if (!(memberInfo.IsNonAssociationList) || (memberInfo.IsNonAssociationList && providedAssociationAttribute.RelationType == RelationType.ManyToMany))
{
xpCustomMemberInfo = typesInfo.CreateCollection(
typeToCreateOn,
memberInfo.Owner.ClassType,
associationAttribute.Name,
XpandModuleBase.Dictiorary,
providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.ClassType.Name + "s", false);
}
else
{
xpCustomMemberInfo = typesInfo.CreateMember(
typeToCreateOn,
memberInfo.Owner.ClassType,
associationAttribute.Name,
XpandModuleBase.Dictiorary,
providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.ClassType.Name, false);
}
if (!string.IsNullOrEmpty(providedAssociationAttribute.AssociationName) && !memberInfo.HasAttribute(typeof(AssociationAttribute)))
{
memberInfo.AddAttribute(new AssociationAttribute(providedAssociationAttribute.AssociationName));
}
typesInfo.RefreshInfo(typeToCreateOn);
return(xpCustomMemberInfo);
}
static XPMemberInfo CreateCollection(this ITypesInfo typeInfo, Type typeToCreateOn, Type typeOfCollection, string associationName, string collectionName, bool refreshTypesInfo,
bool isManyToMany)
{
XPMemberInfo member = null;
if (TypeIsRegister(typeInfo, typeToCreateOn))
{
XPClassInfo xpClassInfo = typeInfo.FindTypeInfo(typeToCreateOn).QueryXPClassInfo();
member = xpClassInfo.FindMember(collectionName) ??
xpClassInfo.CreateMember(collectionName, typeof(XPCollection), true);
if (member.FindAttributeInfo(typeof(AssociationAttribute)) == null)
{
member.AddAttribute(new AssociationAttribute(associationName, typeOfCollection)
{
UseAssociationNameAsIntermediateTableName = isManyToMany
});
}
if (refreshTypesInfo)
{
typeInfo.RefreshInfo(typeToCreateOn);
}
}
return(member);
}
private void ApplySecurityOperations(ITypesInfo typesInfo)
{
var securityOperationInfos = typesInfo.PersistentTypes.Where(info => info.FindAttribute <SecurityOperationsAttribute>() != null);
var roleInfos = typesInfo.DomainSealedInfos <ISecurityRole>().ToArray();
foreach (var securityOperationInfo in securityOperationInfos)
{
var securityOperationsAttributes = securityOperationInfo.FindAttributes <SecurityOperationsAttribute>();
foreach (var securityOperationsAttribute in securityOperationsAttributes)
{
foreach (var roleInfo in roleInfos.Where(info => (!RuntimeMode || info.Type == RoleType) && !(((TypeInfo)info).Source is ReflectionTypeInfoSource)))
{
if (roleInfo.FindMember(securityOperationsAttribute.OperationProviderProperty) == null)
{
roleInfo.CreateMember(securityOperationsAttribute.OperationProviderProperty, typeof(SecurityOperationsEnum));
}
if (!RuntimeMode)
{
CreateWeaklyTypedCollection(typesInfo, roleInfo.Type, securityOperationsAttribute.CollectionName);
}
}
}
}
}
public static IEnumerable <ITypeInfo> DomainSealedInfos <T>(this ITypesInfo typesInfo)
{
return(typesInfo.DomainSealedInfos(typeof(T)));
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
_typesInfoSubject.OnNext(typesInfo);
_typesInfoSubject.OnCompleted();
}
public static ITypeInfo FindTypeInfo <T>(this ITypesInfo typesInfo)
{
return(typesInfo.FindTypeInfo(typeof(T)));
}
private static bool TypeIsRegister(ITypesInfo typeInfo, Type typeToCreateOn)
{
return(XafTypesInfo.Instance.FindTypeInfo(typeToCreateOn).IsDomainComponent ||
typeInfo.PersistentTypes.FirstOrDefault(info => info.Type == typeToCreateOn) != null);
}
// register your application types here
private static void RegisterBOTypes(ITypesInfo typesInfo)
{
typesInfo.RegisterEntity(typeof(Employee));
}
public static List <XPMemberInfo> CreateBothPartMembers(this ITypesInfo typesinfo, Type typeToCreateOn, Type otherPartMember, bool isManyToMany)
{
return(CreateBothPartMembers(typesinfo, typeToCreateOn, otherPartMember, isManyToMany, Guid.NewGuid().ToString()));
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
typesInfo.RegisterEntity("SequenceGeneratorDCObject", typeof(ISequenceGeneratorObject));
}
public MainDemoBuilderManager(ITypesInfo typesInfo, IEnumerable <IBuilder> builders)
: base(typesInfo, builders)
{
}
static XPMemberInfo CreateCollection(this ITypesInfo typeInfo, Type typeToCreateOn, Type typeOfCollection, string associationName, bool refreshTypesInfo,
string propertyName, bool isManyToMany)
{
return(CreateCollection(typeInfo, typeToCreateOn, typeOfCollection, associationName, propertyName, refreshTypesInfo, isManyToMany));
}
public static XPMemberInfo CreateCollection(this ITypesInfo typeInfo, Type typeToCreateOn, Type typeOfCollection, string associationName, string collectionName)
{
return(CreateCollection(typeInfo, typeToCreateOn, typeOfCollection, associationName, collectionName, true));
}
public static XPMemberInfo CreateMember(this ITypesInfo typesInfo, Type typeToCreateOn, Type typeOfMember, string associationName, string propertyName)
{
return(CreateMember(typesInfo, typeToCreateOn, typeOfMember, associationName, propertyName, true));
}
public static XPMemberInfo CreateMember(this ITypesInfo typesInfo, Type typeToCreateOn, Type typeOfMember, string associationName, bool refreshTypesInfo)
{
return(CreateMember(typesInfo, typeToCreateOn, typeOfMember, associationName, typeOfMember.Name, refreshTypesInfo));
}
public static Type FindBussinessObjectType <T>(this ITypesInfo typesInfo)
{
return(typesInfo.FindBussinessObjectType(typeof(T)));
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
}
public WorldCreatorObjectSpaceProvider(bool threadSafe, IXpoDataStoreProvider xpoDataStoreProvider, ITypesInfo typesInfo)
: base(GetConnectionStringDataStoreProvider(xpoDataStoreProvider), typesInfo, WorldCreatorTypeInfoSource.Instance, threadSafe)
{
}
/// <summary> /// Creates the specified types information. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="typesInfo">The types information.</param> /// <returns></returns> public static ModelBuilder <T> Create <T>(ITypesInfo typesInfo) => new ModelBuilder <T>(typesInfo.FindTypeInfo <T>());
public static List <XPMemberInfo> CreateBothPartMembers(this ITypesInfo typesInfo, Type typeToCreateOn, Type otherPartType)
{
return(CreateBothPartMembers(typesInfo, typeToCreateOn, otherPartType, false));
}
public static XPMemberInfo CreateCollection(this ITypesInfo typeInfo, Type typeToCreateOn, Type typeOfCollection, string associationName, string collectionName, bool refreshTypesInfo)
{
return(CreateCollection(typeInfo, typeToCreateOn, typeOfCollection, associationName, collectionName, refreshTypesInfo, false));
}
/// <summary> /// Finds the type information. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="typesInfo">The types information.</param> /// <returns></returns> public static ITypeInfo FindTypeInfo <T>(this ITypesInfo typesInfo) => typesInfo.FindTypeInfo(typeof(T));
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
CalculatedPersistentAliasHelper.CustomizeTypesInfo(typesInfo);
}
/// <summary>
/// Creates the specified types information.
/// </summary>
/// <typeparam name="TBuilder">The type of the builder.</typeparam>
/// <typeparam name="T"></typeparam>
/// <param name="typesInfo">The types information.</param>
/// <returns></returns>
public static TBuilder Create <TBuilder, T>(ITypesInfo typesInfo)
where TBuilder : IModelBuilder <T>
=> (TBuilder)Activator.CreateInstance(typeof(TBuilder), typesInfo.FindTypeInfo <T>());
