public static string ManyToOnePropertyName(string fullAssemblyQualTypeName, string[] fkColumnNames)
{
var fkPropertyType = new NfTypeName(fullAssemblyQualTypeName);
var fkPropertyName = fkPropertyType.ClassName;
fkColumnNames = fkColumnNames.Select(x => Util.Etc.CapitalizeFirstLetterOfWholeWords(Util.Etc.ExtractLastWholeWord(x, '.'), null)).ToArray();
return string.Format("{0}By{1}", fkPropertyName,
string.Join("And", fkColumnNames));
}
public static string ClassName(string name, string outputNamespace)
{
var asmQualifiedName = new StringBuilder();
if (name.Split(Constants.DEFAULT_TYPE_SEPARATOR).Length > 1)
{
var nameParts = name.Split(Constants.DEFAULT_TYPE_SEPARATOR);
var actualClassName = nameParts[(nameParts.Length - 1)].Replace(" ",Globals.REPLACE_SPACE_WITH_SEQUENCE);
nameParts[(nameParts.Length - 1)] = NfTypeName.SafeDotNetTypeName(actualClassName);
name = string.Join(Constants.DEFAULT_TYPE_SEPARATOR.ToString(CultureInfo.InvariantCulture), nameParts);
}
//remove any chars not allowed in C# ids
name = NfTypeName.SafeDotNetTypeName(name);
//capitalize first letter of whole word to avoid conflict with C# reserved words
name = Etc.CapitalizeFirstLetterOfWholeWords(name, Constants.DEFAULT_TYPE_SEPARATOR);
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
outputNamespace = Etc.CapitalizeFirstLetterOfWholeWords(outputNamespace, Constants.DEFAULT_TYPE_SEPARATOR);
asmQualifiedName.AppendFormat("{0}{1}", outputNamespace,Constants.DEFAULT_TYPE_SEPARATOR);
}
asmQualifiedName.Append(name);
if (!String.IsNullOrWhiteSpace(outputNamespace))
asmQualifiedName.AppendFormat(", {0}", NfTypeName.DraftCscExeAsmName(outputNamespace));
var typeName = new NfTypeName(asmQualifiedName.ToString());
if (!String.IsNullOrWhiteSpace(outputNamespace))
return typeName.AssemblyQualifiedName;
return typeName.FullName;
}
/// <summary>
/// Converts the .NET type into the custom Code Gen type
/// </summary>
/// <param name="asmType"></param>
/// <param name="valueTypeOnly">
/// Will only export Fields and Properties whose base type extends System.ValueType
/// </param>
/// <param name="resolveDependencies">
/// Switch to have the IL of the type parsed and all dependent calls Metadata tokens added.
/// </param>
/// <returns></returns>
public static CgType GetCgOfType(this Type asmType, bool valueTypeOnly, bool resolveDependencies = false)
{
var cgType = new CgType();
if (asmType == null || NfTypeName.IsIgnoreType(asmType) || NfTypeName.IsClrGeneratedType(asmType))
return null;
//use the logic in TypeName to get the namespace and class name so its not tied to having the assembly
var cgTypeName = new NfTypeName(asmType.AssemblyQualifiedName);
//make sure there is always some kind of namespace
cgType.Namespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? asmType.Assembly.GetName().Name
: cgTypeName.Namespace;
cgType.IsContrivedNamespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace);
cgType.Name = cgTypeName.ClassName;
cgType.AssemblyQualifiedName = asmType.AssemblyQualifiedName;
cgType.IsEnum = NfTypeName.IsEnumType(asmType);
var cgTypesInterfaces = asmType.GetInterfaces();
cgType.MetadataToken = asmType.MetadataToken;
Func<CgType, string, bool> alreadyPresentHerein =
(cg, nextName) =>
(cg.Properties.FirstOrDefault(
cgP => string.Equals(cgP.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Fields.FirstOrDefault(
cgF => string.Equals(cgF.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Events.FirstOrDefault(
cgE => string.Equals(cgE.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null)
;
//have events go first since they tend to be speard across fields and properties
foreach (
var evtInfo in
asmType.GetEvents(NfConfig.DefaultFlags))
{
var evtHandlerType = evtInfo.NfEventHandlerType().ToString();
var cgMem = new CgMember
{
Name = evtInfo.Name,
TypeName = evtHandlerType,
MetadataToken = evtInfo.MetadataToken
};
cgType.Events.Add(cgMem);
}
var asmMembers =
asmType.GetMembers(NfConfig.DefaultFlags);
foreach (var mi in asmMembers)
{
if (alreadyPresentHerein(cgType, mi.Name))
continue;
try
{
if (mi.MemberType == MemberTypes.Property)
{
var pi = mi as PropertyInfo;
var cgm = GetAsCgMember(pi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
continue;
if (resolveDependencies)
{
var propMi = NfTypeName.GetMethodsForProperty(pi, asmType);
foreach (var pim in propMi)
{
cgm.opCodeCallsAndCallvirtsMetadatTokens.AddRange(Asm.GetCallsMetadataTokens(pim));
}
}
cgType.Properties.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Properties.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
HasGetter = true,
HasSetter = true,
SkipIt = true
});
}
try
{
if (mi.MemberType == MemberTypes.Event)
{
continue;//these have already been handled
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
continue;
}
try
{
if (mi.MemberType == MemberTypes.Field)
{
var fi = mi as FieldInfo;
var cgm = GetAsCgMember(fi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
continue;
cgType.Fields.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Fields.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
try
{
if (!valueTypeOnly && mi.MemberType == MemberTypes.Method)
{
var mti = mi as MethodInfo;
var cgm = GetAsCgMember(mti, resolveDependencies);
if (cgm == null)
continue;
cgm.IsInterfaceImpl = IsInterfaceImpl(mti, cgTypesInterfaces);
cgType.Methods.Add(cgm);
}
if (!valueTypeOnly && mi.MemberType == MemberTypes.Constructor)
{
var ci = mi as ConstructorInfo;
var tn = (string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? cgTypeName.ClassName
: $"{cgTypeName.Namespace}.{cgTypeName.ClassName}");
var cgm = GetAsCgMember(ci, tn, resolveDependencies);
if (cgm == null)
continue;
cgType.Methods.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Methods.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
}
if (resolveDependencies)
{
ResolveAllMetadataTokens(cgType, asmType.Assembly.ManifestModule);
}
return cgType;
}
/// <summary>
/// Parses a hbm.xml file into this runtime equiv.
/// being intended for code generation.
/// </summary>
/// <param name="hbmXmlFilePath"></param>
public HbmFileContent(string hbmXmlFilePath)
{
_simpleProperties = new Dictionary<string, string>();
_fkProperties = new Dictionary<string, string>();
_listProperties = new Dictionary<string, string>();
_compositeKeyProperties = new Dictionary<string, string>();
_keyColumns = new Dictionary<string, ColumnMetadata>();
_simpleColumns = new Dictionary<string, ColumnMetadata>();
_fkColumns = new Dictionary<string, List<ColumnMetadata>>();
_listColumns = new Dictionary<string, List<ColumnMetadata>>();
_spConstNames = new List<HbmStoredProxNames>();
_keyManyToOnePropertyNames = new List<string>();
_allPkColumns = new Dictionary<string, string>();
if(!File.Exists(hbmXmlFilePath))
throw new ItsDeadJim(string.Format("There isn't any xml file at '{0}'", hbmXmlFilePath));
_fileNamePath = hbmXmlFilePath;
_hbmXml = new XmlDocument();
_hbmXml.LoadXml(File.ReadAllText(_fileNamePath));
_nsMgr = new XmlNamespaceManager(_hbmXml.NameTable);
_nsMgr.AddNamespace(NS, Globals.HBM_XML_NS);
_classNode =
_hbmXml.SelectSingleNode(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), _nsMgr) as
XmlElement;
if(_classNode == null)
throw new ItsDeadJim(string.Format("The top-level 'class' node is missing from the xml file at '{0}'",hbmXmlFilePath));
IsCompositeKey =
_hbmXml.SelectSingleNode(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS, HbmXmlNames.COMPOSITE_ID), _nsMgr) != null;
var tableNameAttr = _classNode.Attributes[HbmXmlNames.TABLE];
if (tableNameAttr != null)
_tableName = tableNameAttr.Value;
var attrTypeName = GetAttrVal(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), HbmXmlNames.NAME);
if (NfTypeName.IsFullAssemblyQualTypeName(attrTypeName))
{
_asmQualTypeName = attrTypeName;
var nfName = new NfTypeName(attrTypeName);
_className = nfName.ClassName;
_namespace = nfName.Namespace;
}
else
{
_className = NfTypeName.GetTypeNameWithoutNamespace(attrTypeName);
_namespace = NfTypeName.GetNamespaceWithoutTypeName(attrTypeName);
_asmQualTypeName = Compose.ClassName(_className, _namespace);
}
_dbSchema = GetAttrVal(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), HbmXmlNames.SCHEMA);
//the stored prox will not have a schema qualifier so try to derive it from the file name
if (string.IsNullOrWhiteSpace(_dbSchema))
{
var ff = Path.GetFileName(_fileNamePath);
if (!string.IsNullOrWhiteSpace(ff) && ff.Split('.').Length > 3)
{
_dbSchema = ff.Split('.')[0];
}
else
{
_dbSchema = "Dbo";
}
}
//get id/composite-id node
GetIdNode();
//get id's name and type
GetIdName();
//get flat-data's names and types
GetFlatProperties();
//get FKs names and types
GetFkProperties();
//get IList names and types
GetListProperties();
//get stored proc names
GetStoredProcNames();
//get composite key's properties
GetCompositeKeyProperties();
//condense a list of what is just on this table
GetAllPkColumns();
}
