コード例 #1
0
        public static TMUser        tmUser_FromEmail(this TM_UserData userData, string eMail)
        {
            if (userData.isNull() || eMail.isNull())
            {
                return(null);
            }
            lock (userData.TMUsers)
            {
                var tmUsers = userData.TMUsers.where ((tmUser) => tmUser.EMail == eMail);

                switch (tmUsers.size())
                {
                case 0:
                    //"Could not find TM User with email'{0}'".error(eMail);
                    return(null);

                case 1:
                    return(tmUsers.first());

                default:
                    "There were multiple users resolved to the email '{0}', so returning null".error(eMail);
                    return(null);
                }
            }
        }
コード例 #2
0
ファイル: TM_UserData_Ex_Git.cs プロジェクト: sarvaje/Master
        public static TM_UserData   setupGitSupport(this TM_UserData userData)
        {
            if (userData.UsingFileStorage && userData.Path_UserData.notNull())
            {
                userData.handle_UserData_ConfigActions();

                if (userData.AutoGitCommit)
                {
                    userData.handle_External_GitPull();
                    userData.handle_UserData_ConfigActions();               // run this again in case it was changed from the git pull

                    if (userData.Path_UserData.isGitRepository())
                    {
                        //"[TM_UserData][setupGitSupport] open repository: {0}".info(userData.Path_UserData);
                        "[TM_UserData][GitOpen]".info();
                        userData.NGit = userData.Path_UserData.git_Open();
                    }
                    else
                    {
                        //"[TM_UserData][setupGitSupport] initializing repository at: {0}".info(userData.Path_UserData);
                        "[TM_UserData][GitInit]".info();
                        userData.NGit = userData.Path_UserData.git_Init();
                    }
                    userData.triggerGitCommit();        // in case there are any files that need to be commited
                }
            }
            return(userData);
        }
コード例 #3
0
 public static TMUser        tmUser(this TM_UserData userData, string userName)
 {
     lock (userData.TMUsers)
     {
         return(userData.TMUsers.Where((tmUser) => tmUser.UserName == userName).first());
     }
 }
コード例 #4
0
 public static TMUser        tmUser(this TM_UserData userData, int userId)
 {
     lock (userData.TMUsers)
     {
         return(userData.TMUsers.Where((tmUser) => tmUser.UserID == userId).first());
     }
 }
コード例 #5
0
        public static int           createDefaultAdminUser(this TM_UserData userData)
        {
            var tmConfig = TMConfig.Current;

            lock (tmConfig)
            {
                var defaultAdminUser_Name  = tmConfig.TMSecurity.Default_AdminUserName;
                var defaultAdminUser_Pwd   = tmConfig.TMSecurity.Default_AdminPassword;
                var defaultAdminUser_Email = tmConfig.TMSecurity.Default_AdminEmail;
                var adminUser = userData.tmUser(defaultAdminUser_Name);

                if (adminUser.notNull())
                {
                    if (adminUser.SecretData.PasswordHash.notValid() || tmConfig.OnInstallation.ForceDefaultAdminPassword)
                    {
                        "[createDefaultAdminUser] reseting password since passwordHash was not valid and ForceDefaultAdminPassword was set".error();
                        adminUser.SecretData.PasswordHash = adminUser.createPasswordHash(defaultAdminUser_Pwd);
                        adminUser.saveTmUser();
                    }
                    if (adminUser.GroupID != (int)UserGroup.Admin)
                    {
                        "[createDefaultAdminUser] admin user was not admin (changed to admin)".error();
                        adminUser.GroupID = (int)UserGroup.Admin;
                        adminUser.saveTmUser();
                    }
                    return(adminUser.UserID);
                }
                "[createDefaultAdminUser] admin user didn't exist (creating it)".debug();
                var userId = userData.newUser(defaultAdminUser_Name, defaultAdminUser_Pwd, defaultAdminUser_Email, 1);
                adminUser = userId.tmUser();
                adminUser.AccountStatus.ExpirationDate = DateTime.Now.AddYears(10);        // default to setting the expiry value to 10 years in the future
                adminUser.saveTmUser();
                return(userId);
            }
        }
