private static void ParseApplicationXMLModel(ApplicationXMLModel anApplicationModel)
{
foreach (MenuItemModel menuItem in anApplicationModel.MenuItems.Children)
{
MenuItemIterator(menuItem, anApplicationModel);
}
}
/// <summary>
/// Load all UXActions from the UXAction folder
/// </summary>
/// <param name="aPath"></param>
/// <param name="anApplications"></param>
private static void LoadUXActions(string aPath, Dictionary<string, ApplicationXMLModel> anApplications)
{
try
{
string[] moduleDirectoryEntries = Directory.GetDirectories(aPath);
foreach (string subDirectoryName in moduleDirectoryEntries)
{
ApplicationXMLModel app;
string appName;
bool isFrontend = subDirectoryName.Contains("_Frontend");
if (isFrontend)
{
DirectoryInfo dirInfo = new DirectoryInfo(subDirectoryName);
appName = dirInfo.Name.Split('_').First();
if (anApplications.ContainsKey(appName))
{
app = anApplications[appName];
}
else
{
app = new ApplicationXMLModel();
app.Name = appName;
anApplications.Add(appName, app);
}
string[] uXActionFileNames = Directory.GetFiles(subDirectoryName + "\\UXAction");
foreach (string uXActionPath in uXActionFileNames)
{
try
{
XmlDocument document = LoadXMLDocument(uXActionPath);
if (document != null)
{
string key = document.SelectSingleNode("/UXAction/Id").InnerText;
app.UXActionXMLDocuments.Documents.Add(key, document);
}
}
catch (Exception ex)
{
//If file size is 0 then ignore the error and continue
if (new FileInfo(uXActionPath).Length > 0)
{
throw ex;
}
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Method used to read the metamenu file generated from this application.
/// </summary>
/// <param name="aPath">The path to were the file is that we want to read from</param>
/// <param name="anApplications">A Dictionary that will be populated with XML data</param>
private static void LoadMenus(string aPath, Dictionary <string, ApplicationXMLModel> anApplications)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(aPath);
//Read the applications. e.g. Warehouse, Transportation
XmlNode applicationsNode = doc.SelectSingleNode("/Applications");
foreach (XmlNode applicationNode in applicationsNode)
{
ApplicationXMLModel application = new ApplicationXMLModel();
//Give the RootNode a name e.g. Warehouse
XmlNode applicationNameNode = applicationNode.SelectSingleNode("Name");
ThrowIfNull(applicationNameNode,
"applicationNameNode was null in LoadMenus method");
application.Name = applicationNameNode.InnerText;
XmlNode topMenuItemNode = applicationNode.SelectSingleNode("Menu/MenuItem");
ThrowIfNull(applicationNameNode,
"topMenuItemNode was null in LoadMenus method");
MenuItemModel topMenuItemModel = new MenuItemModel();
XmlNode captionTopMenuItemNode = topMenuItemNode.SelectSingleNode("Caption");
ThrowIfNull(captionTopMenuItemNode,
"captionTopMenuItemNode was null in LoadMenus method");
topMenuItemModel.Caption = captionTopMenuItemNode.InnerText;
XmlNode identityTopMenuItemNode = topMenuItemNode.SelectSingleNode("Id");
ThrowIfNull(identityTopMenuItemNode,
"identityTopMenuItemNode was null in LoadMenus method");
topMenuItemModel.Identity = identityTopMenuItemNode.InnerText;
topMenuItemModel.Actions = null;
XmlNode topMenuChildrenNode = topMenuItemNode.SelectSingleNode("Children");
ThrowIfNull(topMenuChildrenNode,
"topMenuChildrenNode was null in LoadMenus method");
foreach (XmlNode menuItemChildren in topMenuChildrenNode)
{
MenuItemModel menuItemModel = LoadMenu(menuItemChildren);
ThrowIfNull(menuItemModel, "A child node in topMenu was null in LoadMenus method");
topMenuItemModel.Children.Add(menuItemModel);
}
application.MenuItems = topMenuItemModel;
anApplications.Add(application.Name, application);
}
}
catch (Exception ex)
{
if (ex is FileNotFoundException)
{
MessageBox.Show("MetaMenu.XML not found!", "", MessageBoxButtons.OK);
}
}
}
private static MenuItemModel LoadMetaData(string aPath)
{
//LoadDialogAndUXActionMetaData returns null?
ApplicationXMLModel application = LoadDialogAndUXActionMetaData(aPath);
LoadMenus(aPath, _applications);
return null;
}
/// <summary>
/// Init the variables and call the Load methods for Dialogs and UXActions
/// </summary>
/// <param name="aPath"></param>
/// <returns></returns>
private static ApplicationXMLModel LoadDialogAndUXActionMetaData(string aPath)
{
ApplicationXMLModel metaDataModel = new ApplicationXMLModel();
metaDataModel.DialogXmlDocuments = new DialogXMLModel();
metaDataModel.UXActionXMLDocuments = new UXActionXMLModel();
LoadDialogs(aPath, _applications);
LoadUXActions(aPath, _applications);
return null;
}
/// <summary>
/// Method that loads the main MenuItem then all child MenuItems
/// </summary>
/// <param name="aPath"></param>
/// <param name="anApplications"></param>
private static void LoadMenus(string aPath, Dictionary<string, ApplicationXMLModel> anApplications)
{
try
{
string[] moduleDirectoryEntries = Directory.GetDirectories(aPath);
foreach (string subDirectoryName in moduleDirectoryEntries)
{
ApplicationXMLModel app;
//Backend folders are not used
string appName;
bool isFrontend = subDirectoryName.Contains("_Frontend");
if (isFrontend)
{
DirectoryInfo dirInfo = new DirectoryInfo(subDirectoryName);
appName = dirInfo.Name.Split('_').First();
if (anApplications.ContainsKey(appName))
{
app = anApplications[appName];
}
else
{
app = new ApplicationXMLModel();
app.Name = appName;
anApplications.Add(appName, app);
}
string[] menuFileNames = Directory.GetFiles(subDirectoryName + "\\Menu");
foreach (string menuPath in menuFileNames)
{
XmlDocument doc = new XmlDocument();
doc.Load(menuPath);
XmlNode node = doc.SelectSingleNode("/Menu/TopMenuItem/MenuItem");
//For each child MenuItem add a MenuItem under the tag Children for this Menuitem
MenuItemModel menuItemModel = LoadMenu(node, _applications[appName]);
if (menuItemModel != null)
{
app.MenuItems = menuItemModel;
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private static void MenuItemIterator(MenuItemModel aMenuItem, ApplicationXMLModel anApplicationModel)
{
if (MenuItemHasChildren(aMenuItem))
{
foreach (MenuItemModel menuItemChild in aMenuItem.Children)
{
MenuItemIterator(menuItemChild, anApplicationModel);
}
}
else
{
ParseUXAction(aMenuItem, anApplicationModel);
}
}
private static void ParseUXAction(MenuItemModel aMenuItem, ApplicationXMLModel anApplicationModel)
{
string actionIdentity = aMenuItem.Actions.FirstOrDefault().Identity;
XmlDocument uXActionDoc = anApplicationModel.UXActionXMLDocuments.Documents[actionIdentity];
string dialogId;
XmlNode dialogIdNode = uXActionDoc.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
if (dialogIdNode != null)
{
dialogId = dialogIdNode.InnerText;
XmlDocument dialogDoc = anApplicationModel.DialogXmlDocuments.Documents[dialogId];
ParseDialog(aMenuItem, anApplicationModel, dialogDoc);
}
}
private static MenuItemModel GetUXActionsFromNode(XmlNode aViewActionNode, ApplicationXMLModel anApplicationModel)
{
string errorMessageString = "{0} was null in function ActionParser.GetUXActionsFromNode";
MenuItemModel menuItem = new MenuItemModel();
UXAction uXAction = new UXAction();
XmlNode actionIdentityNode = aViewActionNode.SelectSingleNode("Action/UXAction/Id");
ThrowIfNull(actionIdentityNode, string.Format(errorMessageString, "actionIdentityNode"));
uXAction.Identity = actionIdentityNode.InnerText;
XmlNode uXActionNode = anApplicationModel.UXActionXMLDocuments.Documents[uXAction.Identity];
ThrowIfNull(uXActionNode, string.Format(errorMessageString, "uXActionNode"));
XmlNode uXActionCaptionNode = uXActionNode.SelectSingleNode("/UXAction/Caption");
ThrowIfNull(uXActionCaptionNode, string.Format(errorMessageString, "uXActionCaptionNode"));
menuItem.Caption = uXActionCaptionNode.InnerText;
XmlNode viewActionTypeNode = aViewActionNode.SelectSingleNode("Type");
if (viewActionTypeNode != null)
{
if (viewActionTypeNode.InnerText == "JumpTo")
{
AddShowActionToCorrectStartAction(aViewActionNode, anApplicationModel);
return(null);
}
else if (viewActionTypeNode.InnerText == "Drilldown")
{
menuItem.Caption += " (Drilldown)";
AddDrilldownsActionChildren(uXActionNode, menuItem, anApplicationModel);
}
}
XmlNode uxActionDialogNode = aViewActionNode.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
if (uxActionDialogNode != null)
{
menuItem.Identity = uxActionDialogNode.InnerText;
}
menuItem.Actions = new List <UXAction>();
menuItem.Actions.Add(uXAction);
return(menuItem);
}
private static void AddShowActionToCorrectStartAction(XmlNode aViewNode, ApplicationXMLModel anApplicationModel)
{
try
{
//find dialog in applicatinXMLModel using viewnodes UXAction/ID
string startActionIdentity = GetStartActionFromUXAction(aViewNode, anApplicationModel);
//dialog id is also start action id, iterate applicationmodels menuItems and find
//menuitem with the Start action id, add show action id to menuitems actions
MoveShowActionToStartAction(startActionIdentity, aViewNode, anApplicationModel);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Method that builds XML.
/// An application e.g. Warehouse has a menu called Warehouse
/// with children called Inbound, Outbound, etc
/// whom each have children e.g Inbound Overview
/// </summary>
/// <param name="anApplicationXmlModel"></param>
/// <param name="anApplicationElement"></param>
/// <returns></returns>
private static XmlElement CreateApplicationElem(ApplicationXMLModel anApplicationXmlModel, XmlElement anApplicationElement)
{
XmlDocument doc = anApplicationElement.OwnerDocument;
XmlElement applicationElem = doc.CreateElement("Application");
XmlElement applicationNameElement = doc.CreateElement("Name");
applicationNameElement.InnerText = anApplicationXmlModel.Name;
applicationElem.AppendChild(applicationNameElement);
XmlElement menuElement = doc.CreateElement("Menu");
applicationElem.AppendChild(menuElement);
XmlElement topMenuItemElement = doc.CreateElement("MenuItem");
menuElement.AppendChild(topMenuItemElement);
XmlElement captionElement = doc.CreateElement("Caption");
captionElement.InnerText = anApplicationXmlModel.MenuItems.Caption;
topMenuItemElement.AppendChild(captionElement);
XmlElement idElement = doc.CreateElement("Id");
idElement.InnerText = anApplicationXmlModel.MenuItems.Identity;
topMenuItemElement.AppendChild(idElement);
XmlElement actionsElement = doc.CreateElement("Actions");
topMenuItemElement.AppendChild(actionsElement);
XmlElement childrenElement = doc.CreateElement("Children");
topMenuItemElement.AppendChild(childrenElement);
foreach (MenuItemModel item in anApplicationXmlModel.MenuItems.Children)
{
XmlElement childElement = LoadChildElement(childrenElement, item);
if (childElement != null)
{
childrenElement.AppendChild(childElement);
}
}
return(applicationElem);
}
private static void ProcessActions(MenuItemModel menuitem, ApplicationXMLModel anApplication)
{
try
{
if (menuitem.Actions == null) return;
foreach (UXAction action in menuitem.Actions)
{
string newIdentity;
if (action == null) continue;
var uxActionNode = anApplication.UXActionXMLDocuments.Documents[action.Identity];
if (uxActionNode == null) continue;
var uxActionCaptionNode = uxActionNode.SelectSingleNode("/UXAction/Caption");
var dialogIdentityNode = uxActionNode.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
if (dialogIdentityNode == null) continue;
var dialogIdentityDoc = anApplication.DialogXmlDocuments.Documents[dialogIdentityNode.InnerText];
if (dialogIdentityNode == null) continue;
newIdentity = dialogIdentityNode.InnerText;
var uxCaption = uxActionCaptionNode.InnerText;
var dialogTitleNode = dialogIdentityDoc.SelectSingleNode("/Dialog/Title");
if (dialogTitleNode == null) continue;
var dialogTitle = dialogTitleNode.InnerText;
if (uxCaption.Equals(dialogTitle)) continue;
var uxActionNameNode = uxActionNode.SelectSingleNode("/UXAction/Name");
var uxName = uxActionNameNode.InnerText;
var dialogNameNode = dialogIdentityDoc.SelectSingleNode("/Dialog/Name");
var dialogName = dialogNameNode.InnerText;
uxName = uxName.ToUpper();
dialogName = dialogName.ToUpper();
if (uxName.Equals(dialogName)) continue;
if (uxName.StartsWith("SHOW") && !dialogName.StartsWith("SHOW")) continue;
action.Identity = newIdentity;
}
}
catch (Exception)
{
throw;
}
}
private static void ProcessMenuItem(List<MenuItemModel> aMenuItems, ApplicationXMLModel anApplication)
{
try
{
foreach (MenuItemModel menuItem in aMenuItems)
{
if (menuItem != null)
{
ProcessActions(menuItem, anApplication);
ProcessMenuItem(menuItem.Children, anApplication);
}
}
}
catch (Exception)
{
throw;
}
}
private static string GetStartActionFromUXAction(XmlNode aViewNode, ApplicationXMLModel anApplicationModel)
{
XmlNode uXActionIdentityNode = aViewNode.SelectSingleNode("Action/UXAction/Id");
if (uXActionIdentityNode == null)
{
return(null);
}
string uXActionIdentity = uXActionIdentityNode.InnerText;
XmlDocument uXActionDoc = anApplicationModel.UXActionXMLDocuments.Documents[uXActionIdentity];
XmlNode dialogIdentityNode = uXActionDoc.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
if (dialogIdentityNode == null)
{
return(null);
}
return(dialogIdentityNode.InnerText);
}
private static void ParseDialog(MenuItemModel aMenuItem, ApplicationXMLModel anApplicationModel, XmlDocument dialogDoc)
{
string errorMessageString = "{0} was null in function ActionParser.ParseDialog";
//läs in alla actions från dialogDoc och lägg dem i aMenuItem
try
{
XmlNode viewActionsNode = dialogDoc.SelectSingleNode("/Dialog/RootViewNode/ViewNode/ViewActions");
ThrowIfNull(viewActionsNode, string.Format(errorMessageString, "viewActionsNode"));
List <MenuItemModel> mainActions = new List <MenuItemModel>();
foreach (XmlNode viewActionNode in viewActionsNode.ChildNodes)
{
MenuItemModel menuItem = GetUXActionsFromNode(viewActionNode, anApplicationModel);
if (menuItem != null)
{
XmlNode sequenceNode = viewActionNode.SelectSingleNode("Sequence");
menuItem.Sequence = int.Parse(sequenceNode.InnerText);
mainActions.Add(menuItem);
}
}
mainActions.Sort();
aMenuItem.Children.AddRange(mainActions);
XmlNode viewNodeChildrenNode = dialogDoc.SelectSingleNode("/Dialog/RootViewNode/ViewNode/Children");
ThrowIfNull(viewNodeChildrenNode, string.Format("viewNodeChildrenNode"));
foreach (XmlNode childViewNode in viewNodeChildrenNode)
{
AddActionsToMenuItem(aMenuItem, childViewNode, anApplicationModel);
}
}
catch (Exception ex)
{
throw ex;
}
}
private static void AddActionsToMenuItem(MenuItemModel aMenuItem, XmlNode aViewNode, ApplicationXMLModel anApplicationModel)
{
//Add current viewNode actions to aMenuItem.Children
XmlNode viewActionsNode = aViewNode.SelectSingleNode("ViewActions");
List <MenuItemModel> childList = new List <MenuItemModel>();
if (viewActionsNode != null)
{
foreach (XmlNode viewActionNode in viewActionsNode.ChildNodes)
{
MenuItemModel menuItem = GetUXActionsFromNode(viewActionNode, anApplicationModel);
XmlNode sequenceNode = viewActionNode.SelectSingleNode("Sequence");
if (sequenceNode != null && menuItem != null)
{
menuItem.Sequence = int.Parse(sequenceNode.InnerText);
childList.Add(menuItem);
}
}
childList.Sort();
aMenuItem.Children.AddRange(childList);
}
//check if aViewNode has any children, call self recursively
XmlNode children = aViewNode.SelectSingleNode("Children");
if (children != null)
{
foreach (XmlNode childViewNode in children)
{
AddActionsToMenuItem(aMenuItem, childViewNode, anApplicationModel);
}
}
}
private static void AddDrilldownsActionChildren(XmlNode uXActionNode, MenuItemModel aMenuItem, ApplicationXMLModel anApplicationModel)
{
XmlNode dialogIdentityNode = uXActionNode.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
if (dialogIdentityNode == null)
{
return;
}
ParseDialog(aMenuItem, anApplicationModel, anApplicationModel.DialogXmlDocuments.Documents[dialogIdentityNode.InnerText]);
}
private static void MoveShowActionToStartAction(string aStartActionIdentity, XmlNode aViewNode, ApplicationXMLModel anApplicationModel)
{
XmlNode uXActionIdentityNode = aViewNode.SelectSingleNode("Action/UXAction/Id");
if (uXActionIdentityNode == null)
{
return;
}
string uXActionIdentity = uXActionIdentityNode.InnerText;
MenuItemModel menuItemResult = FindStartItem(aStartActionIdentity, anApplicationModel.MenuItems);
if (menuItemResult == null)
{
return;
}
if (ActionsContainsIdentity(menuItemResult.Actions, uXActionIdentity))
{
return;
}
menuItemResult.Actions.Add(new UXAction {
Identity = uXActionIdentity, Parent = aStartActionIdentity
});
}
/// <summary>
/// Method that searches for children of a MenuItem
/// and connects that child to the parent MenuItem
/// </summary>
/// <param name="aNode">A menuItem</param>
/// <param name="depth">0 = children, 1 = grandchildren, etc</param>
/// <returns>A child MenuItem</returns>
private static MenuItemModel LoadMenu(XmlNode aNode, ApplicationXMLModel anApplication, int depth = 0)
{
try
{
MenuItemModel menu = new MenuItemModel();
menu.Identity = aNode.SelectSingleNode("Id").InnerText;
menu.Caption = aNode.SelectSingleNode("Caption").InnerText;
if (IdentityExceptionHelper.Contains(menu.Caption)) return null;
XmlNode sequenceNode = aNode.SelectSingleNode("Sequence");
if (sequenceNode != null) menu.Sequence = int.Parse(sequenceNode.InnerText);
UXAction action = new UXAction();
XmlNode uXActionIdentityNode = aNode.SelectSingleNode("Action/UXAction/Id");
if (uXActionIdentityNode != null)
{
action.Identity = uXActionIdentityNode.InnerText;
//load ux-file
XmlDocument uXDoc = anApplication.UXActionXMLDocuments.Documents[action.Identity];
XmlNode uXDialogNode = uXDoc.SelectSingleNode("/UXAction/Dialog/Dialog/Id");
//insert check if has dialog and if dialog is a Start-operation
if (uXDialogNode != null)
{
XmlDocument dialogDoc = anApplication.DialogXmlDocuments.Documents[uXDialogNode.InnerText];
XmlNode dialogIdNode = dialogDoc.SelectSingleNode("/Dialog/Id");
if (dialogIdNode != null)
{
//if it is a start-action, swap action.Identity for the dialog identity
action.Parent = dialogIdNode.InnerText;
}
}
}
if (!string.IsNullOrEmpty(action.Identity))
{
if (menu.Actions == null)
{
menu.Actions = new List<UXAction>();
}
menu.Actions.Add(action);
}
XmlNode children = aNode.SelectSingleNode("Children");
if (children != null)
{
foreach (XmlNode child in children)
{
//Recursive call to this method in case there are grandchildren and beyond.
MenuItemModel childMenuItem = LoadMenu(child, anApplication, ++depth);
if (childMenuItem != null && menu.Children == null)
{
menu.Children = new List<MenuItemModel>();
}
if (childMenuItem != null)
{
menu.Children.Add(childMenuItem);
}
}
}
return menu;
}
catch (Exception)
{
return null;
}
}
