private IPropDef CreatePrimaryKeyProp()
        {
            var      propertyName = PropNamingConvention.GetIDPropertyName(_classType);
            IPropDef propDef      = new PropDef(propertyName, typeof(Guid), PropReadWriteRule.WriteNew, null);

            this.ClassDef.PropDefcol.Add(propDef);
            return(propDef);
        }
Example #2
0
        private bool FKFoundOnRelatedClass()
        {
            var reverseRelName    = this.PropertyWrapper.GetSingleReverseRelationshipName <AutoMapOneToOneAttribute>();
            var relatedClassType  = this.PropertyWrapper.RelatedClassType;
            var relatedFKPropName = PropNamingConvention.GetSingleRelOwningPropName(reverseRelName);

            return(relatedClassType.HasProperty(relatedFKPropName));
        }
Example #3
0
        // ReSharper restore ConditionIsAlwaysTrueOrFalse

        private bool FKFoundOnOwnerClass()
        {
            var ownerClassType   = this.PropertyWrapper.DeclaringType;
            var relationshipName = this.PropertyWrapper.Name;
            var owningFKPropName = PropNamingConvention.GetSingleRelOwningPropName(relationshipName);

            return(ownerClassType.HasProperty(owningFKPropName));
        }
Example #4
0
 /// <summary>
 /// Returns the Related Property name.
 /// </summary>
 /// <returns></returns>
 public string GetRelatedPropName()
 {
     if (this.PropertyWrapper.HasSingleReverseRelationship)
     {
         PropertyWrapper reverseRelPropInfo = this.PropertyWrapper.GetSingleReverseRelPropInfos()[0];
         return(PropNamingConvention.GetSingleRelOwningPropName(reverseRelPropInfo.Name));
     }
     return(GetOwningPropName(this.PropertyWrapper.DeclaringType));
 }
        private void CreateForeignKeyProp(IRelationshipDef relationshipDef)
        {
            var relationshipName = relationshipDef.RelationshipName;
            var propertyName     = PropNamingConvention.GetSingleRelOwningPropName(relationshipName);
            var propDef          = new PropDef(propertyName, typeof(Guid?), PropReadWriteRule.ReadWrite, null)
            {
                Compulsory = relationshipDef.IsCompulsory
            };

            SetDatabaseFieldName(propDef, relationshipName);
            this.ClassDef.PropDefcol.Add(propDef);
        }
        ///<summary>
        /// Returns the PKPropName that will be used for the underlying type.
        /// The PKPropName will either be determined by attributes or by
        /// convention e.g. ClassNameID.
        ///</summary>
        ///<returns></returns>
        public virtual string GetPKPropName()
        {
            if (!this.IsBaseTypeBusinessObject && this.HasBaseType && !this.BaseType.IsGenericType)
            {
                return(this.BaseType.GetPKPropName());
            }

            var propName = GetPKPropNameFromClassDef();

            if (!string.IsNullOrEmpty(propName))
            {
                return(propName);
            }
            propName = this.GetPKPropNameFromAttribute();
            return(propName ?? PropNamingConvention.GetIDPropertyName(this));
        }
Example #7
0
 private string GetOwningPropName()
 {
     return(PropNamingConvention.GetSingleRelOwningPropName(this.PropertyWrapper.Name));
 }
Example #8
0
 private static string GetFkPropName(string relationshipName)
 {
     return(PropNamingConvention.GetSingleRelOwningPropName(relationshipName));
 }