コード例 #6
0
 public static TM_UserData   loadTmUserData(this TM_UserData userData)
 {
     userData.TMUsers = new List <TMUser>();
     if (userData.Path_UserData.dirExists().isFalse())
     {
         "[TM_UserData_Ex_Users_Persistance] [loadTmUserData] provided userDataPath didn't exist: {0}"
         .error(userData.Path_UserData);
     }
     else
     {
         var usersFolder = userData.getTmUsersFolder();
         foreach (var file in usersFolder.files("*.userData.xml"))
         {
             var tmUser = file.load <TMUser>();
             if (tmUser.notNull() && tmUser.UserID > 0)
             {
                 userData.TMUsers.Add(tmUser);
             }
             else
             {
                 "[TM_UserData_Ex_Users_Persistance] [loadTmUserData] error loading tmUser file (or UserId < 1): {0}".error(file);
             }
         }
     }
     return(userData);
 }
コード例 #7
0
 public static TM_UserData ReloadData(this TM_UserData userData)
 {
     userData.SetUp();
     userData.loadTmUserData();
     userData.createDefaultAdminUser();  // make sure the admin user exists and is configured
     return(userData);
 }
コード例 #8
0
ファイル: TM_WebServices.asmx.cs プロジェクト: sarvaje/Master
 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();
 }
コード例 #9
0
        public static TM_SecretData secretData_Load(this TM_UserData userData)
        {
            try
            {
                if (userData.UsingFileStorage)
                {
                    var secretDataFile = userData.secretData_FileLocation();
                    if (secretDataFile.fileExists())
                    {
                        return(secretDataFile.load <TM_SecretData>());
                    }
                    if (secretDataFile.notNull())
                    {
                        var secretData = new TM_SecretData();
                        secretDataFile.parentFolder().createDir();
                        secretData.saveAs(secretDataFile);
                        userData.triggerGitCommit();
                        return(secretData);
                    }
                }
            }
            catch (Exception ex)
            {
                ex.log("in TM_SecretData secretData_Load");
            }

            return(new TM_SecretData());
        }
コード例 #10
0
        public static TM_UserData   setupGitSupportAndLoadTMConfigFile(this TM_UserData userData)
        {
            if (userData.UsingFileStorage && userData.Path_UserData.notNull())
            {
                userData.load_UserData_FromGitRepo();               // will create the custom UserData repo clone (if mapped)
                userData.load_TMConfigFile();                       // loads the user configured TMConfig.Config file (from either the default or the custom UserData folder)

                var gitEnabled = userData.tmConfig().Git.UserData_Git_Enabled;

                if (gitEnabled)
                {
                    if (userData.Path_UserData.isGitRepository())
                    {
                        //"[TM_UserData][setupGitSupport] open repository: {0}".info(userData.Path_UserData);
                        "[TM_UserData][GitOpen]".info();
                        userData.NGit = userData.Path_UserData.git_Open();
                    }
                    else
                    {
                        //"[TM_UserData][setupGitSupport] initializing repository at: {0}".info(userData.Path_UserData);
                        "[TM_UserData][GitInit]".info();
                        userData.NGit = userData.Path_UserData.git_Init();
                    }
                    userData.triggerGitCommit();        // in case there are any files that need to be commited
                }
            }
            return(userData);
        }
コード例 #11
0
        public static List <int> createTmUsers(this TM_UserData userData, string batchUserData)
        {
            var newUsers = new List <NewUser>();

            foreach (var line in batchUserData.fix_CRLF().split_onLines())
            {
                var newUser = new NewUser();
                //return _newUser;
                var items = line.split(",");

                newUser.Username  = items.size() > 0 ? items[0].trim() : "";
                newUser.Password  = items.size() > 1 ? items[1].trim() : "";
                newUser.Firstname = items.size() > 2 ? items[2].trim() : "";
                newUser.Lastname  = items.size() > 3 ? items[3].trim() : "";
                newUser.GroupId   = items.size() > 4 ? items[4].trim().toInt() : 0;

                //default values
                newUser.Company = "...";
                newUser.Country = "...";
                newUser.Email   = "{0}@randomm.xyz".format(10.randomLetters());
                newUser.Note    = "(Batch user created)";
                newUser.State   = "...";
                newUser.Title   = "...";
                if (newUser.validation_Failed())
                {
                    "[createTmUsers] failed validation for user data:{0}".error(newUser.toXml());
                    newUsers.Add(null);
                }
                else
                {
                    newUsers.Add(newUser);
                }
            }
            return(userData.createTmUsers(newUsers));
        }
