public static urn.microsoft.guidanceexplorer.Folder xmlDB_Add_Folder(this TM_Library tmLibrary, Guid parentFolderId, string folderCaption, TM_Xml_Database tmDatabase)
{
try
{
var newFolder = new urn.microsoft.guidanceexplorer.Folder
{
caption = folderCaption,
folderId = Guid.NewGuid().str()
};
var guidanceExplorer= tmLibrary.guidanceExplorer(tmDatabase);
if (parentFolderId == Guid.Empty)
{
//adding a folder to the library
guidanceExplorer.library.libraryStructure.folder.Add(newFolder);
}
else
{
//adding a folder to folder
var folder = tmDatabase.xmlDB_Folder(tmLibrary.Id, parentFolderId);
if (folder == null)
{
"[xmlDB_Add_Folder] couldn't find parent folder (to add folder) with id: {0}".error(parentFolderId);
return null;
}
folder.folder1.Add(newFolder);
}
guidanceExplorer.xmlDB_Save_GuidanceExplorer(tmDatabase);
return tmDatabase.xmlDB_Folder(tmLibrary.Id, newFolder.folderId.guid());
}
catch(Exception ex)
{
ex.log();
return null;
}
}
public TM_FileStorage(bool loadData)
{
Server = new TM_Server();
TMXmlDatabase = new TM_Xml_Database();
UserData = new TM_UserData();
GuidanceExplorers_Paths = new Dictionary<guidanceExplorer,string>();
GuidanceItems_FileMappings = new Dictionary<Guid,string>();
if (loadData)
{
Current = this;
this.set_WebRoot() // defines where the web root will exist
.set_Path_XmlDatabase() // the WebRoot is used to calculate the root of the XML Database
.tmServer_Load() // the TM_Server is loaded from the root of the Path_XmlDatabase
.set_Path_UserData() // the Path_UserData are Path_SiteData are both
.set_Path_SiteData() // set based on info from TM_Server and Path_XmlDatabase
.tmConfig_Load() // tm TM_Config is loaded from the root of the UserData
.set_Path_XmlLibraries() // the Path_XmlLibraries is set based on info from TM_Config and Path_XmlDatabase
.load_UserData() // after all is configured we can load the users
.load_Libraries(); // and libraries
this.hook_Events_TM_UserData() // hook events to FileStorage handlers so that actions on TeamMentor.Database
.hook_Events_TM_Xml_Database(); // and TeamMentor.UserData are saved or deleted from disk
}
}
public TM_WebServices(bool disable_Csrf_Check)
{
tmXmlDatabase = TM_Xml_Database.Current;
userData = tmXmlDatabase .userData();
tmAuthentication = new TM_Authentication(this).mapUserRoles(disable_Csrf_Check);
GZip.setGZipCompression_forAjaxRequests();
}
public static TM_Library tmLibrary(this urn.microsoft.guidanceexplorer.View viewToFind, TM_Xml_Database tmDatabase)
{
return (from tmLibrary in tmDatabase.tmLibraries()
from view in tmLibrary.xmlDB_Views(tmDatabase)
where view == viewToFind
select tmLibrary).first();
}
public void Application_Start()
{
//O2_Utils.showLogViewer_if_LocalHost();
TmXmlDatabase = new TM_Xml_Database(true); // Create FileSystem Based database
TrackingApplication = new Tracking_Application(TmXmlDatabase.Path_XmlDatabase); // Enabled Application Tracking
TM_REST.SetRouteTable(); // Set REST routes
TrackingApplication.saveLog();
}
public void setup()
{
UserGroup.Admin.assert();
tmDatabase = new TM_Xml_Database();
tmUserData = new TM_UserData();
Assert.NotNull (tmDatabase);
Assert.NotNull (tmDatabase.Events);
}
public void Application_Start()
{
//O2_Utils.showLogViewer_if_LocalHost();
TmXmlDatabase = new TM_Xml_Database(true); // Create FileSystem Based database
TrackingApplication = new Tracking_Application(TmXmlDatabase.Path_XmlDatabase); // Enabled Application Tracking
TM_REST.SetRouteTable(); // Set REST routes
MVC4.MapDefaultRoutes(); // Add support for ASP.NET MVC Controllers on the TM_Website
TrackingApplication.saveLog();
}
public TM_Rest_Direct()
{
UserGroup.Admin.setThreadPrincipalWithRoles();
tmXmlDatabase = new TM_Xml_Database(false);
UserGroup.Anonymous.setThreadPrincipalWithRoles();
TMConfig.Current.TMSetup.UseAppDataFolder = true; // set the TM XMl Database folder to be
moq_HttpContext = new API_Moq_HttpContext();
HttpContextFactory.Context = moq_HttpContext.httpContext();
TmRest = new TM_REST();
}
public void setDatabase()
{
UserGroup.Admin.assert();
tmXmlDatabase = new TM_Xml_Database();
tmXmlDatabase.setup();
tmUserData = new TM_UserData();
tmUserData.createDefaultAdminUser();
UserGroup.None.assert();
}
public void LoadAndSave_TMServer_To_Disk()
{
var tmXmlDatabase = new TM_Xml_Database();
tmXmlDatabase.Path_XmlDatabase = "_tmpLocation".tempDir();
tmXmlDatabase.UsingFileStorage = true;
var tmServer = tmXmlDatabase.TM_Server_Config;
var tmServerPath = tmXmlDatabase.get_Path_TMServer_Config();
Assert.IsNotNull(tmServer , "tmServer");
Assert.IsNotNull(tmServerPath , "tmServerPath");
Assert.AreEqual (tmServerPath.parentFolder(), tmXmlDatabase.Path_XmlDatabase , "tmServerPath.folderName()");
}
public void SetupDatabase()
{
tmXmlDatabase = new TM_Xml_Database();
userData = tmXmlDatabase.UserData;
tmConfig = TMConfig.Current = new TMConfig();
//new TM_TestLibrary().CreateTestDatabase(tmXmlDatabase);
//all these values should be null since we are running TM memory (default setting)
Assert.IsNull(tmXmlDatabase.Path_XmlDatabase , "Path_XmlDatabase");
Assert.IsNull(tmXmlDatabase.Path_XmlLibraries , "Path_XmlLibraries");
Assert.IsEmpty(tmXmlDatabase.Cached_GuidanceItems , "Cached_GuidanceItems");
Assert.IsEmpty(tmXmlDatabase.UserData.ActiveSessions , "ActiveSessions");
Assert.AreEqual(tmXmlDatabase.UserData.TMUsers.size() ,1 , "TMUsers"); // there should be admin
}
public static TeamMentor_Article update_Cache_GuidanceItems(this TeamMentor_Article guidanceItem, TM_Xml_Database tmDatabase)
{
//guidanceItem.htmlEncode(); // ensure MetaData is encoded
var guidanceItemGuid = guidanceItem.Metadata.Id;
if (TM_Xml_Database.Current.Cached_GuidanceItems.hasKey(guidanceItemGuid))
TM_Xml_Database.Current.Cached_GuidanceItems[guidanceItemGuid] = guidanceItem;
else
TM_Xml_Database.Current.Cached_GuidanceItems.Add(guidanceItem.Metadata.Id, guidanceItem);
tmDatabase.Events.Articles_Cache_Updated.raise();
return guidanceItem;
}
public void TM_Xml_Database_Ctor()
{
Assert.IsNull (TM_Xml_Database.Current);
Assert.IsTrue (TM_Xml_Database.SkipServerOnlineCheck); // set on TeamMentor.UnitTests.Tests_Config.RunBeforeAllTests()
var tmDatabase = new TM_Xml_Database();
Assert.IsNotNull(TM_Xml_Database.Current);
Assert.False (tmDatabase.usingFileStorage()); // new TM_Xml_Database() defaults to UsingFileStorage = false
Assert.IsNotNull(tmDatabase.Events); // this is the only list that should be set on the Ctor
Assert.IsNotNull(tmDatabase.Cached_GuidanceItems);
Assert.IsNotNull(tmDatabase.GuidanceExplorers_XmlFormat);
Assert.IsNotNull(tmDatabase.VirtualArticles);
}
public TM_XmlDatabase_FileStorage()
{
SendEmails.Disable_EmailEngine = true;
UserGroup.Admin.assert();
tmFileStorage = new TM_FileStorage();
tmXmlDatabase = tmFileStorage.TMXmlDatabase; //new TM_Xml_Database().setup();
userData = tmFileStorage.UserData;
tmServer = tmFileStorage.Server;
tmConfig = TMConfig.Current;
CheckDatabaseSetup();
UserGroup.None.assert();
}
public void SetupDatabase()
{
UserGroup.Admin.assert();
TM_FileStorage.Current = null; // ensure this is not setup
tmXmlDatabase = new TM_Xml_Database().setup();
userData.createDefaultAdminUser();
Assert.IsEmpty(tmXmlDatabase.Cached_GuidanceItems , "Cached_GuidanceItems");
Assert.IsEmpty(userData.validSessions() , "ActiveSessions");
Assert.AreEqual(userData.TMUsers.size() ,1 , "TMUsers"); // there should be admin
UserGroup.None.assert();
}
public static Folder_V3 tmFolder(this urn.microsoft.guidanceexplorer.Folder folder, Guid libraryId, TM_Xml_Database tmDatabase)
{
if (folder.isNull())
return null;
if (folder.folderId.isNull()) // handle legacy case where there is no folderId in the guidanceitems object
folder.folderId = Guid.NewGuid().str();
var tmFolder= new Folder_V3
{
libraryId = libraryId,
name = folder.caption,
folderId = folder.folderId.guid(),
subFolders = tmDatabase.tmFolders(libraryId, folder.folder1)
};
foreach(var view in folder.view)
tmFolder.views.Add(new View_V3 { viewId = view.id.guid()});
return tmFolder;
}
public void setup()
{
if (Tests_Consts.offline)
Assert.Ignore("Ignoring Test because we are offline");
admin.assert(()=>{
tmFileStorage = new TM_FileStorage(false);
TM_FileStorage.Custom_WebRoot = "Custom_WebRoot".tempDir();
tmFileStorage.set_WebRoot()
.set_Path_XmlDatabase()
.tmConfig_Load()
.set_Path_XmlLibraries();
tmXmlDatabase = tmFileStorage.TMXmlDatabase;
});
}
public Events_TM_Xml_Database(TM_Xml_Database tmXmlDatabase)
{
this.Target = tmXmlDatabase;
Before_Setup = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Setup = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Set_Default_Values = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Set_Path_XmlLibraries = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
// After_TmServer_Load = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Load_UserData = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Load_SiteData = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
After_Load_Libraries = new TM_Event<TM_Xml_Database>(tmXmlDatabase);
Articles_Cache_Updated = new TM_Event_TM_Xml_Database (tmXmlDatabase);
Article_Saved = new TM_Event_TM_Article (tmXmlDatabase);
Article_Deleted = new TM_Event_TM_Article (tmXmlDatabase);
Library_Deleted = new TM_Event_TM_Library (tmXmlDatabase);
GuidanceExplorer_Save = new TM_Event_GuidanceExplorer(tmXmlDatabase);
VirtualArticles_Loaded = new TM_Event_TM_Xml_Database (tmXmlDatabase);
VirtualArticles_Saved = new TM_Event_TM_Xml_Database (tmXmlDatabase);
}
public void setup_UserData_Git_Support()
{
var tmXmlDatabase = new TM_Xml_Database();
Assert.Ignore("needs rewrite");
/*
Assert.AreEqual(tmXmlDatabase.Events.After_UserData_Ctor.size(), 1);
tmXmlDatabase.setup_UserData_Git_Support();
Assert.AreEqual(tmXmlDatabase.Events.After_UserData_Ctor.size(), 2);
Assert.IsNull (TM_UserData_Git.Current);
Assert.IsNull (tmXmlDatabase.UserData);
tmXmlDatabase.userData(); // will call the TM_UserData ctor if tmXmlDatabase.UserData is null
Assert.NotNull (tmXmlDatabase.UserData);
Assert.NotNull (TM_UserData_Git.Current);
Assert.IsNotNull(TM_UserData_Git.Current.UserData);
Assert.IsNull (TM_UserData_Git.Current.UserData.path_UserData());
Assert.IsNull (tmXmlDatabase.path_XmlDatabase());
Assert.AreEqual (TM_UserData_Git.Current.UserData, tmXmlDatabase.UserData);
* */
}
public static List<Folder_V3> tmFolders(this TM_Library tmLibrary, TM_Xml_Database tmDatabase )
{
return tmDatabase.tmFolders(tmLibrary);
}
public void SetupDatabase()
{
1.set_DEFAULT_PBKDF2_INTERACTIONS(); // improve performance of tests that create users
tmXmlDatabase = new TM_Xml_Database();
userData = tmXmlDatabase.UserData;
tmConfig = TMConfig.Current = new TMConfig();
Assert.IsNull(tmXmlDatabase.Path_XmlDatabase , "Path_XmlDatabase"); // null since we are running TM memory (default setting)
Assert.IsNull(tmXmlDatabase.Path_XmlLibraries , "Path_XmlLibraries"); // null since we are running TM memory (default setting)
Assert.IsEmpty(tmXmlDatabase.Cached_GuidanceItems , "Cached_GuidanceItems");
Assert.IsEmpty(tmXmlDatabase.UserData.validSessions() , "ActiveSessions");
Assert.AreEqual(tmXmlDatabase.UserData.TMUsers.size(),1 , "TMUsers"); // there should be admin
}
public static Folder_V3 tmFolder(this TM_Library tmLibrary, Guid folderId, TM_Xml_Database tmDatabase )
{
return tmDatabase.tmFolder(tmLibrary.Id, folderId);
}
public static Library library(this TM_Library tmLibrary, TM_Xml_Database tmDatabase)
{
if (tmLibrary.isNull())
return null;
return new Library
{
caption = tmLibrary.Caption,
id = tmLibrary.Id.str(),
//Views = tmDatabase.tmViews(tmLibrary).ToArray()
};
}
static MarkdownController()
{
tmDatabase = TM_Xml_Database.Current;
}
public TM_Xml_Database CreateTestDatabase(TM_Xml_Database tmXmlDatabase)
{
return tmXmlDatabase;
}
public static string get_Path_TMServer_Config(this TM_Xml_Database tmDatabase)
{
return((tmDatabase.notNull() && tmDatabase.UsingFileStorage)
? tmDatabase.Path_XmlDatabase.pathCombine(TMConsts.TM_SERVER_FILENAME)
: null);
}
public static bool xmlDB_Save_Article(this TeamMentor_Article article, TM_Xml_Database tmDatabase)
{
return article.xmlDB_Save_Article(article.Metadata.Library_Id, tmDatabase);
}
public void setUp()
{
UserGroup.Admin.assert();
//create TM_FileStorage on temp Custom_WebRoot for this TestFixture
TM_FileStorage.Custom_WebRoot = "custom_WebRoot".tempDir();
tmFileStorage = new TM_FileStorage(false);
tmFileStorage.set_WebRoot()
.set_Path_XmlDatabase()
.tmServer_Load()
.set_Path_UserData()
.load_UserData();
tmFileStorage.hook_Events_TM_UserData();
tmXmlDatabase = tmFileStorage.TMXmlDatabase .assert_Not_Null();
userData = tmFileStorage.UserData .assert_Not_Null();
tmServer = tmFileStorage.Server .assert_Not_Null();
tmFileStorage.Path_XmlDatabase.assert_Folder_Exists();
tmFileStorage.Path_UserData .assert_Folder_Exists();
userDataGit = tmFileStorage .setup_UserData_Git_Support(); // adds Git Support for UserData repos
tmFileStorage.Path_UserData.isGitRepository().assert_True();
Assert.NotNull(tmFileStorage.Server.userData_Config());
userData .createDefaultAdminUser();
userDataGit.triggerGitCommit();
nGit = userDataGit.NGit;
nGit.commits().assert_Size_Is(2, "there should be two commits here");
UserGroup.None.assert();
}
public static List<urn.microsoft.guidanceexplorer.View> xmlDB_Views_InLibraryRoot(this TM_Library tmLibrary , TM_Xml_Database tmDatabase)
{
try
{
return tmLibrary.guidanceExplorer(tmDatabase).library.libraryStructure.view.toList();
}
catch
{
return new List<urn.microsoft.guidanceexplorer.View>();
}
}
public static bool xmlDB_Save_Article(this TeamMentor_Article article, Guid libraryId, TM_Xml_Database tmDatabase)
{
if (libraryId == Guid.Empty) // ensure we have a library to put the Article in
{
"[xmlDB_Save_GuidanceItem] no LibraryId was provided".error();
return false;
}
if(article.Content.DataType.lower() == "html") // tidy the html
{
var cdataContent= article.Content.Data.Value.replace("]]>", "]] >"); // xmlserialization below will break if there is a ]]> in the text
var tidiedHtml = cdataContent.tidyHtml();
article.Content.Data.Value = tidiedHtml;
if (article.serialize(false).inValid()) // see if the tidied content can be serialized and if not use the original data
article.Content.Data.Value = cdataContent;
}
article.Metadata.Library_Id = libraryId; // ensure the LibraryID is correct
if (article.serialize(false).notValid()) // make sure the article can be serilialized correctly
return false;
article.update_Cache_GuidanceItems(tmDatabase); // add it to in Memory cache
if(tmDatabase.UsingFileStorage) // save to disk
{
var guidanceXmlPath = tmDatabase.getXmlFilePathForGuidanceId(article.Metadata.Id, libraryId);
"Saving GuidanceItem {0} to {1}".info(article.Metadata.Id, guidanceXmlPath);
article.saveAs(guidanceXmlPath);
return guidanceXmlPath.fileExists();
}
return true;
}
public void setDatabase()
{
tmXmlDatabase = new TM_Xml_Database(false);
}
