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 ClassAtrributeGenerator(ClassGeneratorInfo classGeneratorInfo, string navigationPath) {
_persistentClassInfo = classGeneratorInfo.PersistentClassInfo;
_dbTable = classGeneratorInfo.DbTable;
_navigationPath = navigationPath;
_objectSpace = XPObjectSpace.FindObjectSpaceByObject(_persistentClassInfo);
}
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);
}