コード例 #12
0
        public static int           createTmUser(this TM_UserData userData, NewUser newUser)
        {
            if (newUser.isNull())
            {
                return(0);
            }

            // ensure the email is lowercase (will fail validation otherwise)
            newUser.Email = newUser.Email.lower();

            //validate user against the DataContract specificed in the NewUser class
            if (newUser.validation_Failed())
            {
                return(0);
            }

            // if there is a groupId provided we must check if the user has the manageUsers Priviledge
            if (newUser.GroupId != 0)
            {
                UserRole.ManageUsers.demand();
            }

            // Check if there is already a user with the provided username or email
            if (newUser.Username.tmUser().notNull() || newUser.Email.tmUser_FromEmail().notNull())
            {
                return(0);
            }

            // Create user
            return(userData.newUser(newUser.Username, newUser.Password, newUser.Email, newUser.Firstname, newUser.Lastname, newUser.Note, newUser.Title, newUser.Company, newUser.Country, newUser.State, newUser.GroupId));
        }
コード例 #13
0
ファイル: TM_FileStorage.cs プロジェクト: TeamMentor/Dev
        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
            }
        }
コード例 #14
0
 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();
 }
コード例 #15
0
 public void setup()
 {
     tmConfig.WindowsAuthentication.Enabled = false;            
     windowsAuthentication                  = new WindowsAuthentication();            
     userData                               = new TM_UserData();
     
 }        
コード例 #16
0
 public static List <Guid> validSessions(this TM_UserData userData)
 {
     return((from tmUser in userData.TMUsers
             from session in tmUser.Sessions
             where session.SessionID != Guid.Empty
             select session.SessionID).toList());
 }
コード例 #17
0
        public void setup()
        {
            TM_FileStorage.Current = null;

            tmUserData = new TM_UserData();
            Assert.NotNull (tmUserData);
            Assert.NotNull (tmUserData.Events);
        }
コード例 #18
0
 [ManageUsers]   public static List <bool> deleteTmUsers(this TM_UserData userData, List <int> userIds)
 {
     if (userIds.isNull())
     {
         return(new List <bool>());
     }
     return(userIds.Select(userId => userData.deleteTmUser(userId)).toList());
 }
コード例 #19
0
 [ManageUsers]   public static List <int> createTmUsers(this TM_UserData userData, List <NewUser> newUsers)
 {
     if (newUsers.isNull())
     {
         return(new List <int>());
     }
     return(newUsers.Select(newUser => userData.createTmUser(newUser)).toList());
 }
コード例 #20
0
        public void setup()
        {
            UserGroup.Admin.assert();
            tmDatabase = new TM_Xml_Database();
            tmUserData = new TM_UserData();

            Assert.NotNull (tmDatabase);
            Assert.NotNull (tmDatabase.Events);
        }
コード例 #21
0
 public static TM_UserData ResetData(this TM_UserData userData)
 {
     userData.FirstScriptToInvoke = TMConsts.USERDATA_FIRST_SCRIPT_TO_INVOKE;
     userData.Path_WebRootFiles   = TMConsts.USERDATA_PATH_WEB_ROOT_FILES;
     userData.TMUsers             = new List <TMUser>();
     userData.SecretData          = new TM_SecretData();
     userData.AutoGitCommit       = TMConfig.Current.Git.AutoCommit_UserData;
     return(userData);
 }
コード例 #22
0
 public static bool tmConfig_SetCurrent(this TM_UserData userData, TMConfig tmConfig)
 {
     if (userData.isNull() || tmConfig.isNull())
     {
         return(false);
     }
     TMConfig.Current = tmConfig;
     return(userData.event_TM_Config_Changed());   //return userData.tmConfig_Save();
 }
