/// <summary>
/// To insure that a CSV files headers are all unique and simple, propertyesque, names.
/// </summary>
/// <param name="someStrings"></param>
/// <returns></returns>
public static string[] FormatCsvHeaders(string[] someStrings)
{
var newNames = new List <string>();
var names2Count = new Dictionary <string, int>();
foreach (var s in someStrings)
{
if (names2Count.ContainsKey(s))
{
names2Count[s] += 1;
}
else
{
names2Count.Add(s, 1);
}
}
foreach (var k in names2Count.Keys)
{
var repeated = names2Count[k];
var newName = NfString.SafeDotNetIdentifier(k);
if (repeated > 1)
{
for (var i = 0; i < names2Count[k]; i++)
{
newNames.Add(String.Format("{0}{1:00}", newName, i + 1));
}
}
else
{
newNames.Add(newName);
}
}
return(newNames.ToArray());
}
internal static XElement GetSimplePropertyHbmXml(ColumnMetadata entry, string xElementName)
{
if (entry == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(xElementName))
{
xElementName = Globals.HbmXmlNames.PROPERTY;
}
if (string.IsNullOrWhiteSpace(entry.data_type) &&
Sorting.DbContainers.AllColumns.Data.Any(
x => string.Equals(x.column_name, entry.constraint_name, Sorting.C)))
{
var acEntry =
Sorting.DbContainers.AllColumns.Data.First(
x => string.Equals(x.column_name, entry.constraint_name, Sorting.C));
entry.CopyFrom(acEntry);
}
else
{
entry.CopyFrom(Sorting.GetFromAllColumnMetadata(entry));
}
var simplePropName = Compose.PropertyName(entry.column_name);
var simplePropColumn = NfString.ExtractLastWholeWord(entry.column_name, null);
var simplePropDataType = Globals.HbmXmlNames.ANSI_STRING;
if (!Util.Lexicon.DotNet2HbmTypes.ContainsKey(string.Format("{0}", entry.data_type)) &&
!Util.Lexicon.Mssql2HbmTypes.ContainsKey(string.Format("{0}", entry.data_type)))
{
Console.WriteLine("{0:yyyy-MM-dd HH:mm:ss.ffff} '{1}' has no matching type in the Lexicon [{2}].",
DateTime.Now,
entry.data_type, entry.ToJsonString());
}
else
{
simplePropDataType = entry.data_type.StartsWith("System.")
? Util.Lexicon.DotNet2HbmTypes[entry.data_type]
: Util.Lexicon.Mssql2HbmTypes[entry.data_type];
}
var simplePropLen = simplePropDataType == Globals.HbmXmlNames.ANSI_STRING
? entry.string_length == null || entry.string_length <= 0 ? Globals.MSSQL_MAX_VARCHAR : entry.string_length
: null;
if (simplePropDataType == typeof(Boolean).Name)
{
if (simplePropName.StartsWith(NfString.DefaultNamePrefix))
{
simplePropName = simplePropName.Remove(0, NfString.DefaultNamePrefix.Length);
}
simplePropName = "Is" + simplePropName;
}
return(XeFactory.PropertyNode(xElementName, simplePropName, simplePropColumn,
simplePropDataType, simplePropLen.ToString(), entry.is_nullable.HasValue && entry.is_nullable == true,
entry.ToJsonString()));
}
private EfSimpleProp GetSimpleProp(string propName)
{
var propColMetadataList = GetColumnDataByPropertyName(propName);
if (propColMetadataList == null || propColMetadataList.Length <= 0)
{
return(null);
}
var propColMetadata = propColMetadataList.First();
var isString = false;
if (!_efProperties.ContainsKey(propName) && Util.Lexicon.Mssql2HbmTypes.ContainsKey(propColMetadata.data_type))
{
isString = Util.Lexicon.Mssql2HbmTypes[propColMetadata.data_type] == "AnsiString";
}
else
{
isString = _efProperties[propName] == "string";
}
var efsprop = new EfSimpleProp {
IsString = isString
};
efsprop.IsUnicode = efsprop.IsString && propColMetadata.data_type.StartsWith("n");
efsprop.ColumnName = NfString.ExtractLastWholeWord(propColMetadata.column_name.Replace("[", string.Empty).Replace("]", string.Empty), null);
efsprop.RequiresPrecision = Globals.MssqlTypesWithPrecision.Contains(propColMetadata.data_type);
//this exports doubled when it is unicode
efsprop.StringLength = GetStringLength(propColMetadata.string_length, efsprop.IsUnicode);
efsprop.Precision = propColMetadata.precision;
efsprop.PropName = propName;
return(efsprop);
}
/// <summary>
/// Prints the address as it would appear as post marked.
/// </summary>
/// <returns></returns>
public override string ToString()
{
var data = GetData();
return(NfString.DistillSpaces(string.Join(" ", data.ThoroughfareNumber, data.ThoroughfareDirectional, data.ThoroughfareName,
data.ThoroughfareType, data.SecondaryUnitDesignator,
data.SecondaryUnitId).Trim()));
}
public static string HbmFileName(string someName)
{
if (string.IsNullOrWhiteSpace(someName))
{
return(null);
}
someName = NfString.CapWords(someName, '.');
return($"{someName}.hbm.xml");
}
/// <summary>
/// Gets the universities based on a US State
/// </summary>
/// <param name="state">Either the name or the postal code.</param>
/// <returns></returns>
public static AmericanUniversity[] GetUniversitiesByState(string state)
{
UnivXml = UnivXml ?? Core.XmlDocXrefIdentifier.GetEmbeddedXmlDoc(US_UNIVERSITY_DATA,
Assembly.GetExecutingAssembly());
//this will never pass so avoid the exception
if (UnivXml == null)
{
return new AmericanUniversity[] { }
}
;
if (String.IsNullOrWhiteSpace(state))
{
_allStateAbbreviations = _allStateAbbreviations ?? GetAllXmlStateAbbreviations(UnivXml);
state = GetRandomStateAbbrev(_allStateAbbreviations);
}
var qryBy = "name";
if (state.Length == 2)
{
qryBy = "abbreviation";
}
else
{
state = string.Join(" ", NfString.DistillToWholeWords(state));
}
var elements =
UnivXml.SelectSingleNode($"//state[@{qryBy}='{state}']");
if (elements == null || !elements.HasChildNodes)
{
return new AmericanUniversity[] { }
}
;
var tempList = new List <AmericanUniversity>();
foreach (var elem in elements)
{
if (TryParseXml(elem as XmlElement, out var univOut))
{
univOut.StateName = state;
tempList.Add(univOut);
}
}
if (tempList.Count == 0)
{
return new AmericanUniversity[] { }
}
;
return(tempList.ToArray());
}
public AsmDiagramEdge(Tuple <FlattenedItem, FlattenedItem> f)
{
_node1Name = NfString.SafeDotNetIdentifier(f.Item1.TypeFullName.Replace(".", "_"), false, 128);
_node2Name = NfString.SafeDotNetIdentifier(f.Item2.TypeFullName.Replace(".", "_"), false, 128);
Node1 = f.Item1.TypeFullName;
Node2 = f.Item2.TypeFullName;
IsEnumerable = f.Item2.IsEnumerable;
}
public static string ManyToOnePropertyName(string fullAssemblyQualTypeName, string[] fkColumnNames)
{
var fkPropertyType = new NfTypeName(fullAssemblyQualTypeName);
var fkPropertyName = fkPropertyType.ClassName;
fkColumnNames = fkColumnNames.Select(x => NfString.CapWords(NfString.ExtractLastWholeWord(x, '.'), null)).ToArray();
return(string.Format("{0}By{1}", fkPropertyName,
string.Join("And", fkColumnNames)));
}
public override string GetRandomDriversLicense()
{
var dlVal = base.GetRandomDriversLicense();
var chkDigit = NfString.CalcLuhnCheckDigit(dlVal);
var dlOut = new StringBuilder();
dlOut.Append(dlVal);
dlOut.Append(chkDigit.ToString());
return(dlOut.ToString());
}
public TextCanvas ComposeArrow(Rule ruler, TextCanvas tc)
{
if (ruler == null)
{
throw new NoRuleSetException();
}
var arrowIdx = ruler.CalcEntryIndex(this);
Width = tc.Width;
//find the line on the text canvas
var ti = tc.Items.FirstOrDefault(t => t.Index == arrowIdx.Item1);
if (ti == null)
{
return(tc);
}
//scope in on the ranges for the located line
TextRange fromTr;
TryGetTextRange(ti.Ranges, FromBlock.Id, out fromTr);
TextRange toTr;
TryGetTextRange(ti.Ranges, ToBlock.Id, out toTr);
if (fromTr == null || toTr == null)
{
return(tc);
}
var isOuterBlock = !string.IsNullOrWhiteSpace(tc.Id);
System.Console.WriteLine(
$"({(isOuterBlock ? "Outer Block" : "InnerBlock")}) {fromTr.Id} -> {toTr.Id}");
var arrowText = new StringBuilder();
var arrowDirection = DetermineArrowDirection(fromTr.Id, toTr.Id, ti.Ranges);
switch (arrowDirection)
{
case PrintLocation.Left:
arrowText = GetLeftArrowStrBldr(fromTr, toTr, ti);
break;
case PrintLocation.Right:
arrowText = GetRightArrowStrBldr(fromTr, toTr, ti);
break;
}
tc.Items.First(t => t.Index == arrowIdx.Item1).Text =
NfString.MergeString(arrowText.ToString(),
new string(tc.Items.First(t => t.Index == arrowIdx.Item1).Text.ToArray())).ToCharArray().ToList();
return(tc);
}
/// <summary>
/// Utility method to apply word-wrap to a text document.
/// </summary>
/// <param name="fileFullName"></param>
/// <param name="lineLength"></param>
public static void ToWordWrap(string fileFullName, int?lineLength = 80)
{
if (String.IsNullOrWhiteSpace(fileFullName) || !File.Exists(fileFullName))
{
return;
}
var content = File.ReadAllText(fileFullName);
var wwContent = NfString.ToWordWrap(content, lineLength);
File.WriteAllText(fileFullName, wwContent);
}
public static XElement IdNode(string name)
{
if (String.IsNullOrWhiteSpace(name))
{
name = String.Format("{0}__{1}", Globals.HbmXmlNames.ID, NfString.GetNfRandomName());
}
return(new XElement(Globals.HbmXmlNames.ID.ToLower(),
new XAttribute(Globals.HbmXmlNames.NAME, name),
new XAttribute(Globals.HbmXmlNames.TYPE, "Guid"),
new XAttribute(Globals.HbmXmlNames.GENERATOR, "guid")));
}
protected internal virtual string DrawHeader()
{
var label = NfString.PrintInCenter(Title, Width);
var bar = DrawBar();
var strBuilder = new StringBuilder();
for (var i = 0; i < Width; i++)
{
var headerChar = label[i] == (char)0x20 ? bar[i] : label[i];
strBuilder.Append(headerChar);
}
strBuilder.AppendLine();
return(strBuilder.ToStringUnixNewline());
}
/// <summary>
/// End-of-line conversion with specific encoding.
/// </summary>
/// <param name="somePath"></param>
/// <param name="encoder"></param>
public static void ConvertToCrLf(string somePath, Encoding encoder)
{
if (String.IsNullOrWhiteSpace(somePath))
{
return;
}
if (!File.Exists(somePath))
{
return;
}
var fileContent = File.ReadAllText(somePath);
fileContent = NfString.ConvertToCrLf(fileContent);
File.WriteAllText(somePath, fileContent, encoder);
}
/// <summary>
/// Creates and XDocument in which child elements map to token-pair matches.
/// </summary>
/// <param name="inputString">The string upon which the XDocument frame will be derived.</param>
/// <returns></returns>
/// <remarks>
/// Given a string arguement (or a path to a text file) the function will
/// produce an XDocument where the nesting of child nodes represents
/// the internal context of a matching pair of tokens. Therefore the output
/// will contian nodes and those nodes may contain furthere child nodes and
/// so on down to an internal size that is at least the defined minimum token
/// span.
///
/// The string input will have all its concurrent occurances of spaces and
/// tabs reduced to a single space.
///
/// The result is simply a frame and does not contain any of the original string.
/// </remarks>
public XElement GetXDocFrame(string inputString)
{
if (string.IsNullOrWhiteSpace(inputString))
{
throw new ItsDeadJim("The input string arg is empty.");
}
inputString = NfString.DistillCrLf(inputString);
inputString = NfString.DistillTabs(inputString);
var tokens = GetTokens(inputString);
var gaps = GetGaps(tokens);
var xDoc = FrameTokensXDoc(tokens);
xDoc = FrameGapsXDoc(xDoc, gaps);
return(xDoc);
}
/// <summary>
/// Applies the results of Get-XDocFrame to the original content.
/// </summary>
/// <param name="xDoc"></param>
/// <param name="inputString"></param>
/// <remarks>
/// Returns the XDocument with the inter-string spans applied as text data
/// of each of the XDocument frame nodes.
///
/// The input is again distilled of all concurrent occurances of tab and space
/// characters.
/// </remarks>
public void ApplyXDocFrame(XElement xDoc, string inputString)
{
if (string.IsNullOrWhiteSpace(inputString))
{
throw new ItsDeadJim("The input string arg is empty.");
}
if (xDoc == null)
{
throw new ItsDeadJim("a XElement must be supplied, call GetXDocFrame prior to calling this member");
}
//crit - the indices must match the original so process like frame f(x) did
inputString = NfString.DistillCrLf(inputString);
inputString = NfString.DistillTabs(inputString);
XDocIter(xDoc, inputString);
}
protected internal string DrawHeader()
{
if (_width - 2 <= 0)
{
return(Name);
}
var title = NfString.PrintInCenter(Name, (_width - 2));
var strBuilder = new StringBuilder();
if (_rulerWidth > 0)
{
strBuilder.Append(new string((char)0x20, _rulerWidth));
}
strBuilder.Append(Config.GraphChars.Bar);
strBuilder.Append(title);
strBuilder.Append(Config.GraphChars.Bar);
return(strBuilder.ToStringUnixNewline());
}
/// <summary>
/// Gets a type's name less the namespace
/// </summary>
/// <param name="simplePropType"></param>
/// <returns></returns>
public static string GetTypeNameWithoutNamespace(string simplePropType)
{
if (String.IsNullOrWhiteSpace(simplePropType))
{
return(null);
}
if (!simplePropType.Contains(NfSettings.DefaultTypeSeparator))
{
return(simplePropType);
}
if (simplePropType.Contains(Constants.TYPE_METHOD_NAME_SPLIT_ON))
{
simplePropType = simplePropType.Substring(0,
simplePropType.IndexOf(Constants.TYPE_METHOD_NAME_SPLIT_ON, StringComparison.Ordinal));
}
return(NfString.ExtractLastWholeWord(simplePropType, NfSettings.DefaultTypeSeparator));
}
public override string ToString()
{
if (_nsNodes == null || _nsNodes.Count <= 0)
{
return(string.Empty);
}
var graphViz = new StringBuilder();
graphViz.Append($"subgraph cluster_{NfString.SafeDotNetIdentifier(_ns)}");
graphViz.AppendLine("{");
graphViz.AppendLine("\tlabel=\"\";");
graphViz.AppendLine("\tcolor=red;");
foreach (var item in _nsNodes)
{
graphViz.AppendLine($"\t{item}");
}
graphViz.AppendLine("}");
return(graphViz.ToString());
}
internal static void GetSimpleId(ColumnMetadata pkId, XElement classXe)
{
pkId.CopyFrom(Sorting.GetFromAllColumnMetadata(pkId));
var fullColumnName = pkId.column_name;
Compose.ValidSplit(fullColumnName, 3);
var columnName = NfString.ExtractLastWholeWord(fullColumnName, null);
const string propertyName = Globals.HbmXmlNames.ID;
var type = Util.Lexicon.Mssql2HbmTypes[(pkId.data_type)];
var length = pkId.string_length ?? Globals.MSSQL_MAX_VARCHAR;
XElement idXe;
//don't let the '-1' from the database make it to the hbm.xml's
if (string.Equals(type, Globals.HbmXmlNames.ANSI_STRING))
{
if (length <= 0)
{
length = Globals.MSSQL_MAX_VARCHAR;
}
idXe = XeFactory.IdNode(propertyName, columnName, type,
length.ToString(CultureInfo.InvariantCulture), pkId.ToJsonString());
}
else
{
idXe = XeFactory.IdNode(propertyName, columnName, type, pkId.ToJsonString());
}
//simple split of assigned or is_identity
XElement generatorXe;
if (pkId.is_auto_increment.HasValue && pkId.is_auto_increment.Value)
{
generatorXe = XeFactory.GeneratorId(Globals.HbmXmlNames.IDENTITY);
}
else
{
generatorXe = XeFactory.GeneratorId(Globals.HbmXmlNames.ASSIGNED);
}
idXe.Add(generatorXe);
classXe.Add(idXe);
}
public string GetDotNetPropertyName()
{
if (string.IsNullOrWhiteSpace(ParamName))
{
return(null);
}
var cName = ParamName.StartsWith("@") ? ParamName.Substring(1, ParamName.Length - 1) : ParamName;
cName = NfString.SafeDotNetIdentifier(cName);
cName = NfString.CapWords(cName, null);
if (GetSqlDataType() == SqlDbType.Bit && !cName.StartsWith("Is"))
{
cName = string.Format("Is{0}", cName);
}
if (cName.EndsWith("ID"))
{
cName = string.Format("{0}Id", cName.Substring(0, cName.Length - 2));
}
return(cName);
}
public override bool ValidDriversLicense(string dlnumber)
{
if (string.IsNullOrWhiteSpace(dlnumber))
{
return(false);
}
//all but last digit
var dlVal = dlnumber.Substring(0, dlnumber.Length - 1);
var dlLastChar = dlnumber.Substring(dlnumber.Length - 1, 1);
var dlChkDigit = 0;
if (!int.TryParse(dlLastChar, out dlChkDigit))
{
return(false);
}
var calcChkDigit = NfString.CalcLuhnCheckDigit(dlVal);
return(base.ValidDriversLicense(dlVal) && dlChkDigit == calcChkDigit);
}
public Ef35PropertyAttr(ColumnMetadata md, bool addUpdateCheckNever)
{
Name = NfString.ExtractLastWholeWord(md.column_name, Shared.Core.NfSettings.DefaultTypeSeparator);
_composedName = Compose.PropertyName(md.column_name);
DbType = md.data_type.ToUpper();
if (Lexicon.Mssql2HbmTypes.ContainsKey(md.data_type) && Lexicon.Mssql2HbmTypes[md.data_type] == "AnsiString")
{
if (md.string_length != null && md.string_length < 0)
{
DbType = string.Format("{0}(MAX)", DbType);
}
else
{
DbType = string.Format("{0}({1})", DbType, md.string_length);
}
}
if (Globals.MssqlTypesWithPrecision.Contains(md.data_type))
{
DbType = string.Format("{0}({1})", DbType, md.precision);
}
if (md.is_nullable != null && md.is_nullable.Value == false)
{
DbType = string.Format("{0} NOT NULL", DbType);
CanBeNull = false;
}
else
{
CanBeNull = true;
}
if (md.is_auto_increment != null && md.is_auto_increment.Value)
{
DbType = string.Format("{0} IDENTITY", DbType);
IsPrimaryKey = true;
IsDbGenerated = true;
}
IsUpdateCheckNever = addUpdateCheckNever;
}
public static string ClassName(string name, string outputNamespace)
{
var asmQualifiedName = new StringBuilder();
if (name.Split(Shared.Core.NfSettings.DefaultTypeSeparator).Length > 1)
{
var nameParts = name.Split(Shared.Core.NfSettings.DefaultTypeSeparator);
var actualClassName = nameParts[(nameParts.Length - 1)].Replace(" ", Globals.REPLACE_SPACE_WITH_SEQUENCE);
nameParts[(nameParts.Length - 1)] = NfString.SafeDotNetTypeName(actualClassName);
name = string.Join(Shared.Core.NfSettings.DefaultTypeSeparator.ToString(CultureInfo.InvariantCulture), nameParts);
}
//remove any chars not allowed in C# ids
name = NfString.SafeDotNetTypeName(name);
//capitalize first letter of whole word to avoid conflict with C# reserved words
name = NfString.CapWords(name, Shared.Core.NfSettings.DefaultTypeSeparator);
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
outputNamespace = NfString.CapWords(outputNamespace, Shared.Core.NfSettings.DefaultTypeSeparator);
asmQualifiedName.AppendFormat("{0}{1}", outputNamespace, Shared.Core.NfSettings.DefaultTypeSeparator);
}
asmQualifiedName.Append(name);
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
asmQualifiedName.AppendFormat(", {0}", NfReflect.DraftCscExeAsmName(outputNamespace));
}
var typeName = new NfTypeName(asmQualifiedName.ToString());
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
return(typeName.AssemblyQualifiedName);
}
return(typeName.FullName);
}
public static TextCanvas Merge(this TextCanvas entry1Tc, TextCanvas entry2Tc, Rule ruler)
{
//check for null args
if (ruler == null || entry2Tc == null)
{
throw new DrawingException("A merge requires a source, a candidate and a ruler");
}
//validate args have something to work with
if (entry1Tc.IsEmptyItems() && entry2Tc.IsEmptyItems())
{
return(new TextCanvas());
}
if (entry2Tc.IsEmptyItems() && !entry1Tc.IsEmptyItems())
{
return(entry1Tc);
}
if (entry1Tc.IsEmptyItems() && !entry2Tc.IsEmptyItems())
{
return(entry2Tc);
}
//determine total edges for the whole
var entriesMin = entry1Tc.MinIndex < entry2Tc.MinIndex ? entry1Tc.MinIndex : entry2Tc.MinIndex;
var entriesMax = entry1Tc.MaxIndex > entry2Tc.MaxIndex ? entry1Tc.MaxIndex : entry2Tc.MaxIndex;
Func <TextItem, bool> tti = ti1 => ti1 != null && !ti1.IsEmptyText();
var textCanvas = new TextCanvas
{
Ruler = ruler,
Items = new List <TextItem>(),
MaxIndex = entriesMax,
MinIndex = entriesMin,
Width = entry1Tc.Width > entry2Tc.Width ? entry1Tc.Width : entry2Tc.Width
};
for (var i = entriesMin; i <= entriesMax; i++)
{
var entry1i = entry1Tc.Items.FirstOrDefault(item => item.Index == i);
var entry2i = entry2Tc.Items.FirstOrDefault(item => item.Index == i);
if (entry1i == null && entry2i == null)
{
continue;
}
//merge line
if (tti(entry1i) && tti(entry2i))
{
var newEntry = entry1i.Copy();
newEntry.Ranges.AddRange(entry2i.Ranges);
newEntry.Text =
NfString.MergeString(new string(entry1i.Text.ToArray()), new string(entry2i.Text.ToArray()))
.ToCharArray().Where(c => Convert.ToInt32(c) >= 0x20)
.ToList();
textCanvas.Items.Add(newEntry);
continue;
}
if (tti(entry1i))
{
textCanvas.Items.Add(entry1i.Copy());
continue;
}
textCanvas.Items.Add(entry2i.Copy());
}
return(textCanvas);
}
public AsmDiagram(Assembly asm, bool withNamespaceSubGraphs = false)
{
if (asm == null)
{
throw new ArgumentNullException(nameof(asm));
}
_targetedNs = asm.GetName().Name;
_withNsSubgraphs = withNamespaceSubGraphs;
_asmName = NfString.SafeDotNetIdentifier(asm.GetName().Name);
foreach (
var asmType in
asm.NfGetExportedTypes()
.Where(x => !string.IsNullOrWhiteSpace(x.Namespace) &&
AssemblyName.ReferenceMatchesDefinition(asm.GetName(), x.Assembly.GetName())))
{
var item1 = new FlattenedItem(asmType)
{
FlName = asmType.Name
};
if (item1.IsTerminalNode || NfReflect.IsEnumType(asmType))
{
continue;
}
foreach (
var p in
asmType.NfGetProperties(NfSettings.DefaultFlags, false)
.Where(
x => x != null &&
!string.IsNullOrWhiteSpace(x.NfPropertyType(false)?.Namespace) &&
AssemblyName.ReferenceMatchesDefinition(x.NfPropertyType(false)?.Assembly.GetName(), asm.GetName()))
)
{
if (NfReflect.IsEnumType(p.PropertyType))
{
continue;
}
var item2 = new FlattenedItem(p.PropertyType)
{
FlName = p.Name
};
if (item2.IsTerminalNode)
{
continue;
}
var tupleOfItems = new Tuple <FlattenedItem, FlattenedItem>(item1, item2);
var itemEv = new AsmDiagramEdge(tupleOfItems);
if (Edges.Any(x => x.AreSame(itemEv)))
{
continue;
}
Edges.Add(itemEv);
}
}
Edges = RemoveDuplicates(Edges);
var names = Edges.SelectMany(x => x.NodeName).ToList();
var uqNames = names.Distinct().OrderBy(x => x).ToList();
_nodes = uqNames.Select(x => new AsmDiagramNode(x, GetCountOfEdgesOn(x))).ToList();
if (_withNsSubgraphs)
{
var uqNamespaces = _nodes.Select(x => x.NodeNamespace).Distinct().ToList();
foreach (var ns in uqNamespaces)
{
_nsSubGraphs.Add(new AsmDiagramSubGraph(ns, _nodes));
}
}
}
public override string ToString()
{
if (string.IsNullOrEmpty(Text))
{
return(string.Empty);
}
if (Width == 0)
{
_width = Config.Numerics.DefaultWidth;
}
if (_height == 0)
{
_height = CalcHeight();
}
Func <int, string> sfOpL = i => "{0,-" + i + "}";
Func <int, string> sfOpR = i => "{0," + i + "}";
var strBuilder = new StringBuilder();
switch (Location)
{
case PrintLocation.Center:
strBuilder.AppendLine(NfString.PrintInCenter(Text, Width));
break;
case PrintLocation.Left:
strBuilder.AppendLine(string.Format(sfOpL(Width), Text));
break;
case PrintLocation.Right:
strBuilder.AppendLine(string.Format(sfOpR(Width), Text.Trim()));
break;
}
if (_height <= 1)
{
return(strBuilder.ToStringUnixNewline());
}
for (var i = 0; i < _height - 1; i++)
{
switch (Location)
{
case PrintLocation.Center:
strBuilder.AppendLine(NfString.PrintInCenter(Config.GraphChars.LifeLine.ToString(), Width));
break;
case PrintLocation.Left:
strBuilder.AppendLine(string.Format(sfOpL(Width), Config.GraphChars.LifeLine));
break;
case PrintLocation.Right:
strBuilder.AppendLine(string.Format(sfOpR(Width), Config.GraphChars.LifeLine));
break;
}
}
switch (Location)
{
case PrintLocation.Center:
strBuilder.AppendLine(NfString.PrintInCenter(new string(Config.GraphChars.Rail, 3), Width));
break;
case PrintLocation.Left:
strBuilder.AppendLine(string.Format(sfOpL(Width), new string(Config.GraphChars.Rail, 3)));
break;
case PrintLocation.Right:
strBuilder.AppendLine(string.Format(sfOpR(Width), new string(Config.GraphChars.Rail, 3)));
break;
}
return(strBuilder.ToStringUnixNewline());
}
/// <summary>
/// Produces a single hbm.xml for the given <see cref="tbl"/>
/// </summary>
/// <param name="outputNamespace"></param>
/// <param name="tbl"></param>
/// <returns>The path the generated hbm.xml file</returns>
public static string GetSingleHbmXml(string outputNamespace, string tbl)
{
if (HbmKeys == null || HbmOneToMany == null || HbmBags == null)
{
throw new RahRowRagee("Assign the static variables HbmKeys, HbmOneToMany and HbmBags" +
" then try again (These values are calculated from Sorting).");
}
if (Settings.DoNotReference.Contains(tbl))
{
return(null);
}
var hbmPk = HbmKeys.Data;
var hbmFk = HbmOneToMany.Data;
var hbmBags = HbmBags.Data;
//possiable duplicate names handled within this
var className = Compose.ClassName(tbl, outputNamespace);
//not having the naming pattern is exceptional
Compose.ValidSplit(tbl, 2);
var tableName = NfString.ExtractLastWholeWord(tbl, null);
var schemaName = tbl.Replace(string.Format(".{0}", tableName), string.Empty);
var xe = XeFactory.HibernateMappingNode();
var classXe = XeFactory.ClassNode(className, tableName, schemaName);
var hasNoPkAtAll = GetPk(outputNamespace, tbl, hbmPk, classXe);
//having no pk, add the contrived comp-key to the class
if (hasNoPkAtAll)
{
GetAllColumnsAsCompositeKey(tbl, classXe, outputNamespace);
}
else//simple properties
{
foreach (var columnName in Sorting.DbContainers.FlatData.Data.Where(x => string.Equals(x.table_name, tbl, Sorting.C)))
{
var fullColumnName = columnName.column_name;
Compose.ValidSplit(fullColumnName, 3);
var simplePropXe = GetSimplePropertyHbmXml(columnName, Globals.HbmXmlNames.PROPERTY);
classXe.Add(simplePropXe);
}
}
GetFksWhichAreNotPartOfPks(outputNamespace, tbl, hbmFk, classXe);
GetBags(outputNamespace, tbl, hbmBags, hasNoPkAtAll, className, classXe);
xe.Add(classXe);
var hbmXmlOutputPath = Path.Combine(Settings.HbmDirectory,
Compose.HbmFileName(tbl));
var xmlContent = xe.ToString()
.Replace("<hibernate-mapping>", "<hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.2\">");
File.WriteAllText(hbmXmlOutputPath, xmlContent);
//perform rename of any properties which match classname or are duplicated therein
CorrectHbmXmlDuplicateNames(hbmXmlOutputPath);
return(hbmXmlOutputPath);
}
/// <summary>
/// Produces a single hbm.xml with the sql-query node in tow.
/// </summary>
/// <param name="outputNamespace"></param>
/// <param name="storedProc"></param>
/// <returns>The path to the generated hbm.xml file.</returns>
public static string GetHbmNamedQueryXml(string outputNamespace, string storedProc)
{
if (Sorting.AllStoredProcNames == null || Sorting.AllStoredProcNames.Count <= 0)
{
throw new RahRowRagee("There doesn't appear to be any stored procs here.");
}
if (Settings.DoNotReference.Contains(storedProc) || !Sorting.AllStoredProx.ContainsKey(storedProc))
{
return(null);
}
var sp = Sorting.AllStoredProx[storedProc];
if (sp == null)
{
return(null);
}
var returnedData = sp.ReturnedData;
if (returnedData == null || returnedData.Count <= 0)
{
return(null);
}
if (returnedData.Keys.Count <= 0)
{
Settings.WriteToStoredProcLog(string.Format("Stored proc named '{0}' has an empty dataset", sp.ProcName));
if (!Sorting.EmptyDatasetProx.Contains(sp.ProcName))
{
Sorting.EmptyDatasetProx.Add(sp.ProcName);
}
return(null);
}
//both the return types and the callable sql-query are wrapped in this root node
var xe = XeFactory.HibernateMappingNode();
if (returnedData.Count > 1)
{
Settings.WriteToStoredProcLog(string.Format("Stored Proc named '{0}' returns a multi-table dataset", storedProc));
if (!Sorting.MultiTableDsProx.Contains(storedProc))
{
Sorting.MultiTableDsProx.Add(storedProc);
}
}
//possiable duplicate names handled within this
var className = Compose.ClassName(string.Format("{0}.{1}{2}", Globals.STORED_PROX_FOLDER_NAME, storedProc, "Table"), outputNamespace);
var classXe = XeFactory.ClassNode(className, null, null);
classXe.Add(XeFactory.IdNode(null));
var sqlQryName = NfString.SafeDotNetIdentifier(storedProc);
var returnsXe = XeFactory.ReturnNode(sqlQryName, className);
foreach (var cMeta in returnedData[returnedData.Keys.First()])
{
var simplePropName = Compose.PropertyName(cMeta.column_name, true);
var simplePropColumn = NfString.ExtractLastWholeWord(cMeta.column_name, null);
var simplePropDataType = Util.Lexicon.DotNet2HbmTypes[cMeta.data_type];
classXe.Add(XeFactory.PropertyNode(Globals.HbmXmlNames.PROPERTY, simplePropName, null, simplePropDataType,
(cMeta.data_type == "System.String"
? Globals.MSSQL_MAX_VARCHAR.ToString(CultureInfo.InvariantCulture)
: null), cMeta.is_nullable.HasValue && cMeta.is_nullable == true, string.Empty));
returnsXe.Add(XeFactory.ReturnPropertyNode(simplePropColumn, simplePropName));
}
var sqlQryXe = XeFactory.SqlQueryNode(sqlQryName);
sqlQryXe.Add(returnsXe);
sqlQryXe.Add(new XCData(sp.ToHbmSql()));
xe.Add(classXe);
xe.Add(sqlQryXe);
var hbmXmlOutputPath = Path.Combine(Settings.HbmStoredProcsDirectory,
Compose.HbmFileName(storedProc.Replace(" ", Globals.REPLACE_SPACE_WITH_SEQUENCE)));
var xmlContent = xe.ToString()
.Replace("<hibernate-mapping>", "<hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.2\">");
File.WriteAllText(hbmXmlOutputPath, xmlContent);
CorrectHbmXmlDuplicateNames(hbmXmlOutputPath, true);
return(hbmXmlOutputPath);
}
public static string PropertyName(string name, bool replaceInvalidsWithHexEsc = false)
{
name = NfString.ExtractLastWholeWord(name, Shared.Core.NfSettings.DefaultTypeSeparator);
name = NfString.CapWords(name, null);
return(NfString.SafeDotNetIdentifier(name, replaceInvalidsWithHexEsc));
}