/// <summary>
/// Clean the top level menu items by removing unit test data
/// </summary>
/// <param name="menuitems"></param>
/// <param name="user"></param>
/// <returns></returns>
public MainMenuModels CleanMainMenuModel_deprecated(MainMenuModels menuitems, UserModel user)
{
MainMenuModels displayMenuItems = null;
if (menuitems?.MenuItems == null || !menuitems.MenuItems.Any() || user == null)
{
return(null);
}
displayMenuItems = new MainMenuModels();
foreach (var menuitem in menuitems.MenuItems)
{
//filter out the unit testing menu items - only assigned to super users
if (user.SuperUser)
{
if (!menuitem.DisplayText.ToLower().Contains("unit test"))
{
displayMenuItems.MenuItems.Add(menuitem);
}
}
else
{
displayMenuItems.MenuItems.Add(menuitem);
}
}
return(displayMenuItems);
}
/// <summary>
/// Clean the menu items by removing unit test data
/// </summary>
/// <param name="menuitems"></param>
/// <param name="user"></param>
/// <returns></returns>
public MainMenuModels CleanMainMenuModel(MainMenuModels menuitems, UserModel user)
{
MainMenuModels displayMenuItems = null;
if (menuitems?.MenuItems == null || !menuitems.MenuItems.Any() || user == null)
{
return(null);
}
displayMenuItems = menuitems;
if (user.SuperUser)
{
foreach (var menuitem in displayMenuItems.MenuItems.ToList())
{
if (menuitem.DisplayText.ToLower().Contains("unit test"))
{
displayMenuItems.MenuItems.Remove(menuitem);
var children = displayMenuItems.MenuItems.FindAll(m => m.ParentId == menuitem.Id);
if (children.Any())
{
displayMenuItems.MenuItems.RemoveAll(m => m.ParentId == menuitem.Id);
}
}
}
}
return(displayMenuItems);
}
private static MainMenuModels GetUnitTestMenu()
{
MainMenuModels menu = new MainMenuModels {
MenuItems = new List <MainMenuModel>()
};
MainMenuModel menuitem = new MainMenuModel
{
DisplayText = "Unit Test Admin",
Id = 1
};
menu.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Unit Test Development",
Id = 2
};
menu.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Unit Test Testing",
Id = 3
};
menu.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Unit Test Design",
Id = 4
};
menu.MenuItems.Add(menuitem);
return(menu);
}
public void CleanMainMenuModelInvalidTests()
{
//Arrange
UserModel user = new UserModel
{
Email = "*****@*****.**",
SuperUser = true
};
//Act
var cleanMenu = new MenuServices().CleanMainMenuModel(null, user);
//Assert
Assert.IsNull(cleanMenu);
MainMenuModels menu = new MainMenuModels {
MenuItems = null
};
cleanMenu = new MenuServices().CleanMainMenuModel(menu, user);
//Assert
Assert.IsNull(cleanMenu);
menu = MenuServicesTests.GetUnitTestMenu();
cleanMenu = new MenuServices().CleanMainMenuModel(menu, null);
//Assert
Assert.IsNull(cleanMenu);
}
public void GetParentIdForMenuItemInvalidTests()
{
//Arrange
var menu = MenuServicesTests.GetUnitTestMenu();
//Act - fetch the parent ID
MenuServices services = new MenuServices();
int parentId = services.GetParentIdForMenuItem("", menu);
//Assert
Assert.AreEqual(-1, parentId);
parentId = services.GetParentIdForMenuItem(null, menu);
//Assert
Assert.AreEqual(-1, parentId);
parentId = services.GetParentIdForMenuItem("Unit Test Testing", null);
//Assert
Assert.AreEqual(-1, parentId);
menu = new MainMenuModels {
MenuItems = null
};
parentId = services.GetParentIdForMenuItem("Unit Test Testing", menu);
//Assert
Assert.AreEqual(-1, parentId);
}
/// <summary>
/// Fetch the parent ID for the specified menu item Display Text
/// </summary>
/// <param name="menuitem"></param>
/// <param name="menuitems"></param>
/// <returns></returns>
public int GetParentIdForMenuItem(string menuitem, MainMenuModels menuitems)
{
int result = -1;
if (string.IsNullOrEmpty(menuitem) || menuitems?.MenuItems == null)
{
return(result);
}
var foundMenuItem = menuitems.MenuItems.Find(m => m.DisplayText == menuitem);
if (foundMenuItem != null)
{
result = foundMenuItem.Id;
}
return(result);
}
/// <summary>
/// Fetch the menu items for the specified user and menu level
/// </summary>
/// <param name="useremail"></param>
/// <param name="parentId"></param>
/// <param name="rooturl"></param>
/// <param name="encodedId"></param>
/// <returns></returns>
public async Task <MainMenuModels> GetModulesItemsForUser(string useremail, int parentId, string rooturl, string encodedId)
{
MainMenuModels result = null;
if (string.IsNullOrEmpty(useremail) || string.IsNullOrEmpty(rooturl) || string.IsNullOrEmpty(encodedId) ||
parentId < 0)
{
return(null);
}
string queryname = WebTasksTypeConstants.GetMenuItemsForModuleByUser;
string queryterms = WebApiServices.GetMenuItemsJsonQuerySearchTerms(useremail, parentId);
string url = $"{rooturl}api/webtasks?queryname={queryname}&queryterms={queryterms}";
LoggingService service = new LoggingService();
var stopwatch = new Stopwatch();
try
{
var response = await new WebApiServices().GetData(url, encodedId);
if (!string.IsNullOrEmpty(response) && response.Length > 0)
{
result = new SerializerServices().DeserializeObject <MainMenuModels>(response.NormalizeJsonString());
}
}
catch (Exception ex)
{
service.TrackException(ex);
throw;
}
finally
{
stopwatch.Stop();
var properties = new Dictionary <string, string>
{
{ "UserEmail", useremail },
{ "WebServicesEndpoint", rooturl },
{ "EncodedId", encodedId },
{ "ParentId", parentId.ToString() }
};
service.TrackEvent(LoggingServiceConstants.GetModulesItemsForUserForParentId, stopwatch.Elapsed, properties);
}
return(result);
}
public async Task InvokeAsyncTest()
{
MenuItemsViewComponent component = new MenuItemsViewComponent();
var mockContext = MenuItemsViewComponentTests.MockHttpContext();
string email = mockContext.Get <string>(SessionConstants.EmailClaim);
string url = mockContext.Get <string>(SessionConstants.WebServicesUrl);
string encodedId = mockContext.Get <string>(SessionConstants.EncodedUserId);
MainMenuModels menuitems = mockContext.Get <MainMenuModels>(SessionConstants.TopLevelMenuItems);
UserModel user = mockContext.Get <UserModel>(SessionConstants.CurrentUser);
Assert.AreEqual(MenuItemsViewComponentTests.UserEmail, email);
Assert.AreEqual(MenuItemsViewComponentTests.Endpoint, url);
Assert.IsNotNull(encodedId);
Assert.IsNull(menuitems);
Assert.IsNotNull(user);
Assert.AreEqual(MenuItemsViewComponentTests.UserEmail, user.Email);
var result = await component.InvokeAsync(0, mockContext);
Assert.IsNotNull(result);
}
/// <summary>
/// Convert a menu of type <see cref="MainMenuModels"/> into a tree structure of type <see cref="TreeViewItemModel"/>
/// as used by the Kendo UI tree component.
/// </summary>
/// <param name="mainmenu">An instance of <seealso cref="MainMenuModels"/></param>
/// <returns>A list of <see cref="TreeViewItemModel"/></returns>
public static List <TreeViewItemModel> ToKendoTreeViewItemModelList(this MainMenuModels mainmenu)
{
List <Kendo.Mvc.UI.TreeViewItemModel> result = null;
if (mainmenu?.MenuItems == null || !mainmenu.MenuItems.Any())
{
return(null);
}
var topMenuItems = MainMenuModelsExtensions.GetChildItems(mainmenu, 0);
result = new List <TreeViewItemModel>();
foreach (var topMenuItem in topMenuItems)
{
TreeViewItemModel topMenuTreeItem = MainMenuModelsExtensions.CreateKendoTreeViewModel(topMenuItem);
var children = MainMenuModelsExtensions.GetChildItems(mainmenu, topMenuItem.Id);
if (children != null && children.Any())
{
foreach (var child in children)
{
var subTopTree = MainMenuModelsExtensions.CreateKendoTreeViewModel(child);
topMenuTreeItem.Items.Add(subTopTree);
var subchildren = MainMenuModelsExtensions.GetChildItems(mainmenu, child.Id);
if (subchildren == null || !subchildren.Any())
{
continue;
}
foreach (var subchild in subchildren)
{
subTopTree.Items.Add(MainMenuModelsExtensions.CreateKendoTreeViewModel(subchild));
}
}
}
result.Add(topMenuTreeItem);
}
return(result);
}
public async Task InvokeAsyncTest()
{
SubFormMenuViewComponent component = new SubFormMenuViewComponent();
var mockContext = SubFormMenuViewComponentTests.MockHttpContext();
const int parentId = 17;
string email = mockContext.Get <string>(SessionConstants.EmailClaim);
string url = mockContext.Get <string>(SessionConstants.WebServicesUrl);
string encodedId = mockContext.Get <string>(SessionConstants.EncodedUserId);
MainMenuModels menuitems = mockContext.Get <MainMenuModels>(SessionConstants.CompanyAdministrationMenuItems);
UserModel user = mockContext.Get <UserModel>(SessionConstants.CurrentUser);
Assert.AreEqual(SubFormMenuViewComponentTests.UserEmail, email);
Assert.AreEqual(SubFormMenuViewComponentTests.Endpoint, url);
Assert.IsNotNull(encodedId);
Assert.IsNull(menuitems);
Assert.IsNotNull(user);
Assert.AreEqual(SubFormMenuViewComponentTests.UserEmail, user.Email);
var result = await component.InvokeAsync(parentId, SessionConstants.CompanyAdministrationMenuItems, new MainMenuModels(), mockContext);
Assert.IsNotNull(result);
}
private static MainMenuModels CreateMainMenu()
{
MainMenuModels result = new MainMenuModels {
MenuItems = new List <MainMenuModel>()
};
MainMenuModel menuitem = new MainMenuModel
{
DisplayText = "Admin",
ParentId = 0,
Id = 1
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Company Admin",
ParentId = 1,
Id = 2
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Add Company",
ParentId = 2,
Id = 3
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Role Admin",
ParentId = 1,
Id = 4
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "User Admin",
ParentId = 1,
Id = 5
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Document Manager",
ParentId = 0,
Id = 6
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Upload",
ParentId = 6,
Id = 7
};
result.MenuItems.Add(menuitem);
menuitem = new MainMenuModel
{
DisplayText = "Download",
ParentId = 6,
Id = 8
};
result.MenuItems.Add(menuitem);
return(result);
}
private static List <MainMenuModel> GetChildItems(MainMenuModels menuitems, int menuId)
{
return(menuitems.MenuItems.FindAll(m => m.ParentId == menuId));
}
/// <summary>
/// Creates a sub-form-level menu blade
/// </summary>
/// <param name="parentId">The parent ID of the menu item</param>
/// <param name="menuname">The name of the menu as stored in HTTP session storage</param>
/// <param name="formmenu">An instance of <see cref="MainMenuModels"/> to populate</param>
/// <param name="context">The context session - used for mocking the HTTP context for unit testing.</param>
/// <returns></returns>
public async Task <IViewComponentResult> InvokeAsync(int parentId, string menuname, MainMenuModels formmenu, ISession context = null)
{
//for unit-testing we pass in an instance of HttpContext.Session to allow for mocking the environment
if (context == null)
{
context = HttpContext.Session;
}
if (context.Get <MainMenuModels>(menuname) == null)
{
LoggingService service = new LoggingService();
var stopwatch = new Stopwatch();
try
{
formmenu = await new MenuServices().GetModulesItemsForUser(
context.Get <string>(SessionConstants.EmailClaim),
parentId,
context.Get <string>(SessionConstants.WebServicesUrl),
context.Get <string>(SessionConstants.EncodedUserId));
context.Set <MainMenuModels>(menuname, formmenu);
}
catch (Exception ex)
{
service.TrackException(ex);
throw;
}
finally
{
stopwatch.Stop();
var properties = new Dictionary <string, string>
{
{ "UserEmail", context.Get <string>(SessionConstants.EmailClaim) },
{ "WebServicesEndpoint", context.Get <string>(SessionConstants.WebServicesUrl) },
{ "EncodedId", context.Get <string>(SessionConstants.EncodedUserId) }
};
service.TrackEvent(LoggingServiceConstants.GetModulesItemsForUser, stopwatch.Elapsed, properties);
}
}
else
{
formmenu = context.Get <MainMenuModels>(menuname);
}
return(View(formmenu));
}
