private static Boolean IsMenuItemPointingToForm(string filename, string formName)
{
if (FormForMenuItem.ContainsKey(filename))
{
return(formName.ToLowerInvariant() == FormForMenuItem[filename].ToLowerInvariant());
}
if (File.Exists(filename))
{
XmlReader SourceFile = new XmlReader(filename);
string fileText = SourceFile.Text();
string objectName = MetaData.extractFromXML(fileText, "//AxMenuItemDisplay/Object");
string objectType = MetaData.extractFromXML(fileText, "//AxMenuItemDisplay/ObjectType");
if (objectType == string.Empty ||
objectType == "Form")
{
FormForMenuItem.Add(filename, objectName);
if (objectName.ToLowerInvariant() == formName.ToLowerInvariant())
{
return(true);
}
}
}
return(false);
}
public string Run(string input, int startAt = 0)
{
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = input;
string name = MetaData.extractFromXML(xml, "//AxEnum/Name");
string isExtensible = MetaData.extractFromXML(xml, "//AxEnum/IsExtensible");
string useEnumValue = MetaData.extractFromXML(xml, "//AxEnum/UseEnumValue");
if (useEnumValue == "No" && isExtensible != "true")
{
XmlNodeList nodes = MetaData.extractMultipleFromXML(xml, "//AxEnum/EnumValues/AxEnumValue/Value");
int valueExpected = 1;
foreach (XmlNode node in nodes)
{
if (valueExpected != int.Parse(node.InnerText))
{
Debug.WriteLine(string.Format("{0}", name));
}
valueExpected++;
}
}
}
return(input);
}
public string Run(string input, int startAt = 0)
{
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = match.Value;
if (!xml.Contains("<Optional>"))
{
string fieldName = MetaData.extractFromXML(xml, "//AxTableIndexField/DataField");
string indexName = MetaData.extractPreviousXMLElement("Name", match.Index, input);
string tableName = MetaData.extractNextXMLElement("Name", 1, input);
string token = tableName + "\\" + indexName + "\\" + fieldName;
if (fieldsToMakeOptional.Contains(token.ToLowerInvariant()))
{
if (xml.Contains("<Tags>"))
{
throw new NotSupportedException();
}
if (xml.Contains("<IncludedColumn>"))
{
throw new NotSupportedException();
}
int endpos = xml.IndexOf("</DataField>") + "</DataField>".Length;
int startPos = xml.LastIndexOf(Environment.NewLine, endpos);
int xmlPos = xml.IndexOf("<DataField>");
string updatedInput = input.Insert(match.Index + endpos, xml.Substring(startPos, xmlPos - startPos) + "<Optional>Yes</Optional>");
string indexToken = "<Name>" + indexName + "</Name>";
int indexPos = updatedInput.IndexOf(indexToken);
int endpos2 = updatedInput.IndexOf("</IsSystemGenerated>", indexPos) + "</IsSystemGenerated>".Length;
if (endpos2 > indexPos)
{
int startPos2 = updatedInput.LastIndexOf(Environment.NewLine, endpos2);
int xmlPos2 = updatedInput.IndexOf("<IsSystemGenerated>", startPos2);
if (!updatedInput.Substring(indexPos, endpos2 - indexPos).Contains("IsManuallyUpdated"))
{
updatedInput = updatedInput.Insert(xmlPos2, "<IsManuallyUpdated>Yes</IsManuallyUpdated>" + updatedInput.Substring(startPos2, xmlPos2 - startPos2));
}
}
Hits++;
return(this.Run(updatedInput, match.Index + match.Length));
}
return(this.Run(input, match.Index + match.Length));
}
}
return(input);
}
public string Run(string input, int startAt = 0)
{
if (!Scanner.FILENAME.Contains("Descriptor"))
{
return(input);
}
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = input;
string customization = MetaData.extractFromXML(xml, "//AxModelInfo/Customization");
string locked = MetaData.extractFromXML(xml, "//AxModelInfo/Locked");
string updatedText = "";
if (customization == "")
{
int pos = this.insertCustomizationAt(input);
updatedText = input.Insert(pos, "<Customization>DoNotAllow</Customization>\r\n ");
input = updatedText;
}
else if (customization != "DoNotAllow")
{
string originalText = input;
int startPos = originalText.IndexOf("<Customization>");
int endPos = originalText.IndexOf("</Customization>") + "</Customization>".Length;
updatedText = originalText.Remove(startPos, endPos - startPos);
updatedText = updatedText.Insert(startPos, "<Customization>DoNotAllow</Customization>");
input = updatedText;
}
if (locked != "")
{
string originalText = input;
int startPos = originalText.IndexOf("<Locked>");
int endPos = originalText.IndexOf("</Locked>") + "</Locked>".Length;
startPos = originalText.LastIndexOf("\n", startPos);
endPos = originalText.IndexOf("\n", endPos);
updatedText = originalText.Remove(startPos, endPos - startPos);
}
if (updatedText != "")
{
Hits++;
return(updatedText);
}
}
return(input);
}
private static string getSymbolFromFile(string filename, string value)
{
if (File.Exists(filename))
{
XmlReader SourceFile = new XmlReader(filename);
string fileText = SourceFile.Text();
string symbol = MetaData.extractFromXML(fileText, "//AxEnum/EnumValues/AxEnumValue[Value=\"" + value + "\"]/Name");
if (symbol == String.Empty && value == "0")
{
symbol = MetaData.extractFromXML(fileText, "//AxEnum/EnumValues/AxEnumValue[not (Value)]/Name");
// Debug.WriteLine(string.Format("{2}: {0} does not have value {1}", filename, value, Scanner.FILENAME));
}
return(symbol);
}
return(String.Empty);
}
public string Run(string input, int startAt = 0)
{
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = match.Value;
if (!xml.Contains("<AllowDuplicates>"))
{
string indexName = MetaData.extractFromXML(xml, "//AxTableIndex/Name");
Debug.WriteLine(string.Format("{0}.{1}", Scanner.FILENAME, indexName));
Hits++;
}
return(this.Run(input, match.Index + match.Length));
}
return(input);
}
private static string getTableNameFromQueryRangeSearch(string xml, string prefix, string postfix)
{
string sub = "/DataSources/AxQuerySimpleEmbeddedDataSource";
for (int i = 0; i <= 10; i++)
{
string xPath = prefix;
for (int j = 0; j < i; j++)
{
xPath += sub;
}
xPath += postfix;
string tableName = MetaData.extractFromXML(xml, xPath);
if (tableName != String.Empty)
{
return(tableName);
}
}
return(String.Empty);
}
public string Run(string input, int startAt = 0)
{
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = match.Value;
if (xml.Contains("<Value>") &&
xml.Contains("<Field>"))
{
// <AxQuerySimpleDataSourceRange>
// <Name>NamedCategoryHierarchyRoleRetail</Name>
// <Field>NamedCategoryHierarchyRole</Field>
// <Value>4</Value>
// </AxQuerySimpleDataSourceRange>
string value = MetaData.extractFromXML(xml, "//AxQuerySimpleDataSourceRange/Value");
if (value.IndexOfAny(matchChars) != -1 &&
!value.Contains("(") &&
!value.Contains(">") &&
!value.Contains("<") &&
!value.Contains("..") &&
!value.Contains("!"))
{
string fieldName = MetaData.extractFromXML(xml, "//AxQuerySimpleDataSourceRange/Field");
string rangeName = MetaData.extractFromXML(xml, "//AxQuerySimpleDataSourceRange/Name");
string tableName = MetaData.getTableNameFromQueryRange(input, rangeName);
if (tableName == String.Empty)
{
Debug.WriteLine(string.Format("{0} has unknown table range {1} with value {2} on field {3}", Scanner.FILENAME, rangeName, value, fieldName));
}
string enumName = MetaData.getEnumFromTable(tableName, fieldName);
if (enumName != String.Empty &&
enumName.ToLowerInvariant() != "Boolean".ToLowerInvariant() &&
enumName.ToLowerInvariant() != "NoYes".ToLowerInvariant() &&
enumName.ToLowerInvariant() != "NoYesId".ToLowerInvariant())
{
string symbols = string.Empty;
foreach (var v in value.Split(','))
{
string symbol = MetaData.getSymbolFromEnum(enumName, v.Trim());
if (symbol == string.Empty)
{
// Debug.WriteLine(string.Format("{0} is referencing unknown enum value. Enum={1} with value {2}", Scanner.FILENAME, enumName, v));
break;
}
Debug.WriteLine(string.Format("{0};{1};{2}", enumName, v, symbol));
if (symbols != string.Empty)
{
symbols += ", " + symbol;
}
else
{
symbols = symbol;
}
}
if (symbols != "")
{
string originalText = match.Value;
int startPos = originalText.IndexOf("<Value>");
int endPos = originalText.IndexOf("</Value>") + "</Value>".Length;
string updatedText;
updatedText = originalText.Remove(startPos, endPos - startPos);
updatedText = updatedText.Insert(startPos, "<Value>" + symbols + "</Value>");
string updatedInput = input.Remove(match.Index, match.Length);
updatedInput = updatedInput.Insert(match.Index, updatedText);
Hits++;
return(this.Run(updatedInput, match.Index + match.Length));
}
else
{
//Debug.WriteLine(string.Format("{0} has integer based range {1} on enum {2} on field {3}.{4}", Scanner.FILENAME, value, enumName, tableName, fieldName));
// Debug.WriteLine(string.Format("{0};{1};{2};{3};{4}", Scanner.FILENAME, value, enumName, tableName, fieldName));
}
}
}
}
return(this.Run(input, match.Index + match.Length));
}
return(input);
}
public string Run(string input, int startAt = 0)
{
Match match = xpoMatch.Match(input, startAt);
if (match.Success)
{
string xml = match.Value;
if (!xml.Contains("<ValueStr>") &&
(xml.Contains("AxTableRelationConstraintFixed") ||
xml.Contains("AxTableRelationConstraintRelatedFixed")))
{
// <AxTableRelationConstraint xmlns=""
// i:type="AxTableRelationConstraintFixed">
// <Name>InventAccountType</Name>
// <Field>InventAccountType</Field>
// <Value>21</Value>
// <ValueStr>InventAccountType::SalesIssue</ValueStr>
// </AxTableRelationConstraint>
int startPos = xml.IndexOf("xmlns") - 1;
int endPos = xml.IndexOf(">");
xml = xml.Remove(startPos, endPos - startPos); //Remove the i:type...
string fieldName = MetaData.extractFromXML(xml, "//AxTableRelationConstraint/Field");
string value = MetaData.extractFromXML(xml, "//AxTableRelationConstraint/Value");
if (value == String.Empty)
{
//default
value = "0";
}
string enumName = "";
string token = "Field";
if (fieldName != "")
{
enumName = MetaData.extractFromXML(input, "//AxTable/Fields/AxTableField[Name=\"" + fieldName + "\"]/EnumType");
}
else
{
string relatedFieldName = MetaData.extractFromXML(xml, "//AxTableRelationConstraint/RelatedField");
string sub = input.Substring(1, match.Index);
int pos = sub.LastIndexOf("<RelatedTable>") + "<RelatedTable>".Length;
int pos2 = sub.IndexOf("</RelatedTable>", pos);
string relatedTableName = sub.Substring(pos, pos2 - pos);
fieldName = relatedTableName + "." + relatedFieldName;
enumName = MetaData.getEnumFromTable(relatedTableName, relatedFieldName);
token = "RelatedField";
}
if (enumName != "")
{
string symbol = MetaData.getSymbolFromEnum(enumName, value);
if (symbol != "")
{
string originalText = match.Value;
startPos = originalText.IndexOf("<Value>");
endPos = originalText.IndexOf("</Value>") + "</Value>".Length;
string updatedText;
if (startPos != -1)
{
updatedText = originalText.Remove(startPos, endPos - startPos);
}
else
{
startPos = originalText.IndexOf("</Name>") + "</Name>".Length;
endPos = originalText.IndexOf("<" + token + ">");
string whiteSpace = originalText.Substring(startPos, endPos - startPos);
int iPos = whiteSpace.IndexOf("<");
if (iPos != -1)
{
whiteSpace = whiteSpace.Substring(1, iPos - 1);
}
startPos = originalText.IndexOf("</" + token + ">") + ("</" + token + ">").Length;
updatedText = originalText.Insert(startPos, whiteSpace);
startPos += whiteSpace.Length;
}
updatedText = updatedText.Insert(startPos, "<ValueStr>" + enumName + "::" + symbol + "</ValueStr>");
string updatedInput = input.Remove(match.Index, match.Length);
updatedInput = updatedInput.Insert(match.Index, updatedText);
Hits++;
return(this.Run(updatedInput, match.Index + match.Length));
}
else
{
if (enumName != "NoYes" &&
enumName != "Boolean")
{
Debug.WriteLine(string.Format("{0} references non existing value {1} in enum {2} via constraint on field {3}", Scanner.FILENAME, value, enumName, fieldName));
}
}
}
}
return(this.Run(input, match.Index + match.Length));
}
return(input);
}
