static void CreateAttributes(IExtendedMemberInfo extendedMemberInfo, XPCustomMemberInfo memberInfo)
{
foreach (AttributeInfoAttribute attributeInfo in extendedMemberInfo.TypeAttributes.Select(typeAttribute => typeAttribute.Create()))
{
memberInfo.AddAttribute((Attribute)ReflectionHelper.CreateObject(attributeInfo.Constructor.DeclaringType, attributeInfo.InitializedArgumentValues));
}
}
private void createAttributes(IExtendedMemberInfo extendedMemberInfo, XPCustomMemberInfo customMemberInfo)
{
foreach (IPersistentAttributeInfo typeAttribute in extendedMemberInfo.TypeAttributes){
AttributeInfo attributeInfo = typeAttribute.Create();
customMemberInfo.AddAttribute((Attribute)Activator.CreateInstance(attributeInfo.Constructor.DeclaringType, attributeInfo.InitializedArgumentValues[0], ReflectionHelper.GetType(attributeInfo.InitializedArgumentValues[2] as string)));
}
}
public static List <XPCustomMemberInfo> CreateBothPartMembers(this ITypesInfo typesinfo, Type typeToCreateOn, Type otherPartMember, XPDictionary xpDictionary, bool isManyToMany, string association)
{
var infos = new List <XPCustomMemberInfo>();
XPCustomMemberInfo member = isManyToMany
? CreateCollection(typesinfo, typeToCreateOn, otherPartMember, association, xpDictionary, false)
: CreateMember(typesinfo, otherPartMember, typeToCreateOn, association, xpDictionary, false);
if (member != null)
{
infos.Add(member);
member = isManyToMany
? CreateCollection(typesinfo, otherPartMember, typeToCreateOn, association, xpDictionary,
false)
: CreateCollection(typesinfo, typeToCreateOn, otherPartMember, association, xpDictionary,
false);
if (member != null)
{
infos.Add(member);
}
}
typesinfo.RefreshInfo(typeToCreateOn);
typesinfo.RefreshInfo(otherPartMember);
return(infos);
}
IModelMember GetCalcNode(XPCustomMemberInfo memberInfo, IModelClass modelClass)
{
var modelRuntimeCalculatedMember = modelClass.OwnMembers.AddNode <IModelRuntimeCalculatedMember>(memberInfo.Name);
modelRuntimeCalculatedMember.AliasExpression = ((PersistentAliasAttribute)memberInfo.FindAttributeInfo(typeof(PersistentAliasAttribute))).AliasExpression;
return(modelRuntimeCalculatedMember);
}
IModelMember GetCollectionNode(XPCustomMemberInfo memberInfo, IModelClass modelClass)
{
var modelRuntimeOrphanedColection = modelClass.OwnMembers.AddNode <IModelRuntimeOrphanedColection>(memberInfo.Name);
modelRuntimeOrphanedColection.CollectionType = modelClass.Application.BOModel[memberInfo.MemberType.GetGenericArguments()[0].FullName];
modelRuntimeOrphanedColection.Criteria = ((XpandCollectionMemberInfo)memberInfo).Criteria;
return(modelRuntimeOrphanedColection);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
foreach (var memberInfo in GetDecoratedMembers(typesInfo))
{
var providedAssociationAttribute = (ProvidedAssociationAttribute)memberInfo.FindAttributeInfo(typeof(ProvidedAssociationAttribute));
AssociationAttribute associationAttribute = GetAssociationAttribute(memberInfo, providedAssociationAttribute);
XPCustomMemberInfo customMemberInfo = CreateMemberInfo(typesInfo, memberInfo, providedAssociationAttribute, associationAttribute);
AddExtraAttributes(memberInfo, providedAssociationAttribute, customMemberInfo);
}
}
static void AddAttributes(IModelRuntimeMember runtimeMember, XPCustomMemberInfo memberInfo)
{
if (runtimeMember.Size != 0)
{
memberInfo.AddAttribute(new SizeAttribute(runtimeMember.Size));
}
if (runtimeMember is IModelRuntimeNonPersistentMember && !(runtimeMember is IModelRuntimeCalculatedMember))
{
memberInfo.AddAttribute(new NonPersistentAttribute());
}
}
static void AddAttributes(IModelMemberEx modelMemberEx, XPCustomMemberInfo memberInfo)
{
if (modelMemberEx.Size != 0)
{
memberInfo.AddAttribute(new SizeAttribute(modelMemberEx.Size));
}
if (modelMemberEx is IModelMemberNonPersistent && !(modelMemberEx is IModelMemberCalculated))
{
memberInfo.AddAttribute(new NonPersistentAttribute());
}
}
public void An_Associated_Member_Can_Be_Created_To_Any_Perstent_type()
{
ITypesInfo info = XafTypesInfo.Instance;
Type typeToCreateOn = typeof(User);
info.RegisterEntity(typeToCreateOn);
Type typeOfMember = typeof(Analysis);
XPCustomMemberInfo member = info.CreateMember(typeToCreateOn, typeOfMember, "association", XpoTypesInfoHelper.GetXpoTypeInfoSource().XPDictionary);
assertMemberCreation(member, typeOfMember.Name, typeToCreateOn);
}
private void addAttributes(IMemberInfo memberInfo, AssociationAttribute associationAttribute, ProvidedAssociationAttribute providedAssociationAttribute, XPCustomMemberInfo customMemberInfo)
{
customMemberInfo.AddAttribute(getAssociationAttribute(customMemberInfo.IsCollection, memberInfo.Owner.Type,associationAttribute.Name));
if (providedAssociationAttribute.AttributesFactoryProperty != null){
var property = memberInfo.Owner.Type.GetProperty(providedAssociationAttribute.AttributesFactoryProperty, BindingFlags.Static|BindingFlags.Public);
if (property== null)
throw new NullReferenceException(string.Format("Static propeprty {0} not found at {1}", providedAssociationAttribute.GetPropertyInfo(x=>x.AttributesFactoryProperty).Name, memberInfo.Owner.Type.FullName));
var values = (IEnumerable<Attribute>) property.GetValue(null, null);
foreach (Attribute attribute in values){
customMemberInfo.AddAttribute(attribute);
}
}
}
static IEnumerable <XPCustomMemberInfo> CreateCollectionMembers(IObjectSpace objectSpace)
{
IEnumerable <IExtendedMemberInfo> xpCollection = GetMembers(objectSpace, XafTypesInfo.Instance.FindBussinessObjectType <IExtendedCollectionMemberInfo>());
var collection = xpCollection.Cast <IExtendedCollectionMemberInfo>();
foreach (var info in collection)
{
XPCustomMemberInfo member = GetXPCustomMemberInfo(info);
if (member != null)
{
CreateAttributes(info, member);
yield return(member);
}
}
}
public void AN_Association_Collection_Can_Be_Created_To_Any_Persistent_Type()
{
ITypesInfo info = XafTypesInfo.Instance;
Type typeToCreateOn = typeof(User);
info.RegisterEntity(typeToCreateOn);
Type typeOfCollection = typeof(Analysis);
XPCustomMemberInfo collection = info.CreateCollection(typeToCreateOn, typeOfCollection, "association",
XpoTypesInfoHelper.GetXpoTypeInfoSource().XPDictionary);
AssociationAttribute attribute = assertMemberCreation(collection, typeOfCollection.Name + "s", typeToCreateOn);
Assert.AreEqual(typeOfCollection.FullName, attribute.ElementTypeName);
}
public List <Type> CreateCollectionMembers(Session session)
{
IEnumerable <IExtendedMemberInfo> xpCollection = GetMembers(session, WCTypesInfo.Instance.FindBussinessObjectType <IExtendedCollectionMemberInfo>());
var collection = xpCollection.Cast <IExtendedCollectionMemberInfo>();
var types = new List <Type>();
foreach (var info in collection)
{
XPCustomMemberInfo member = GetXPCustomMemberInfo(info);
if (member != null)
{
CreateAttributes(info, member);
types.Add(info.Owner);
}
}
return(types);
}
protected static bool ValidState(TModelMember modelMemberEx, XPCustomMemberInfo memberInfo, Func <TModelMember, bool> validState)
{
if (CheckTag(modelMemberEx))
{
return(false);
}
if (memberInfo == null && !String.IsNullOrEmpty(modelMemberEx.Name))
{
TagMember(modelMemberEx, true);
if (modelMemberEx.Type != null && (validState.Invoke(modelMemberEx)))
{
TagMember(modelMemberEx, false);
return(true);
}
}
return(false);
}
public static XPCustomMemberInfo CreateMember(this ITypesInfo typesInfo, Type typeToCreateOn, Type typeOfMember, string associationName, XPDictionary dictionary, string propertyName, bool refreshTypesInfo)
{
XPCustomMemberInfo member = null;
if (typeIsRegister(typesInfo, typeToCreateOn))
{
XPClassInfo xpClassInfo = dictionary.GetClassInfo(typeToCreateOn);
if (xpClassInfo.FindMember(propertyName) == null)
{
member = xpClassInfo.CreateMember(propertyName, typeOfMember);
member.AddAttribute(new AssociationAttribute(associationName));
if (refreshTypesInfo)
{
typesInfo.RefreshInfo(typeToCreateOn);
}
}
}
return(member);
}
IModelMember GetPropertyNode(XPCustomMemberInfo memberInfo, IModelClass modelClass)
{
if (memberInfo is XpandCalcMemberInfo)
{
return(GetCalcNode(memberInfo, modelClass));
}
if (memberInfo is XpandCollectionMemberInfo)
{
return(GetCollectionNode(memberInfo, modelClass));
}
if (!(memberInfo.IsPersistent))
{
return(modelClass.OwnMembers.AddNode <IModelRuntimeNonPersistentMember>(memberInfo.Name));
}
if (memberInfo is XpandCustomMemberInfo)
{
return(modelClass.OwnMembers.AddNode <IModelRuntimeMember>(memberInfo.Name));
}
throw new NotImplementedException(memberInfo.ToString());
}
public DynamicDataTableClassInfo(XPDictionary dictionary, DataTable table)
: base(dictionary)
{
if (table.PrimaryKey.Length != 1)
{
throw new NotSupportedException();
}
baseClassCore = dictionary.QueryClassInfo(typeof(XPDataTableObject));
tableNameCore = table.TableName;
foreach (DataColumn column in table.Columns)
{
XPCustomMemberInfo member = CreateMember(column.Caption, column.DataType);
member.AddAttribute(new PersistentAttribute(column.ColumnName));
member.AddAttribute(new DisplayNameAttribute(column.Caption));
if (table.PrimaryKey[0] == column)
{
member.AddAttribute(new KeyAttribute(column.AutoIncrement));
}
}
dictionary.AddClassInfo(this);
}
static XPCustomMemberInfo CreateCollection(this ITypesInfo typeInfo, Type typeToCreateOn, Type typeOfCollection, string associationName, XPDictionary dictionary, string collectionName, bool refreshTypesInfo,
bool isManyToMany)
{
XPCustomMemberInfo member = null;
if (typeIsRegister(typeInfo, typeToCreateOn))
{
XPClassInfo xpClassInfo = dictionary.GetClassInfo(typeToCreateOn);
if (xpClassInfo.FindMember(collectionName) == null)
{
member = xpClassInfo.CreateMember(collectionName, typeof(XPCollection), true);
member.AddAttribute(new AssociationAttribute(associationName, typeOfCollection)
{
UseAssociationNameAsIntermediateTableName = isManyToMany
});
if (refreshTypesInfo)
{
typeInfo.RefreshInfo(typeToCreateOn);
}
}
}
return(member);
}
void AddExtraAttributes(XPMemberInfo memberInfo, ProvidedAssociationAttribute providedAssociationAttribute, XPCustomMemberInfo customMemberInfo) {
if (!(string.IsNullOrEmpty(providedAssociationAttribute.AttributesFactoryProperty)))
foreach (var attribute in GetAttributes(providedAssociationAttribute.AttributesFactoryProperty, memberInfo.Owner)) {
customMemberInfo.AddAttribute(attribute);
}
}
public static void CreateColumn(this IObjectSpace objectSpace, XPCustomMemberInfo customMemberInfo, bool throwUnableToCreateDBObjectException = false)
{
CreateDbObject(objectSpace, store => store.CreateColumn(customMemberInfo, throwUnableToCreateDBObjectException));
}
public void CreateAttributes(IExtendedMemberInfo extendedMemberInfo, XPCustomMemberInfo memberInfo) {
foreach (AttributeInfoAttribute attributeInfo in extendedMemberInfo.TypeAttributes.Select(typeAttribute => typeAttribute.Create())) {
memberInfo.AddAttribute((Attribute)ReflectionHelper.CreateObject(attributeInfo.Constructor.DeclaringType, attributeInfo.InitializedArgumentValues));
}
}
public void CreateAttributes(IExtendedMemberInfo extendedMemberInfo, XPCustomMemberInfo customMemberInfo) {
foreach (AttributeInfo attributeInfo in extendedMemberInfo.TypeAttributes.Select(typeAttribute => typeAttribute.Create())) {
customMemberInfo.AddAttribute((Attribute)Activator.CreateInstance(attributeInfo.Constructor.DeclaringType,attributeInfo.InitializedArgumentValues));
}
}
void AddExtraAttributes(XPMemberInfo memberInfo, ProvidedAssociationAttribute providedAssociationAttribute, XPCustomMemberInfo customMemberInfo)
{
if (!(string.IsNullOrEmpty(providedAssociationAttribute.AttributesFactoryProperty)))
{
foreach (var attribute in GetAttributes(providedAssociationAttribute.AttributesFactoryProperty, memberInfo.Owner))
{
customMemberInfo.AddAttribute(attribute);
}
}
}
static void AddAttributes(IModelRuntimeMember runtimeMember, XPCustomMemberInfo memberInfo) {
if (runtimeMember.Size != 0)
memberInfo.AddAttribute(new SizeAttribute(runtimeMember.Size));
if (runtimeMember is IModelRuntimeNonPersistentMember && !(runtimeMember is IModelRuntimeCalculatedMember))
memberInfo.AddAttribute(new NonPersistentAttribute());
}
private static IList <string> GetDynamicClassInfoFromTable(DataTable table, string primaryKeyName, IList <string> displayColumnNames,
CaseInsensitiveDictionary <string> filterColumnNamesAndValues, out XPClassInfo classInfo,
out ReflectionDictionary reflectionDictionary)
{
reflectionDictionary = new ReflectionDictionary();
classInfo =
new XPDataObjectClassInfo(reflectionDictionary.GetClassInfo(typeof(DynamicXpoObject)), table.TableName);
DataColumn primaryKeyColumn = null;
if (string.IsNullOrEmpty(primaryKeyName))
{
primaryKeyColumn = table.Columns[0];
}
else
{
foreach (DataColumn col in table.Columns)
{
if (string.Equals(col.ColumnName, primaryKeyName, StringComparison.OrdinalIgnoreCase))
{
primaryKeyColumn = col;
break;
}
}
if (primaryKeyColumn == null)
{
throw new ArgException("The primary key column named \"{0}\" could not be found in the view \"{1}\"",
primaryKeyName, table.TableName);
}
}
if (CollectionUtils.IsNullOrEmpty(displayColumnNames))
{
// Add all columns from the view, ignoring filterColumnNames as displayable, if found
if (!CollectionUtils.IsNullOrEmpty(filterColumnNamesAndValues))
{
displayColumnNames = new List <string>(table.Columns.Count);
}
else
{
displayColumnNames = null;
}
bool foundAnyFilterColumns = false;
foreach (DataColumn col in table.Columns)
{
if (col == primaryKeyColumn)
{
XPCustomMemberInfo pkMemberInfo = classInfo.CreateMember(col.ColumnName, col.DataType, new KeyAttribute());
}
else
{
classInfo.CreateMember(col.ColumnName, col.DataType);
}
if (displayColumnNames != null)
{
if (filterColumnNamesAndValues.ContainsKey(col.ColumnName))
{
foundAnyFilterColumns = true;
}
else
{
displayColumnNames.Add(col.ColumnName);
}
}
}
return(foundAnyFilterColumns ? displayColumnNames : null);
}
else
{
bool addedPrimaryKeyCol = false;
List <string> notFoundFilterColumnNames = null;
if (!CollectionUtils.IsNullOrEmpty(filterColumnNamesAndValues))
{
notFoundFilterColumnNames = new List <string>(filterColumnNamesAndValues.Keys);
}
foreach (string colName in displayColumnNames)
{
DataColumn foundColumn = FindColumn(table, colName);
if (foundColumn == null)
{
throw new ArgException("The display column named \"{0}\" could not be found in the view \"{1}\"",
colName, table.TableName);
}
if (foundColumn == primaryKeyColumn)
{
XPCustomMemberInfo pkMemberInfo = classInfo.CreateMember(foundColumn.ColumnName, foundColumn.DataType, new KeyAttribute());
addedPrimaryKeyCol = true;
}
else
{
classInfo.CreateMember(foundColumn.ColumnName, foundColumn.DataType);
}
RemoveNameFromList(notFoundFilterColumnNames, foundColumn.ColumnName);
}
if (!addedPrimaryKeyCol)
{
classInfo.CreateMember(primaryKeyColumn.ColumnName, primaryKeyColumn.DataType, new KeyAttribute());
RemoveNameFromList(notFoundFilterColumnNames, primaryKeyColumn.ColumnName);
}
if (!CollectionUtils.IsNullOrEmpty(notFoundFilterColumnNames))
{
for (int i = notFoundFilterColumnNames.Count - 1; i >= 0; --i)
{
string colName = notFoundFilterColumnNames[i];
DataColumn foundColumn = FindColumn(table, colName);
if (foundColumn != null)
{
classInfo.CreateMember(foundColumn.ColumnName, foundColumn.DataType);
notFoundFilterColumnNames.RemoveAt(i);
}
}
}
return(displayColumnNames);
}
}
static void AddAttributes(IModelMemberEx modelMemberEx, XPCustomMemberInfo memberInfo) {
if (modelMemberEx.Size != 0)
memberInfo.AddAttribute(new SizeAttribute(modelMemberEx.Size));
if (modelMemberEx is IModelMemberNonPersistent && !(modelMemberEx is IModelMemberCalculated))
memberInfo.AddAttribute(new NonPersistentAttribute());
}