コード例 #23
0
 public static bool event_TM_Config_Changed(this TM_UserData userData)
 {
     if (userData.events().notNull())
     {
         return(userData.events().After_TM_Config_Changed.raise()
                .Last_Exception.isNull());
     }
     return(true);
 }
コード例 #24
0
        public static TM_UserData   load_UserData_FromGitRepo(this TM_UserData userData)
        {
            try
            {
                var gitConfig = userData.tmConfig().Git;
                if (gitConfig.UserData_Git_Enabled.isFalse())
                {
                    return(userData);
                }

                var gitLocation = TM_Xml_Database.Current.TM_Server_Config.getActive_UserData_Repo_GitPath();
                if (gitLocation.valid())
                {
                    //Adjust Path_UserData so that there is an unique folder per repo
                    var extraFolderName = "_Git_";

                    // extra mode to switch of multiple Git_Hosting in same server
                    extraFolderName += gitLocation.replace("\\", "/").split("/").last().remove(".git").safeFileName();

                    userData.Path_UserData = userData.Path_UserData_Base + extraFolderName;
                    //userData.Path_UserData.createDir();
                    "[handleExternalGitPull] userData.Path_UserData set to: {0}".debug(userData.Path_UserData);

                    if (MiscUtils.online().isFalse())
                    {
                        return(userData);
                    }

                    if (userData.Path_UserData.isGitRepository())
                    {
                        if (gitConfig.UserData_Auto_Pull.isFalse())     //skip if this is set
                        {
                            return(userData);
                        }

                        "[TM_UserData][GitPull]".info();
                        var nGit = userData.Path_UserData.git_Open();
                        nGit.pull();
                        //var nGit = userData.Path_UserData.git_Pull();
                        userData.pushUserRepository(nGit);
                    }
                    else
                    {
                        var start = DateTime.Now;
                        "[TM_UserData][GitClone] Start".info();
                        gitLocation.git_Clone(userData.Path_UserData);
                        "[TM_UserData][GitClone] in ".info(start.duration_To_Now());
                    }
                }
            }
            catch (Exception ex)
            {
                ex.log("[handleExternalGitPull]");
            }
            return(userData);
        }
コード例 #25
0
        public static string        getUserGroupName(this TM_UserData userData, int userId)
        {
            var tmUser = userData.tmUser(userId);

            if (tmUser.notNull())
            {
                return(tmUser.userGroup().str());
            }
            return(null);
        }
コード例 #26
0
        public static int           getUserGroupId(this TM_UserData userData, int userId)
        {
            var tmUser = userData.tmUser(userId);

            if (tmUser.notNull())
            {
                return(tmUser.GroupID);
            }
            return(-1);
        }
コード例 #27
0
        public static TMUser        tmUser_by_Name_or_Id(this TM_UserData userData, string userNameOrId)
        {
            var tmUser = userData.tmUser(userNameOrId);

            if (tmUser.isNull() && userNameOrId.isInt())
            {
                return(userData.tmUser(userNameOrId.toInt()));
            }
            return(tmUser);
        }
コード例 #28
0
        [Admin] public static Guid createUserAuthToken(this TM_UserData userData, int userId)
        {
            var tmUser = userId.tmUser();

            if (tmUser.notNull())
            {
                return(tmUser.add_AuthToken().Token);
            }
            return(Guid.Empty);
        }
コード例 #29
0
 [Admin] public TM_Xml_Database ResetDatabase()
 {
     NGits = new List <API_NGit>();
     Cached_GuidanceItems        = new Dictionary <Guid, TeamMentor_Article>();
     GuidanceItems_FileMappings  = new Dictionary <Guid, string>();
     GuidanceExplorers_XmlFormat = new Dictionary <Guid, guidanceExplorer>();
     GuidanceExplorers_Paths     = new Dictionary <guidanceExplorer, string>();
     UserData = new TM_UserData(UsingFileStorage);
     return(this);
 }
コード例 #30
0
        [ManageUsers]   public static List <string> getUserRoles(this TM_UserData userData, int userId)
        {
            var tmUser = userData.tmUser(userId);

            if (tmUser.notNull())
            {
                return(tmUser.userGroup().userRoles().toStringList());
            }
            return(new List <string>());
        }
