public void Name_Is_Valid_Code_Identifier(WCTestData testData, IPersistentClassInfo persistentClassInfo) { persistentClassInfo.Name = "123"; Validator.RuleSet.StateOf <RuleValidCodeIdentifier>(persistentClassInfo, nameof(persistentClassInfo.Name)) .Should().Be(ValidationState.Invalid); }
public static IPersistentCoreTypeMemberInfo CreateSimpleMember(this IPersistentClassInfo classInfo, DBColumnType dataType, string name) { var memberInfo = classInfo.CreateMember <IPersistentCoreTypeMemberInfo>(name); memberInfo.DataType = dataType; return(memberInfo); }
public IPersistentMemberInfo Create(Column column, IPersistentClassInfo owner) { IPersistentMemberInfo persistentMemberInfo = null; if (IsCoumboundPKColumn(column)) { var structClassInfo = GetReferenceClassInfo(((Table)column.Parent).Name + TableMapper.KeyStruct); var structMemberInfo = CreateStructMemberInfo(column, structClassInfo, owner); if (structMemberInfo != null) { persistentMemberInfo = CreateComboundKeyMemberInfo(column, structClassInfo, owner); } } else { persistentMemberInfo = CreateMember(column, owner, TemplateType.XPReadWritePropertyMember); if (persistentMemberInfo != null) { AddAttributes(column, persistentMemberInfo); if (column.IsForeignKey) { _extraInfoBuilder.CreateExtraInfos(column, persistentMemberInfo, _foreignKeyCalculator); } } } return(persistentMemberInfo); }
public ClassAtrributeGenerator(ClassGeneratorInfo classGeneratorInfo, string navigationPath) { _persistentClassInfo = classGeneratorInfo.PersistentClassInfo; _dbTable = classGeneratorInfo.DbTable; _navigationPath = navigationPath; _objectSpace = XPObjectSpace.FindObjectSpaceByObject(_persistentClassInfo); }
Type GetInheritance(IPersistentClassInfo info) { if (info.Name.ToLower().IndexOf("customer") > -1) return typeof(CustomerBase); if (info.Name.ToLower().EndsWith("order")) return typeof(OrderBase); return typeof(OrderLineBase); }
public override void Update() { if (Session.FindObject <PersistentAssemblyInfo>(info => info.Name == DynamicAssemblyCalculatedField.AttributeRegistrator.MasterDetailDynamicAssembly) == null) { IPersistentAssemblyInfo persistentAssemblyInfo = new DynamicAssemblyBuilder(Session).Build(DynamicAssemblyCalculatedField.AttributeRegistrator.DMDCustomer, DMDOrder, DMDOrderLine, DynamicAssemblyCalculatedField.AttributeRegistrator.MasterDetailDynamicAssembly); IPersistentClassInfo persistentClassInfo = persistentAssemblyInfo.PersistentClassInfos.Single(info => info.Name == DynamicAssemblyCalculatedField.AttributeRegistrator.DMDCustomer); var persistentCoreTypeMemberInfo = new PersistentCoreTypeMemberInfo(persistentClassInfo.Session); persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInDetailViewAttribute(persistentCoreTypeMemberInfo.Session)); persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInListViewAttribute(persistentCoreTypeMemberInfo.Session)); persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInLookupListViewAttribute(persistentCoreTypeMemberInfo.Session)); persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentPersistentAliasAttribute(persistentCoreTypeMemberInfo.Session) { AliasExpression = "DMDOrders.Min(OrderDate)" }); persistentCoreTypeMemberInfo.Name = "FirstOrderDate"; persistentCoreTypeMemberInfo.DataType = DBColumnType.DateTime; var codeTemplateInfo = new CodeTemplateInfo(persistentCoreTypeMemberInfo.Session); var codeTemplate = new CodeTemplate(codeTemplateInfo.Session) { TemplateType = TemplateType.XPCalculatedPropertyMember }; codeTemplate.SetDefaults(); codeTemplate.Name = "CalculatedProperty"; codeTemplateInfo.TemplateInfo = codeTemplate; persistentCoreTypeMemberInfo.CodeTemplateInfo = codeTemplateInfo; persistentClassInfo.OwnMembers.Add(persistentCoreTypeMemberInfo); XPObjectSpace.FindObjectSpaceByObject(persistentClassInfo).CommitChanges(); } }
IPersistentMemberInfo CreateMember(Column column, IPersistentClassInfo owner, TemplateType templateType) { var columnName = column.Name; ForeignKey foreignKey = _foreignKeyCalculator.GetForeignKey(column); if (column.IsForeignKey && owner.CodeTemplateInfo.CodeTemplate.TemplateType != TemplateType.Struct && _foreignKeyCalculator.IsOneToOne(foreignKey, columnName)) { templateType = TemplateType.XPOneToOnePropertyMember; } else if (foreignKey != null && foreignKey.Columns.Count > 1) { columnName = foreignKey.ReferencedTable; } if (_objectSpace.FindObject <IPersistentMemberInfo>(info => info.Name == columnName && info.Owner == owner, PersistentCriteriaEvaluationBehavior.InTransaction) != null) { return(null); } if (!(column.IsForeignKey)) { return(CreatePersistentCoreTypeMemberInfo(column, owner, templateType)); } if (foreignKey != null) { IPersistentClassInfo referenceClassInfo = GetReferenceClassInfo(foreignKey.ReferencedTable); var persistentReferenceMemberInfo = CreatePersistentReferenceMemberInfo(columnName, owner, referenceClassInfo, templateType); return(persistentReferenceMemberInfo); } throw new NotImplementedException(column.Name + " " + ((Table)column.Parent).Name); }
private static void CreateMembers(IPersistentClassInfo info, Type type) { foreach (IPersistentMemberInfo mi in info.OwnMembers) { CreateMember(mi, type); } }
static void AddPersistentMemberInfo(IPersistentClassInfo classInfo, PropertyInfo propertyInfo, IInterfaceInfo interfaceInfo) { Type memberInfoType = GetMemberInfoType(propertyInfo.PropertyType); var persistentMemberInfo = ((IPersistentMemberInfo)memberInfoType.CreateInstance(classInfo.Session)); classInfo.OwnMembers.Add(persistentMemberInfo); persistentMemberInfo.SetDefaultTemplate(TemplateType.InterfaceReadWriteMember); persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode = persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode.Replace("$INTERFACENAME$", interfaceInfo.Name); persistentMemberInfo.Name = propertyInfo.Name; var info = persistentMemberInfo as IPersistentCoreTypeMemberInfo; if (info != null) { info.DataType = (DBColumnType)Enum.Parse(typeof(DBColumnType), propertyInfo.PropertyType.Name); } else { var memberInfo = persistentMemberInfo as IPersistentReferenceMemberInfo; if (memberInfo != null) { memberInfo.SetReferenceTypeFullName(propertyInfo.PropertyType.FullName); } } }
void addInterface(Type type1, IPersistentClassInfo persistentClassInfo1) { var t1InterfaceInfo = (IInterfaceInfo)_XPObjectSpace.CreateObject(typeof(InterfaceInfo)); t1InterfaceInfo.Name = type1.FullName; t1InterfaceInfo.Assembly = new AssemblyName(type1.Assembly.FullName + "").Name; persistentClassInfo1.Interfaces.Add(t1InterfaceInfo); }
void IClassInfoHandler.CreateCollectionMember(IPersistentClassInfo persistentClassInfo, string name, IPersistentClassInfo refenceClassInfo, string associationName) { var persistentCollectionMemberInfo = createPersistentAssociatedMemberInfo <IPersistentCollectionMemberInfo>(name, persistentClassInfo, WCTypesInfo.Instance.FindBussinessObjectType <IPersistentCollectionMemberInfo>(), associationName, TemplateType.XPCollectionMember, true); persistentCollectionMemberInfo.SetCollectionTypeFullName(refenceClassInfo.PersistentAssemblyInfo.Name + "." + refenceClassInfo.Name); }
public static XPClassInfo AddClass(this XPDictionary xpDictionary, IPersistentClassInfo info) { var builder = PersistentClassTypeBuilder.BuildClass(); XPClassInfo xpClassInfo = CreateClass(xpDictionary, info, builder); CreateMembers(info, xpClassInfo.ClassType); return(xpClassInfo); }
private static T CreateMember <T>(this IPersistentClassInfo classInfo, string name) where T : IPersistentMemberInfo { var memberInfo = (T)Activator.CreateInstance(XafTypesInfo.Instance.FindBussinessObjectType <T>(), classInfo.Session); memberInfo.Name = name; classInfo.OwnMembers.Add(memberInfo); memberInfo.SetDefaultTemplate(TemplateType.XPReadWritePropertyMember); return(memberInfo); }
List<ITemplateInfo> GetOrderTemplateInfo(IPersistentClassInfo info, string customer) { string code = @"protected override void SetCustomer(" + typeof(ICustomer).FullName + @" customer){ " + customer + @" = (" + customer + @")customer; } protected override " + typeof(ICustomer).FullName + @" GetCustomer() { return " + customer + @"; }"; return new List<ITemplateInfo> { new TemplateInfo(info.Session) { TemplateCode = code } }; }
public void Non_Compilable_Code(WCTestData testData, IPersistentClassInfo persistentClassInfo) { persistentClassInfo.CodeTemplateInfo.TemplateInfo.TemplateCode = "invalid"; var result = persistentClassInfo.PersistentAssemblyInfo.Validate(AssemblyPath); result.Valid.Should().Be(false); result.Message.Should().Contain("A namespace cannot directly contain members such as fields or methods"); }
IPersistentMemberInfo CreateStructMemberInfo(Column column, IPersistentClassInfo structClassInfo, IPersistentClassInfo owner) { IPersistentMemberInfo structMemberInfo = CreateMember(column, structClassInfo, TemplateType.ReadWriteMember); if (structMemberInfo != null) { AddAttributes(column, structMemberInfo); if (column.IsForeignKey) _extraInfoBuilder.CreateCollection((IPersistentReferenceMemberInfo)structMemberInfo, owner); } return structMemberInfo; }
public void Assembly_Should_Validate_if_file_not_exists(IWCTestData testData, IPersistentClassInfo persistentClassInfo, IAssemblyManager assemblyManager) { persistentClassInfo.PersistentAssemblyInfo.Name += Guid.NewGuid().ToString("N"); var persistentAssemblyInfos = assemblyManager.ValidateAssemblyInfos(); persistentAssemblyInfos.Length.Should().Be(1); }
IEnumerable<IPersistentClassInfo> GetReferenceMembers(IPersistentClassInfo classInfo, string customer, string order, string orderLine) { if (classInfo.Name == order) { return new List<IPersistentClassInfo> { classInfo.PersistentAssemblyInfo.PersistentClassInfos.Where(info => info.Name == customer).Single() }; } if (classInfo.Name == orderLine) { return new List<IPersistentClassInfo> { classInfo.PersistentAssemblyInfo.PersistentClassInfos.Where(info => info.Name == order).Single() }; } return new List<IPersistentClassInfo>(); }
IPersistentReferenceMemberInfo IClassInfoHandler.CreateRefenenceMember(IPersistentClassInfo persistentClassInfo, string name, IPersistentClassInfo referenceClassInfo, bool createAssociation) { var persistentReferenceMemberInfo = createPersistentAssociatedMemberInfo <IPersistentReferenceMemberInfo>(name, persistentClassInfo, WCTypesInfo.Instance.FindBussinessObjectType <IPersistentReferenceMemberInfo>(), TemplateType.XPReadWritePropertyMember, createAssociation); persistentReferenceMemberInfo.SetReferenceTypeFullName(persistentClassInfo.PersistentAssemblyInfo.Name + "." + referenceClassInfo.Name); return(persistentReferenceMemberInfo); }
public void Assembly_Should_not_be_Validated_if_already_loaded(IWCTestData testData, IPersistentClassInfo persistentClassInfo, IAssemblyManager assemblyManager) { persistentClassInfo.PersistentAssemblyInfo.Name += Guid.NewGuid().ToString("n"); (assemblyManager.LoadAssemblies().ToArray().FirstOrDefault() != null).Should().BeTrue(); var loadAssemblies = assemblyManager.LoadAssemblies(); loadAssemblies.Count.Should().Be(0); }
IPersistentMemberInfo CreateComboundKeyMemberInfo(Column column, IPersistentClassInfo structClassInfo, IPersistentClassInfo owner) { IPersistentMemberInfo persistentMemberInfo; if (owner.OwnMembers.Where(info => info.Name == structClassInfo.Name).FirstOrDefault() == null) { var persistentReferenceMemberInfo = CreatePersistentReferenceMemberInfo(structClassInfo.Name, owner, structClassInfo, TemplateType.FieldMember); AddAttributes(column, persistentReferenceMemberInfo); persistentMemberInfo = persistentReferenceMemberInfo; } else persistentMemberInfo = null; return persistentMemberInfo; }
private static XPClassInfo CreateClass(XPDictionary xpDictionary, IPersistentClassInfo info, IClassAssemblyNameBuilder builder) { XPClassInfo result = xpDictionary.QueryClassInfo(info.AssemblyName, info.Name); if (result == null){ var type = builder.WithAssemblyName(info.AssemblyName).Define(info); result = new ReflectionClassInfo(type, xpDictionary); CreateAttributes(result, info); } return result; }
IEnumerable<MemberGeneratorInfo> CreateMembersCore(IEnumerable<DBColumn> dbColumns, IPersistentClassInfo persistentClassInfo = null, TemplateType coreTemplateType = TemplateType.XPReadWritePropertyMember, TemplateType refTemplateType = TemplateType.XPReadWritePropertyMember) { return dbColumns.SelectMany(dbColumn => { var memberGeneratorInfos = new List<MemberGeneratorInfo>(); if (IsOneToOneOnTheKey(dbColumn) && coreTemplateType != TemplateType.ReadWriteMember) { memberGeneratorInfos.Add(CreateFkMember(dbColumn, persistentClassInfo, coreTemplateType, TemplateType.XPOneToOneReadOnlyPropertyMember)); } memberGeneratorInfos.Add(CreateMember(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType)); return memberGeneratorInfos; }).Where(info => info.PersistentMemberInfo != null); }
public static void SetTypeValue(this IPersistentTypeInfo persistentTypeInfo, ref IPersistentClassInfo persistentClassInfo, ref Type type, string typeFullName) { var session = persistentTypeInfo.Session; if (!string.IsNullOrEmpty(typeFullName)){ IPersistentClassInfo classInfo = PersistentClassInfoQuery.Find(session, typeFullName); if (classInfo != null) persistentClassInfo = classInfo; else type = ReflectionHelper.GetType(typeFullName.Substring(typeFullName.LastIndexOf(".") + 1)); } }
List<ITemplateInfo> GetTemplateInfos(IPersistentClassInfo info, string customer, string order) { if (info.Name.ToLower().EndsWith("order")) { return GetOrderTemplateInfo(info, customer); } if (info.Name.ToLower().EndsWith("orderline")) { return GetOrderLineTemplateInfo(info, order); } return new List<ITemplateInfo>(); }
public void Missing_Key_Property(WCTestData testData, IPersistentClassInfo persistentClassInfo) { persistentClassInfo.BaseType = typeof(XPBaseObject); var result = persistentClassInfo.PersistentAssemblyInfo.Validate(AssemblyPath); result.Valid.Should().BeFalse(); result.Message.Should().Contain(typeof(KeyPropertyAbsentException).Name); }
public static IPersistentClassInfo Find(Session session, string referenceTypeFullName) { const IPersistentClassInfo persistentClassInfo = null; string propertyName = persistentClassInfo.GetPropertyName(x => x.PersistentAssemblyInfo) + "." + persistentClassInfo.GetPropertyName(x => x.PersistentAssemblyInfo.Name); var binaryOperator = new BinaryOperator(propertyName, referenceTypeFullName.Substring(0, referenceTypeFullName.IndexOf("."))); var operands = new BinaryOperator(persistentClassInfo.GetPropertyName(x => x.Name), referenceTypeFullName.Substring(referenceTypeFullName.IndexOf(".") + 1)); return(session.FindObject(PersistentCriteriaEvaluationBehavior.InTransaction, WCTypesInfo.Instance.FindBussinessObjectType <IPersistentClassInfo>(), new GroupOperator(binaryOperator, operands)) as IPersistentClassInfo); }
public void CreateCollection(IPersistentReferenceMemberInfo persistentReferenceMemberInfo, IPersistentClassInfo owner) { var persistentCollectionMemberInfo = _objectSpace.CreateWCObject<IPersistentCollectionMemberInfo>(); persistentReferenceMemberInfo.ReferenceClassInfo.OwnMembers.Add(persistentCollectionMemberInfo); persistentCollectionMemberInfo.Name = persistentReferenceMemberInfo.Owner.Name + persistentReferenceMemberInfo.Name + "s"; persistentCollectionMemberInfo.Owner = persistentReferenceMemberInfo.ReferenceClassInfo; persistentCollectionMemberInfo.CollectionClassInfo = owner; persistentCollectionMemberInfo.SetDefaultTemplate(TemplateType.XPCollectionMember); var persistentAssociationAttribute = _objectSpace.CreateWCObject<IPersistentAssociationAttribute>(); persistentCollectionMemberInfo.TypeAttributes.Add(persistentAssociationAttribute); persistentAssociationAttribute.AssociationName = persistentReferenceMemberInfo.TypeAttributes.OfType<IPersistentAssociationAttribute>().Single().AssociationName; }
public void Assembly_Should_not_Validate_if_version_equal_to_file_version(IWCTestData testData, IPersistentClassInfo persistentClassInfo, IAssemblyManager assemblyManager) { persistentClassInfo.PersistentAssemblyInfo.Revision++; persistentClassInfo.PersistentAssemblyInfo.Name += Guid.NewGuid().ToString("n"); assemblyManager.LoadAssemblies(); var validAssemblyInfos = assemblyManager.ValidateAssemblyInfos(); validAssemblyInfos.Length.Should().Be(0); }
Type GetInheritance(IPersistentClassInfo info) { if (info.Name.ToLower().IndexOf("customer", StringComparison.Ordinal) > -1) { return(typeof(CustomerBase)); } if (info.Name.ToLower().EndsWith("order")) { return(typeof(OrderBase)); } return(typeof(OrderLineBase)); }
List <ITemplateInfo> GetTemplateInfos(IPersistentClassInfo info, string customer, string order) { if (info.Name.ToLower().EndsWith("order")) { return(GetOrderTemplateInfo(info, customer)); } if (info.Name.ToLower().EndsWith("orderline")) { return(GetOrderLineTemplateInfo(info, order)); } return(new List <ITemplateInfo>()); }
public void CreateExtraInfos(Table table, IPersistentClassInfo persistentClassInfo, IMapperInfo mapperInfo) { var persistentAttributeInfos = _attributeMapper.Create(table, persistentClassInfo, mapperInfo); foreach (var persistentAttributeInfo in persistentAttributeInfos) { persistentClassInfo.TypeAttributes.Add(persistentAttributeInfo); } var count = table.Columns.OfType<Column>().Where(column => column.InPrimaryKey).Count(); if (count > 0) { var templateInfo = (ITemplateInfo) _objectSpace.CreateObject(WCTypesInfo.Instance.FindBussinessObjectType(typeof (ITemplateInfo))); templateInfo.Name = SupportPersistentObjectsAsAPartOfACompositeKey; persistentClassInfo.TemplateInfos.Add(templateInfo); } }
void createTheManyPart(IPersistentReferenceMemberInfo persistentReferenceMemberInfo) { IPersistentClassInfo classInfo = PersistentClassInfoQuery.Find(((XPObjectSpace)ObjectSpace).Session, persistentReferenceMemberInfo.ReferenceTypeFullName); string collectionPropertyName = persistentReferenceMemberInfo.Name + "s"; if (classInfo != null && classInfo.OwnMembers.FirstOrDefault(info => info.Name == collectionPropertyName) == null) { var associationAttribute = PersistentAttributeInfoQuery.Find <AssociationAttribute>(persistentReferenceMemberInfo); classInfo.CreateCollection(persistentReferenceMemberInfo.Owner.PersistentAssemblyInfo.Name, persistentReferenceMemberInfo.Owner.Name).CreateAssociation(associationAttribute.Name); } }
private static XPClassInfo CreateClass(XPDictionary xpDictionary, IPersistentClassInfo info, IClassAssemblyNameBuilder builder) { XPClassInfo result = xpDictionary.QueryClassInfo(info.AssemblyName, info.Name); if (result == null) { var type = builder.WithAssemblyName(info.AssemblyName).Define(info); result = new ReflectionClassInfo(type, xpDictionary); CreateAttributes(result, info); } return(result); }
public static IPersistentMemberInfo CreateCollection(this IPersistentClassInfo classInfo, string assemblyName, string classInfoName) { var collectionMemberInfo = XPObjectSpace.FindObjectSpaceByObject(classInfo).CreateWCObject <IPersistentCollectionMemberInfo>(); collectionMemberInfo.Owner = classInfo; collectionMemberInfo.Name = classInfoName + "s"; collectionMemberInfo.SetCollectionTypeFullName(assemblyName + "." + classInfoName); collectionMemberInfo.Init(WCTypesInfo.Instance.FindBussinessObjectType <ICodeTemplate>()); collectionMemberInfo.CodeTemplateInfo.CloneProperties(); classInfo.OwnMembers.Add(collectionMemberInfo); return(collectionMemberInfo); }
private void MergeTypes(Func <Type, IObjectSpace> queryObjectSpace, XPClassInfo mergeToClassInfo, XPClassInfo mergeFromClassInfo, IPersistentClassInfo persistentClassInfo) { using (var updatingObjectSpace = queryObjectSpace(mergeToClassInfo.ClassType)){ var session = updatingObjectSpace.Session(); session.UpdateSchema(mergeFromClassInfo.ClassType, mergeToClassInfo.ClassType); if (ObjectType(session, mergeFromClassInfo, mergeToClassInfo) > 0) { persistentClassInfo.MergedObjectFullName = null; } } }
static string GetAllMembersCode(IPersistentClassInfo persistentClassInfo, string code) { string allMemberGeneratedCode = GetMembersCode(persistentClassInfo.OwnMembers); int anchorsFound = 0; for (int i = code.Length - 1; i > -1; i--) { if (code[i] == '}' && anchorsFound < 2) anchorsFound++; if (anchorsFound == 2) { code = code.Substring(0, i) + allMemberGeneratedCode + code.Substring(i); break; } } return code; }
public void Aclass(IWCTestData testData, Compiler compiler, IPersistentClassInfo persistentClassInfo) { var code = persistentClassInfo.GenerateCode(); var compilerResult = compiler.Compile(code, persistentClassInfo.Name); var moduleDefinition = compilerResult.AssemblyDefinition.MainModule; moduleDefinition.Types.Any(definition => definition.Name == persistentClassInfo.Name) .Should() .BeTrue(); }
IPersistentMemberInfo CreateStructMemberInfo(Column column, IPersistentClassInfo structClassInfo, IPersistentClassInfo owner) { IPersistentMemberInfo structMemberInfo = CreateMember(column, structClassInfo, TemplateType.ReadWriteMember); if (structMemberInfo != null) { AddAttributes(column, structMemberInfo); if (column.IsForeignKey) { _extraInfoBuilder.CreateCollection((IPersistentReferenceMemberInfo)structMemberInfo, owner); } } return(structMemberInfo); }
public void Validation_Failure_after_Succeful_Validation(WCTestData testData, IPersistentClassInfo persistentClassInfo) { var result = persistentClassInfo.PersistentAssemblyInfo.Validate(AssemblyPath); result.Valid.Should().BeTrue(); persistentClassInfo.BaseType = null; var assembliesLenght = AppDomain.CurrentDomain.GetAssemblies().Length; result = persistentClassInfo.PersistentAssemblyInfo.Validate(AssemblyPath); result.Valid.Should().BeFalse(); result.Message.Should().Contain("Type expected"); AppDomain.CurrentDomain.GetAssemblies().Length.Should().Be(assembliesLenght); }
public static void CreateMembersFromInterfaces(this IPersistentClassInfo classInfo) { foreach (IInterfaceInfo interfaceInfo in classInfo.Interfaces) { foreach (PropertyInfo propertyInfo in interfaceInfo.Type.GetProperties()) { PropertyInfo info1 = propertyInfo; bool propertyNotExists = classInfo.OwnMembers.FirstOrDefault(info => info.Name == info1.Name) == null; if (propertyNotExists) { AddPersistentMemberInfo(classInfo, propertyInfo, interfaceInfo); } } } }
public static string GenerateCode(IPersistentClassInfo persistentClassInfo) { if (persistentClassInfo.CodeTemplateInfo.TemplateInfo != null) { string code = persistentClassInfo.CodeTemplateInfo.TemplateInfo.TemplateCode; string attributesCode = GetAttributesCode(persistentClassInfo); if (code != null) { code = code.Replace("$ASSEMBLYNAME$", persistentClassInfo.PersistentAssemblyInfo.Name); code = code.Replace("$TYPEATTRIBUTES$", attributesCode); code = code.Replace("$CLASSNAME$", persistentClassInfo.Name); code = code.Replace("$BASECLASSNAME$", getBaseType(persistentClassInfo) + getInterfacesCode(persistentClassInfo)); code = GetAllMembersCode(persistentClassInfo, code); return code; } } return null; }
MemberGeneratorInfo CreateFkMember(DBColumn dbColumn, IPersistentClassInfo persistentClassInfo, TemplateType coreTemplateType, TemplateType refTemplateType) { var foreignKey = _dbTable.ForeignKeys.Where(key => key.Columns.Contains(dbColumn.Name)).First(key => !Equals(key.PrimaryKeyTable, "XPObjectType")); var tableName = ClassGenerator.GetTableName(foreignKey.PrimaryKeyTable); if (_classInfos.ContainsKey(tableName)) { var classGeneratorInfo = _classInfos[tableName]; return(new MemberGeneratorInfo(CreatePersistentReferenceMemberInfo(dbColumn.Name, persistentClassInfo, classGeneratorInfo.PersistentClassInfo, GetTemplateType(refTemplateType, classGeneratorInfo)), dbColumn)); } return(new MemberGeneratorInfo(CreatePersistentCoreTypeMemberInfo(dbColumn, persistentClassInfo, coreTemplateType), dbColumn)); }
static void AddPersistentMemberInfo(IPersistentClassInfo classInfo, PropertyInfo propertyInfo, IInterfaceInfo interfaceInfo) { Type memberInfoType = GetMemberInfoType(propertyInfo.PropertyType); var persistentMemberInfo = ((IPersistentMemberInfo)Activator.CreateInstance(memberInfoType, classInfo.Session)); classInfo.OwnMembers.Add(persistentMemberInfo); persistentMemberInfo.SetDefaultTemplate(TemplateType.InterfaceReadWriteMember); persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode = persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode.Replace("$INTERFACENAME$",interfaceInfo.Name); persistentMemberInfo.Name = propertyInfo.Name; if (persistentMemberInfo is IPersistentCoreTypeMemberInfo) ((IPersistentCoreTypeMemberInfo) persistentMemberInfo).DataType = (XPODataType) Enum.Parse(typeof (XPODataType), propertyInfo.PropertyType.Name); else if (persistentMemberInfo is IPersistentReferenceMemberInfo) ((IPersistentReferenceMemberInfo) persistentMemberInfo).ReferenceTypeFullName = propertyInfo.PropertyType.FullName; }
public IPersistentMemberInfo Create(Column column, IPersistentClassInfo owner) { IPersistentMemberInfo persistentMemberInfo = null; if (IsCoumboundPKColumn(column)) { var structClassInfo = GetReferenceClassInfo(((Table)column.Parent).Name + TableMapper.KeyStruct); var structMemberInfo = CreateStructMemberInfo(column, structClassInfo, owner); if (structMemberInfo != null) persistentMemberInfo = CreateComboundKeyMemberInfo(column, structClassInfo, owner); } else { persistentMemberInfo = CreateMember(column, owner, TemplateType.XPReadWritePropertyMember); if (persistentMemberInfo != null) { AddAttributes(column, persistentMemberInfo); if (column.IsForeignKey) { _extraInfoBuilder.CreateExtraInfos(column, persistentMemberInfo, _foreignKeyCalculator); } } } return persistentMemberInfo; }
static void AddPersistentMemberInfo(IPersistentClassInfo classInfo, PropertyInfo propertyInfo, IInterfaceInfo interfaceInfo) { Type memberInfoType = GetMemberInfoType(propertyInfo.PropertyType); var persistentMemberInfo = ((IPersistentMemberInfo)memberInfoType.CreateInstance(classInfo.Session)); classInfo.OwnMembers.Add(persistentMemberInfo); persistentMemberInfo.SetDefaultTemplate(TemplateType.InterfaceReadWriteMember); persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode = persistentMemberInfo.CodeTemplateInfo.TemplateInfo.TemplateCode.Replace("$INTERFACENAME$", interfaceInfo.Name); persistentMemberInfo.Name = propertyInfo.Name; var info = persistentMemberInfo as IPersistentCoreTypeMemberInfo; if (info != null) info.DataType = (DBColumnType)Enum.Parse(typeof(DBColumnType), propertyInfo.PropertyType.Name); else { var memberInfo = persistentMemberInfo as IPersistentReferenceMemberInfo; if (memberInfo != null) memberInfo.SetReferenceTypeFullName(propertyInfo.PropertyType.FullName); } }
IPersistentMemberInfo CreateMember(Column column, IPersistentClassInfo owner, TemplateType templateType) { var columnName = column.Name; ForeignKey foreignKey = _foreignKeyCalculator.GetForeignKey(column); if (column.IsForeignKey && owner.CodeTemplateInfo.CodeTemplate.TemplateType != TemplateType.Struct && _foreignKeyCalculator.IsOneToOne(foreignKey, columnName)) templateType = TemplateType.XPOneToOnePropertyMember; else if (foreignKey != null && foreignKey.Columns.Count > 1) { columnName = foreignKey.ReferencedTable; } if (_objectSpace.FindObject<IPersistentMemberInfo>(info => info.Name == columnName && info.Owner == owner, PersistentCriteriaEvaluationBehavior.InTransaction) != null) return null; if (!(column.IsForeignKey)) { return CreatePersistentCoreTypeMemberInfo(column, owner, templateType); } if (foreignKey != null) { IPersistentClassInfo referenceClassInfo = GetReferenceClassInfo(foreignKey.ReferencedTable); var persistentReferenceMemberInfo = CreatePersistentReferenceMemberInfo(columnName, owner, referenceClassInfo, templateType); return persistentReferenceMemberInfo; } throw new NotImplementedException(column.Name + " " + ((Table)column.Parent).Name); }
IPersistentReferenceMemberInfo CreatePersistentReferenceMemberInfo(string name, IPersistentClassInfo owner, IPersistentClassInfo referenceClassInfo, TemplateType templateType) { var persistentReferenceMemberInfo = _objectSpace.CreateWCObject<IPersistentReferenceMemberInfo>(); persistentReferenceMemberInfo.Name = name; persistentReferenceMemberInfo.ReferenceClassInfo = referenceClassInfo; owner.OwnMembers.Add(persistentReferenceMemberInfo); persistentReferenceMemberInfo.SetDefaultTemplate(templateType); return persistentReferenceMemberInfo; }
IPersistentCoreTypeMemberInfo CreatePersistentCoreTypeMemberInfo(Column column, IPersistentClassInfo owner, TemplateType templateType) { var persistentCoreTypeMemberInfo = _objectSpace.CreateWCObject<IPersistentCoreTypeMemberInfo>(); persistentCoreTypeMemberInfo.Name = column.Name; persistentCoreTypeMemberInfo.DataType = _dataTypeMapper.GetDataType(column); owner.OwnMembers.Add(persistentCoreTypeMemberInfo); persistentCoreTypeMemberInfo.SetDefaultTemplate(templateType); return persistentCoreTypeMemberInfo; }
IPersistentCoreTypeMemberInfo CreatePersistentCoreTypeMemberInfo(DBColumn column, IPersistentClassInfo persistentClassInfo, TemplateType templateType) { var persistentCoreTypeMemberInfo = _objectSpace.CreateWCObject<IPersistentCoreTypeMemberInfo>(); persistentCoreTypeMemberInfo.Name = column.Name; persistentCoreTypeMemberInfo.DataType = column.ColumnType; if (persistentClassInfo == null) { var tableName = ClassGenerator.GetTableName(_dbTable.Name); persistentClassInfo = _classInfos[tableName].PersistentClassInfo; } persistentClassInfo.OwnMembers.Add(persistentCoreTypeMemberInfo); persistentCoreTypeMemberInfo.SetDefaultTemplate(templateType); return persistentCoreTypeMemberInfo; }
public TypeInfo(Type type, IPersistentClassInfo persistentClassInfo) { _type = type; _persistentClassInfo = persistentClassInfo; }
static string getBaseType(IPersistentClassInfo persistentClassInfo) { return persistentClassInfo.BaseTypeFullName??persistentClassInfo.GetDefaultBaseClass().FullName; }
static string GetInterfacesCode(IPersistentClassInfo persistentClassInfo) { return persistentClassInfo.Interfaces.Aggregate<IInterfaceInfo, string>(null, (current, interfaceInfo) => current + ("," + interfaceInfo.Type.FullName)); }
MemberGeneratorInfo CreateFkMember(DBColumn dbColumn, IPersistentClassInfo persistentClassInfo, TemplateType coreTemplateType, TemplateType refTemplateType) { var foreignKey = _dbTable.ForeignKeys.Where(key => key.Columns.Contains(dbColumn.Name)).First(key => !Equals(key.PrimaryKeyTable, "XPObjectType")); var tableName = ClassGenerator.GetTableName(foreignKey.PrimaryKeyTable); if (_classInfos.ContainsKey(tableName)) { var classGeneratorInfo = _classInfos[tableName]; return new MemberGeneratorInfo(CreatePersistentReferenceMemberInfo(dbColumn.Name, persistentClassInfo, classGeneratorInfo.PersistentClassInfo, GetTemplateType(refTemplateType, classGeneratorInfo)), dbColumn); } return new MemberGeneratorInfo(CreatePersistentCoreTypeMemberInfo(dbColumn, persistentClassInfo, coreTemplateType), dbColumn); }
MemberGeneratorInfo CreateMemberCore(DBColumn dbColumn, IPersistentClassInfo persistentClassInfo, TemplateType coreTemplateType, TemplateType refTemplateType) { bool isPrimaryKey = IsPrimaryKey(dbColumn); bool isFkColumn = IsFKey(dbColumn); var isOneToOneOnTheKey = IsOneToOneOnTheKey(dbColumn); var b = ((!isFkColumn) && (IsCoreColumn(dbColumn) || isPrimaryKey)) || (isOneToOneOnTheKey); if (b || IsSelfRefOnTheKey(dbColumn, isPrimaryKey)) { return new MemberGeneratorInfo(CreatePersistentCoreTypeMemberInfo(dbColumn, persistentClassInfo, coreTemplateType), dbColumn); } if (isFkColumn) { return CreateFkMember(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType); } throw new NotImplementedException(dbColumn.Name); }
void CreateCollection(IPersistentReferenceMemberInfo persistentReferenceMemberInfo, IPersistentClassInfo owner) { var persistentCollectionMemberInfo = _objectSpace.CreateWCObject<IPersistentCollectionMemberInfo>(); persistentReferenceMemberInfo.ReferenceClassInfo.OwnMembers.Add(persistentCollectionMemberInfo); persistentCollectionMemberInfo.Name = persistentReferenceMemberInfo.Owner.Name + persistentReferenceMemberInfo.Name + "s"; persistentCollectionMemberInfo.Owner = persistentReferenceMemberInfo.ReferenceClassInfo; var tableName = ClassGenerator.GetTableName(Regex.Replace(owner.Name, ClassGenerator.KeyStruct, "", RegexOptions.Singleline | RegexOptions.IgnoreCase)); persistentCollectionMemberInfo.CollectionClassInfo = owner.CodeTemplateInfo.CodeTemplate.TemplateType == TemplateType.Struct ? _classInfos[tableName].PersistentClassInfo : owner; persistentCollectionMemberInfo.SetDefaultTemplate(TemplateType.XPCollectionMember); var persistentAssociationAttribute = _objectSpace.CreateWCObject<IPersistentAssociationAttribute>(); persistentCollectionMemberInfo.TypeAttributes.Add(persistentAssociationAttribute); persistentAssociationAttribute.AssociationName = String.Format("{0}-{1}s", persistentReferenceMemberInfo.Name, persistentCollectionMemberInfo.Name); }
IPersistentMemberInfo CreatePersistentReferenceMemberInfo(string name, IPersistentClassInfo persistentClassInfo, IPersistentClassInfo persistentReferenceClassInfo, TemplateType templateType) { var persistentReferenceMemberInfo = _objectSpace.CreateWCObject<IPersistentReferenceMemberInfo>(); persistentReferenceMemberInfo.Name = name; persistentReferenceMemberInfo.ReferenceClassInfo = persistentReferenceClassInfo; if (persistentClassInfo == null) persistentClassInfo = _classInfos[ClassGenerator.GetTableName(_dbTable.Name)].PersistentClassInfo; persistentClassInfo.OwnMembers.Add(persistentReferenceMemberInfo); persistentReferenceMemberInfo.SetDefaultTemplate(templateType); if (templateType != TemplateType.XPOneToOnePropertyMember && templateType != TemplateType.XPOneToOneReadOnlyPropertyMember && persistentClassInfo.CodeTemplateInfo.CodeTemplate.TemplateType == TemplateType.Class && persistentReferenceClassInfo.CodeTemplateInfo.CodeTemplate.TemplateType == TemplateType.Class) CreateCollection(persistentReferenceMemberInfo, persistentClassInfo); return persistentReferenceMemberInfo; }
public ClassGeneratorInfo(IPersistentClassInfo persistentClassInfo, DBTable dbTable) : this() { _persistentClassInfo = persistentClassInfo; _dbTable = dbTable; }
MemberGeneratorInfo CreateMember(DBColumn dbColumn, IPersistentClassInfo persistentClassInfo = null, TemplateType coreTemplateType = TemplateType.XPReadWritePropertyMember, TemplateType refTemplateType = TemplateType.XPReadWritePropertyMember) { return CreateMemberCore(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType); }