public void DeleteBookmark_Success_ReturnHttpStatusCode()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//call delete with successful HttpStatusCode
bookmarkRepo.Setup(x => x.DeleteBookmark(1)).Returns(HttpStatusCode.Accepted);
var result = controller.DeleteBookmark(1);
Assert.AreEqual(result, HttpStatusCode.Accepted);
}
public void GetBookmark_NoTitle_ThrowException()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//call get bookmark that will throw exception
bookmarkRepo.Setup(x => x.GetBookmark("test")).Throws(new HttpResponseException(HttpStatusCode.Conflict));
controller.GetBookmark("test");
Assert.Fail();
}
public void DeleteBookmark_BookmarkNotFound_ThrowsException()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//call delete that will throw exception
bookmarkRepo.Setup(x => x.DeleteBookmark(1)).Throws(new HttpResponseException(HttpStatusCode.Conflict));
controller.DeleteBookmark(1);
Assert.Fail();
}
public void FavouriteBookmark_UserIsNull_ThrowException()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//needs refactoring
bookmarkRepo.Setup(x => x.FavouriteBookmark(1, 1)).Throws(new HttpRequestException("Id not found"));
controller.FavouriteBookmark(1, 1);
Assert.Fail();
}
public BookmarksPivotViewModel(
ThisBookBookmarksViewModel thisBookBookmarksViewModel,
AllBooksBookmarksViewModel allBooksBookmarksViewModel,
INavigationService navigationService,
IBookRepository bookRepository,
IBookmarkRepository bookmarkRepository,
BookmarksController bookmarksController,
BookTool bookTool)
{
_thisBookBookmarksViewModel = thisBookBookmarksViewModel;
_allBooksBookmarksViewModel = allBooksBookmarksViewModel;
_navigationService = navigationService;
_bookRepository = bookRepository;
_bookmarkRepository = bookmarkRepository;
_bookmarksController = bookmarksController;
_bookTool = bookTool;
}
public void CreateBookmark_BookmarkIsNull_ThrowsException()
{
//make mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//create bookmark with null as Bookmark that will throw exception
bookmarkRepo.Setup(x => x.CreateBookmark(null, "test")).Throws(new HttpResponseException(HttpStatusCode.Conflict));
controller.CreateBookmark(new CreateJson {
Bookmark = null, Username = "******"
});
Assert.Fail();
}
public void CreateBookmark_Success_ReturnBookmark()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
var newBookmark = new Bookmark()
{
BookmarkId = 1,
AuthorId = 1,
Date = DateTime.Now,
Link = "link",
Title = "title",
Users = new List <User>()
};
var bookmark = new Mock <Bookmark>();
bookmark.Object.BookmarkId = newBookmark.BookmarkId;
bookmark.Object.AuthorId = newBookmark.AuthorId;
bookmark.Object.Date = newBookmark.Date;
bookmark.Object.Link = newBookmark.Link;
bookmark.Object.Title = newBookmark.Title;
bookmark.Object.Users = newBookmark.Users;
//call bookmark successfully
bookmarkRepo.Setup(x => x.CreateBookmark(bookmark.Object, "test")).Returns(newBookmark);
var result = controller.CreateBookmark(new CreateJson {
Bookmark = bookmark.Object, Username = "******"
});
bool id = newBookmark.BookmarkId == result.BookmarkId;
bool author = newBookmark.AuthorId == result.AuthorId;
bool date = newBookmark.Date == result.Date;
bool link = newBookmark.Link == result.Link;
bool title = newBookmark.Title == result.Title;
bool users = newBookmark.Users.Equals(result.Users);
Assert.IsTrue(id && author && date && link && title && users);
}
public void FavouriteBookmark_Success_ReturnUsers()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
List <User> sample;
//call FavouriteBookmark and return list of users
bookmarkRepo.Setup(x => x.FavouriteBookmark(1, 1)).Returns(sample = new List <User>());
var result = controller.FavouriteBookmark(1, 1);
bool users = sample.Equals(result);
Assert.IsTrue(users);
}
public void EditBookmark_BookmarkIsNull_ThrowsException()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
//call edit when bookmark is null to throw exception
bookmarkRepo.Setup(x => x.EditBookmark(1, null)).Throws(new HttpResponseException(HttpStatusCode.Conflict));
controller.EditBookmark(new EditJson {
Bookmark = null, UserId = 1
});
Assert.Fail();
}
public void CreateBookmark_UserIsNotFound_ThrowsException()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
var bookmark = new Mock <Bookmark>();
bookmarkRepo.Setup(x => x.CreateBookmark(bookmark.Object, "test")).Throws(new HttpRequestException("Username not found"));
//needs refactoring to test
controller.CreateBookmark(new CreateJson {
Bookmark = new Bookmark(), Username = "******"
});
Assert.Fail();
}
public void EditBookmark_Success_ReturnBookmark()
{
//create mock objects
var bookmarkRepo = new Mock <IBookmarkRepository>();
var controller = new BookmarksController(bookmarkRepo.Object);
var newBookmark = new Bookmark()
{
BookmarkId = 1,
AuthorId = 1,
Date = DateTime.Now,
Link = "link",
Title = "title",
Users = new List <User>()
};
var bookmark = new Mock <Bookmark>();
bookmark.Object.BookmarkId = newBookmark.BookmarkId;
bookmark.Object.AuthorId = newBookmark.AuthorId;
bookmark.Object.Date = newBookmark.Date;
bookmark.Object.Link = newBookmark.Link;
bookmark.Object.Title = newBookmark.Title;
bookmark.Object.Users = newBookmark.Users;
//get a bookmark that successfully returns HttpStatusCode
bookmarkRepo.Setup(x => x.EditBookmark(1, bookmark.Object)).Returns(HttpStatusCode.Accepted);
var result = controller.EditBookmark(new EditJson {
Bookmark = bookmark.Object, UserId = 1
});
Assert.AreEqual(result, HttpStatusCode.Accepted);
}
public void initialize(StandaloneController standaloneController)
{
RocketInterface.Instance.FileInterface.addExtension(new RocketAssemblyResourceLoader(this.GetType().Assembly));
if (VirtualFileSystem.Instance.exists("Watermark/AnomalousMedical.png"))
{
standaloneController.ImageRenderer.LoadLogo = () =>
{
using (Stream stream = VirtualFileSystem.Instance.openStream("Watermark/AnomalousMedical.png", Engine.Resources.FileMode.Open))
{
return(new FreeImageBitmap(stream));
}
};
}
this.guiManager = standaloneController.GUIManager;
this.standaloneController = standaloneController;
standaloneController.MovementSequenceController.GroupAdded += MovementSequenceController_GroupAdded;
bool hasPremium = licenseManager.allowFeature(1);
standaloneController.AnatomyController.ShowPremiumAnatomy = hasPremium;
guiManager.SaveUIConfiguration += guiManager_SaveUIConfiguration;
guiManager.LoadUIConfiguration += guiManager_LoadUIConfiguration;
guiManager.MainGUIShown += guiManager_MainGUIShown;
guiManager.MainGUIHidden += guiManager_MainGUIHidden;
//Controllers
imageLicenseServer = new ImageLicenseServer(licenseManager);
bookmarksController = new BookmarksController(standaloneController, ScaleHelper.Scaled(100), ScaleHelper.Scaled(100), hasPremium);
//Create Dialogs
aboutDialog = new AboutDialog(licenseManager);
chooseSceneDialog = new ChooseSceneDialog(guiManager);
chooseSceneDialog.ChooseScene += new EventHandler(chooseSceneDialog_ChooseScene);
standaloneController.AnatomyController.ShowPremiumAnatomyChanged += AnatomyController_ShowPremiumAnatomyChanged;
anatomyFinder = new AnatomyFinder(standaloneController.AnatomyController, standaloneController.SceneViewController, standaloneController.LayerController, standaloneController.AnatomyTaskManager);
guiManager.addManagedDialog(anatomyFinder);
options = new OptionsDialog(guiManager);
options.VideoOptionsChanged += new EventHandler(options_VideoOptionsChanged);
options.RequestRestart += new EventHandler(options_RequestRestart);
bookmarks = new BookmarksGUI(bookmarksController, standaloneController.GUIManager, standaloneController.SceneViewController);
viewsGui = new ViewsGui(standaloneController.SceneViewController, standaloneController.AnatomyController);
guiManager.addManagedDialog(viewsGui);
//Taskbar
taskbar = new AppButtonTaskbar();
taskbar.OpenTaskMenu += taskbar_OpenTaskMenu;
taskbar.setAppIcon("AppButton/Hamburger", "AppButton/Hamburger");
taskbarLink = new SingleChildChainLink(GUILocationNames.Taskbar, taskbar);
guiManager.addLinkToChain(taskbarLink);
guiManager.pushRootContainer(GUILocationNames.Taskbar);
//Task Menu
taskMenu = new TaskMenu(standaloneController.DocumentController, standaloneController.TaskController, standaloneController.GUIManager, new LayoutElementName(GUILocationNames.FullscreenPopup));
taskMenu.GroupComparison = TaskMenuCategories.Sorter;
guiTaskManager = new GUITaskManager(taskbar, taskMenu, standaloneController.TaskController);
//Tasks Menu
TaskController taskController = standaloneController.TaskController;
standaloneController.AnatomyTaskManager.HighlightTasks += AnatomyTaskManager_HighlightTasks;
//Tasks
cameraMovementModeTask = new CameraMovementModeTask(standaloneController.SceneViewController);
taskController.addTask(cameraMovementModeTask);
Slideshow.AdditionalTasks.addTask(cameraMovementModeTask);
selectionOperatorTask = new SelectionOperatorTask(standaloneController.AnatomyController);
taskController.addTask(selectionOperatorTask);
Slideshow.AdditionalTasks.addTask(selectionOperatorTask);
var viewsTask = new PinableMDIDialogOpenTask(viewsGui, "Medical.Views", "Views", "AnomalousMedical/ViewIcon", TaskMenuCategories.Explore);
taskController.addTask(viewsTask);
//Patient Section
taskController.addTask(new ShowPopupTask(chooseSceneDialog, "Medical.NewPatient", "New", "AnomalousMedical/ChangeScene", TaskMenuCategories.Explore, 0));
taskController.addTask(new DialogOpenTask(aboutDialog, "Medical.About", "About", "AnomalousMedical/About", TaskMenuCategories.System, int.MaxValue - 2));
taskController.addTask(new VolumeControlTask());
CallbackTask unhideAllAnatomy = new CallbackTask("Medical.UnhideAllAnatomy", "Unhide All", "AnatomyFinder.ShowAll", TaskMenuCategories.Explore, int.MaxValue - 2, false, (item) =>
{
LayerState undo = LayerState.CreateAndCapture();
standaloneController.LayerController.unhideAll();
standaloneController.LayerController.pushUndoState(undo);
});
taskController.addTask(unhideAllAnatomy);
//Navigation Section
PinableMDIDialogOpenTask anatomyFinderTask = new PinableMDIDialogOpenTask(anatomyFinder, "Medical.AnatomyFinder", "Anatomy Finder", "AnomalousMedical/SearchIcon", TaskMenuCategories.Explore);
taskController.addTask(anatomyFinderTask);
Slideshow.AdditionalTasks.addTask(anatomyFinderTask);
ShowPopupTask bookmarkTask = null;
standaloneController.AnatomyController.setCommandPermission(AnatomyCommandPermissions.Unrestricted, PlatformConfig.UnrestrictedEnvironment);
standaloneController.AnatomyController.setCommandPermission(AnatomyCommandPermissions.PremiumActive, hasPremium);
if (PlatformConfig.UnrestrictedEnvironment || hasPremium)
{
//Explore
selectionModeTask = new SelectionModeTask(standaloneController.AnatomyController);
taskController.addTask(selectionModeTask);
Slideshow.AdditionalTasks.addTask(selectionModeTask);
bookmarkTask = new ShowPopupTask(bookmarks, "Medical.Bookmarks", "Bookmarks", "AnomalousMedical/FavoritesIcon", TaskMenuCategories.Explore);
taskController.addTask(bookmarkTask);
Slideshow.AdditionalTasks.addTask(bookmarkTask);
}
if (PlatformConfig.UnrestrictedEnvironment)
{
//System
CallbackTask helpTaskItem = new CallbackTask("Medical.Help", "Help", "AnomalousMedical/Help", TaskMenuCategories.System, int.MaxValue - 4, false);
helpTaskItem.OnClicked += new CallbackTask.ClickedCallback(helpTaskItem_OnClicked);
taskController.addTask(helpTaskItem);
taskController.addTask(new ShowPopupTask(options, "Medical.Options", "Options", "AnomalousMedical/Options", TaskMenuCategories.System, int.MaxValue - 3));
CallbackTask exitTaskItem = new CallbackTask("Medical.Exit", "Exit", "AnomalousMedical/Exit", TaskMenuCategories.System, int.MaxValue, false);
exitTaskItem.OnClicked += new CallbackTask.ClickedCallback(exitTaskItem_OnClicked);
taskController.addTask(exitTaskItem);
if (MedicalConfig.ShowDeveloperTools)
{
CallbackTask createOverrideTaskItem = new CallbackTask("Medical.CreateOverride", "CreateOverride", CommonResources.NoIcon, TaskMenuCategories.Developer, int.MaxValue, false);
createOverrideTaskItem.OnClicked += CreateOverrideTaskItem_OnClicked;
taskController.addTask(createOverrideTaskItem);
}
}
if (PlatformConfig.AllowFullscreenToggle)
{
CallbackTask toggleFullscreen = new CallbackTask("Medical.ToggleFullscreen", "Toggle Fullscreen", "AnomalousMedical/ToggleFullscreen", TaskMenuCategories.System, int.MaxValue - 2, false, (item) =>
{
MainWindow.Instance.toggleFullscreen();
});
taskController.addTask(toggleFullscreen);
//Fullscreen Toggle Shortcut
var toggleFullscreenMessageEvent = new ButtonEvent(EventLayers.Gui, frameUp: (evtMgr) =>
{
MainWindow.Instance.toggleFullscreen();
});
toggleFullscreenMessageEvent.addButton(KeyboardButtonCode.KC_RETURN);
toggleFullscreenMessageEvent.addButton(KeyboardButtonCode.KC_LMENU);
standaloneController.MedicalController.EventManager.addEvent(toggleFullscreenMessageEvent);
}
//Premium / Non Premium
if (!hasPremium)
{
if (PlatformConfig.UnrestrictedEnvironment)
{
buyScreens = new BuyScreenController(standaloneController);
taskMenuAd = new PremiumFeaturesTaskMenuAd(taskMenu);
selectionModeTask.SelectionModeChooser.ShowBuyMessage += SelectionModeChooser_ShowBuyMessage;
anatomyFinder.ShowBuyMessage += anatomyFinder_ShowBuyMessage;
bookmarks.ShowBuyMessage += bookmarks_ShowBuyMessage;
}
if (MedicalConfig.FirstRun)
{
guiTaskManager.addPinnedTask(anatomyFinderTask);
guiTaskManager.addPinnedTask(viewsTask);
guiTaskManager.addPinnedTask(cameraMovementModeTask);
if (bookmarkTask != null)
{
guiTaskManager.addPinnedTask(bookmarkTask);
}
guiTaskManager.addPinnedTask(unhideAllAnatomy);
}
}
standaloneController.AtlasPluginManager.RequestDependencyDownload += AtlasPluginManager_RequestDependencyDownload;
//Teeth mover
teethMover = new SimObjectMover("Teeth", standaloneController.MedicalController.PluginManager.RendererPlugin, standaloneController.MedicalController.EventManager, standaloneController.SceneViewController);
TeethToolController teethToolController = new TeethToolController(teethMover);
standaloneController.ImageRenderer.ImageRenderStarted += teethToolController.ScreenshotRenderStarted;
standaloneController.ImageRenderer.ImageRenderCompleted += teethToolController.ScreenshotRenderCompleted;
standaloneController.ViewHostFactory.addFactory(new WizardComponentFactory(teethToolController));
}
public TestBookmarksApiController()
{
controller = new BookmarksController(new BookmarkerTestContext());
controller.ControllerContext.Configuration = new HttpConfiguration();
controller.Request = new HttpRequestMessage();
}
public void TestInit()
{
userProvider = new Mock <IUserProvider>();
service = new Mock <IBookmarkService>();
controller = new BookmarksController(userProvider.Object, service.Object);
}
public AppHost(
IConfigurationRoot rawConfig,
AzureSentinelApiConfiguration[] configurations,
AlertRulesController alertRulesController,
AuthenticationService authenticationService,
AlertRuleTemplatesController alertRuleTemplatesController,
IncidentsController incidentsController,
ActionsController actionsController,
BookmarksController bookmarksController,
DataConnectorsController dataConnectorsController,
IncidentRelationController incidentRelationController,
SavedSearchController savedSearchController)
{
this.configurations = configurations;
this.alertRulesController = alertRulesController;
this.authenticationService = authenticationService;
this.alertRuleTemplatesController = alertRuleTemplatesController;
this.incidentsController = incidentsController;
this.actionsController = actionsController;
this.bookmarksController = bookmarksController;
this.dataConnectorsController = dataConnectorsController;
this.incidentRelationController = incidentRelationController;
this.savedSearchController = savedSearchController;
cliMode = rawConfig.GetValue <bool>("Climode");
string exeName = "AzureSentinel_ManagementAPI.exe";
cmdArgs = new TupleList <string, int>
{
{ $": {exeName} 1 <actionRuleId> [instanceId]", 3 },
{ $": {exeName} 2 <actionRuleId> <actionId> [instanceId]", 4 },
{ $": {exeName} 3 <actionRuleId> <actionId> [instanceId]", 4 },
{ $": {exeName} 4 <actionRuleId> [instanceId]", 3 },
{ $": {exeName} 5 <alertRuleTemplateId> [instanceId]", 3 },
{ $": {exeName} 6 [instanceId]", 2 },
{ $": {exeName} 7 [instanceId]", 2 },
{ $": {exeName} 8 [instanceId]", 2 },
{ $": {exeName} 9 [instanceId]", 2 },
{ $": {exeName} 10 <actionRuleId> [instanceId]", 3 },
{ $": {exeName} 11 [instanceId]", 2 },
{ $": {exeName} 12 <fusionRuleId> [instanceId]", 3 },
{ $": {exeName} 13 <securityRuleId> [instanceId]", 3 },
{ $": {exeName} 14 <scheduledRuleId> [instanceId]", 3 },
{ $": {exeName} 15 [instanceId]", 2 },
{ $": {exeName} 16 <bookmarkId> [instanceId]", 3 },
{ $": {exeName} 17 <bookmarkId> [instanceId]", 3 },
{ $": {exeName} 18 [instanceId]", 2 },
{ $": {exeName} 19 [instanceId]", 2 },
{ $": {exeName} 20 <bookmarkId> [instanceId]", 3 },
{ $": {exeName} 21 [instanceId]", 2 },
{ $": {exeName} 22 [instanceId]", 2 },
{ $": {exeName} 23 <incidentId> [instanceId]", 3 },
{ $": {exeName} 24 <incidentId> [instanceId]", 3 },
{ $": {exeName} 25 [instanceId]", 2 },
{ $": {exeName} 26 <incidentId> [instanceId]", 3 },
{ $": {exeName} 27 [instanceId]", 2 },
{ $": {exeName} 28 <incidentId> [instanceId]", 3 },
{ $": {exeName} 29 <incidentId> [instanceId]", 3 },
{ $": {exeName} 30 <incidentId> <commentId> [instanceId]", 4 },
{ $": {exeName} 31 <incidentId> <bookmarkId> [instanceId]", 4 },
{ $": {exeName} 32 <incidentId> <relationId> [instanceId]", 4 },
{ $": {exeName} 33 <incidentId> [instanceId]", 3 },
{ $": {exeName} 34 <incidentId> <relationId> [instanceId]", 4 },
{ $": {exeName} 35 <incidentId> [instanceId]", 3 },
};
}
public async Task DeleteTest()
{
DocumentsController.DocFolder = "__DocContTest/";
Directory.CreateDirectory(DocumentsController.DocFolder + "1/DEL/");
UserContext _context = GetContext();
_context.Document.Add(new Document()
{
Id = "DEL", Title = "DEL", File = "1/DEL/.pdf", UserId = users[2].Id, GroupId = 1
});
await _context.SaveChangesAsync();
LogOut();
JsonResult res = await controller.apiDelete("DELDFHdjghfdgdfgjk");
Assert.AreEqual(JsonError.ERROR_NOT_FOUND, res.Value);
res = await controller.apiDelete("DEL");
Assert.AreEqual(JsonError.ERROR_ACCESS_DENIED, res.Value);
LogIn(users[3]);
res = await controller.apiDelete("DEL");
Assert.AreEqual(JsonError.ERROR_ACCESS_DENIED, res.Value);
LogIn(users[2]);
res = await controller.apiDelete("DEL");
Assert.AreEqual(JsonError.OK, res.Value);
// Check folder
Assert.False(Directory.Exists(DocumentsController.DocFolder + "1/DEL/"));
// after that not found
Assert.Null(_context.Document.Find("DEL"));
// Now add bookmark to document and try to delete
Directory.CreateDirectory(DocumentsController.DocFolder + "1/DEL/");
_context.Document.Add(new Document()
{
Id = "DEL", Title = "DEL", File = "1/DEL/.pdf", UserId = users[2].Id, GroupId = 1
});
Bookmark bm = new Bookmark()
{
DocumentId = "DEL", Name = "TEST", UserId = users[3].Id
};
_context.Bookmark.Add(bm);
await _context.SaveChangesAsync();
res = await controller.apiDelete("DEL");
Assert.AreEqual(JsonError.OK, res.Value);
Assert.True(Directory.Exists(DocumentsController.DocFolder + "1/DEL/"));
Assert.NotNull(_context.Document.Find("DEL"));
// now delete bookmark via BookmarksController
LogIn(users[3]);
BookmarksController bmc = new BookmarksController(_context, smngrMoq.Object);
SetupController(bmc);
await bmc.apiDelete(bm.Id);
Assert.Null(_context.Bookmark.Find(bm.Id));
Assert.False(Directory.Exists(DocumentsController.DocFolder + "1/DEL/"));
Assert.Null(_context.Document.Find("DEL"));
// Check delete from group
Directory.CreateDirectory(DocumentsController.DocFolder + "1/DEL/");
_context.Document.Add(new Document()
{
Id = "DEL", Title = "DEL", File = "1/DEL/.pdf", UserId = users[2].Id, GroupId = 1
});
await _context.SaveChangesAsync();
// user[1] is groups admin, he can only "hide" document from group
LogIn(users[1]);
res = await controller.apiDelete("DEL");
Assert.AreEqual(JsonError.OK, res.Value);
var doc = _context.Document.Find("DEL");
Assert.NotNull(doc);
Assert.AreEqual(Document.DocStatusEnum.Invisible, doc.DocStatus);
// check messages
LogIn(users[2]);
res = await(new MessagesController(_context, umngr)).apiIndex();
Assert.AreEqual(Message.MessageType.DocRemoved, ((List <MessageModel>)res.Value)[0].Type);
Directory.Delete(DocumentsController.DocFolder, true);
}
void bookmarksController_PremiumBookmarksChanged(BookmarksController obj)
{
toggleAddCustomBookmarks();
}