コード例 #31
0
        public static TM_UserData resetAllSessions(this TM_UserData userData)
        {
            var sessionIDs = userData.validSessions();

            foreach (var sessionID in sessionIDs)
            {
                var tmUser = sessionID.session_TmUser();
                tmUser.remove_Session(sessionID);
            }
            return(userData);
        }
コード例 #32
0
        public TM_UserData_InMemory()
        {
            userData = new TM_UserData();

            1.set_DEFAULT_PBKDF2_INTERACTIONS();                    // improve performance of tests that create users
            SendEmails.Disable_EmailEngine = true;                  // Disable Email engine by default

            // check the TM_UserData
            Assert.IsEmpty(userData.validSessions() , "There should be no sessions");
            Assert.IsEmpty(userData.TMUsers         , "There should be no users");
        }
コード例 #33
0
        [Admin] public static List <Guid> getUserAuthTokens(this TM_UserData userData, int userId)
        {
            var tmUser = userId.tmUser();

            if (tmUser.notNull())
            {
                return((from authToken in tmUser.AuthTokens
                        select authToken.Token).toList());
            }
            return(new List <Guid>());
        }
コード例 #34
0
        public static UserActivity logTBotActivity(this TM_UserData userData, string action, string detail)
        {
            var userActivities = UserActivities.Current;

            if (userActivities.notNull())
            {
                var userActivity = userActivities.newUserActivity("TBot", action, detail);
                return(userActivities.logUserActivity(userActivity, null));
            }
            return(null);
        }
コード例 #35
0
ファイル: Events_TM_UserData.cs プロジェクト: TeamMentor/Dev
        public Events_TM_UserData(TM_UserData tmUserData)
        {
            this.Target                     = tmUserData;
            this.Before_TM_Config_Load      = new TM_Event<TM_UserData>(tmUserData);
            this.After_TM_Config_Load       = new TM_Event<TM_UserData>(tmUserData);
            this.After_TM_Config_Changed    = new TM_Event<TM_UserData>(tmUserData);
            this.After_TM_SecretData_Load   = new TM_Event<TM_UserData>(tmUserData);
            this.After_Users_Load           = new TM_Event<TM_UserData>(tmUserData);

            this.User_Deleted               = new TM_Event<TM_UserData,TMUser>(tmUserData);
            this.User_Updated               = new TM_Event<TM_UserData,TMUser>(tmUserData);
        }
コード例 #36
0
ファイル: TM_Rest_Direct.cs プロジェクト: TeamMentor/Dev
        public void setDatabase()
        {
            UserGroup.Admin.assert();

            tmXmlDatabase = new TM_Xml_Database();
            tmXmlDatabase.setup();

            tmUserData = new TM_UserData();
            tmUserData.createDefaultAdminUser();

            UserGroup.None.assert();
        }
コード例 #37
0
 public static string webRootFiles(this TM_UserData userData)
 {
     if (userData.notNull() &&
         userData.Path_UserData.valid() &&
         userData.Path_UserData.dirExists() &&
         userData.Path_WebRootFiles.valid() &&
         userData.UsingFileStorage)
     {
         return(userData.Path_UserData.pathCombine(userData.Path_WebRootFiles));
     }
     return(null);
 }
コード例 #38
0
        [ManageUsers]   public static bool          setUserGroupId(this TM_UserData userData, int userId, int groupId)
        {
            var tmUser = userData.tmUser(userId);

            if (tmUser.notNull())
            {
                tmUser.GroupID = groupId;
                tmUser.saveTmUser();
                return(true);
            }
            return(false);
        }
コード例 #39
0
ファイル: Test_TM_UserData.cs プロジェクト: TeamMentor/Dev
        public void TM_UserData_Ctor()
        {
            TM_FileStorage.Current = null;
            var userData = new TM_UserData();

            Assert.AreEqual (TM_UserData.Current, userData);
            Assert.IsEmpty  (userData.TMUsers);
            Assert.NotNull  (userData.SecretData);
            Assert.NotNull  (userData.Events);
            Assert.IsNull   (TM_UserData.GitPushThread);

            Assert.IsNull   (new TMUser().user_XmlFile_Name());
        }
コード例 #40
0
ファイル: TM_XmlDatabase_InMemory.cs プロジェクト: sempf/Dev
        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
        }
コード例 #41
0
        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();
        }
コード例 #42
0
ファイル: Test_QA__3_5_Issues.cs プロジェクト: TeamMentor/Dev
        public void Issue_826__No_lenght_constraint_on_User_Tags_SigupResponse()
        {
            var userData = new TM_UserData();
            var newUser = new NewUser().with_Random_Data();
            newUser.validate().asStringList().assert_Is_Empty();

            var userTag_Ok = new UserTag { Key = 254.randomLetters(), Value = 254.randomLetters() };
            var userTag_Fail = new UserTag { Key = 256.randomLetters(), Value = 256.randomLetters() };

            userTag_Ok.validate().assert_Empty();
            userTag_Fail.validate().assert_Not_Empty();

            newUser.UserTags.add(userTag_Ok);
            userData.createTmUserResponse(newUser).UserCreated.assert_Is_Not(0);

            newUser.UserTags.add(userTag_Fail);
            userData.createTmUser(newUser).assert_Is(0);
        }
コード例 #43
0
ファイル: TM_Xml_Database.cs プロジェクト: sempf/Dev
        public TM_Xml_Database ResetDatabase()
        {
            Cached_GuidanceItems        = new Dictionary<Guid, TeamMentor_Article>();
            GuidanceItems_FileMappings  = new Dictionary<Guid, string>();
            GuidanceExplorers_XmlFormat = new Dictionary<Guid, guidanceExplorer>();
            UserData                    = new TM_UserData(UsingFileStorage);

            /*Libraries.Clear();
            Folders.Clear();
            Views.Clear();
            GuidanceItems.Clear();*/
            return this;
        }
コード例 #44
0
        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();
        }
コード例 #45
0
        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
        }
コード例 #46
0
ファイル: Test_TM_SecretData.cs プロジェクト: TeamMentor/Dev
 public void setup()
 {
     tmFileStorage = new TM_FileStorage(false);
     tmUserData    = tmFileStorage.UserData;
 }
コード例 #47
0
ファイル: Test_TM_SecretData.cs プロジェクト: TeamMentor/Dev
 public void SecretData_Via_TM_UserData()
 {
     var userData = new TM_UserData();
     Assert.NotNull(userData.SecretData, "new TM_UserData should create new TM_SecretData object");
 }
コード例 #48
0
ファイル: Test_UserData_GitStorage.cs プロジェクト: sempf/Dev
        public void setUp()
        {
            //create temp repo with no Admin user
            userData = new TM_UserData(true)
                                {
                                    Path_UserData = "nonGitRepo".tempDir()
                                };
            userData .SetUp(false);
            nGit     = userData.NGit;

            Assert.AreEqual(1, nGit.commits().size() , "there should be one commit of the TMSecretData.config file");
        }
コード例 #49
0
        public void setUp()
        {
            //create temp repo with no Admin user
            userData = new TM_UserData(true)
                                {
                                    Path_UserData = "nonGitRepo".tempDir()
                                };
            userData .SetUp();
            nGit     = userData.NGit;

            Assert.AreEqual(2, nGit.commits().size() , "there should be two commits here");
        }
コード例 #50
0
ファイル: TokenAuthentication.cs プロジェクト: TeamMentor/Dev
 public TokenAuthentication()
 {
     userData = TM_UserData.Current;
 }
コード例 #51
0
ファイル: TM_Xml_Database.cs プロジェクト: roman87/Dev
 public TM_Xml_Database ResetDatabase()
 {
     NGits                       = new List<API_NGit>();
     Cached_GuidanceItems        = new Dictionary<Guid, TeamMentor_Article>();
     GuidanceItems_FileMappings  = new Dictionary<Guid, string>();
     GuidanceExplorers_XmlFormat = new Dictionary<Guid, guidanceExplorer>();
     GuidanceExplorers_Paths     = new Dictionary<guidanceExplorer, string>();
     TM_Server_Config            = new TMServer();
     UserData                    = new TM_UserData(UsingFileStorage);
     return this;
 }