public Events_TMUser(TMUser tmUser)
{
this.Target = tmUser;
this.After_User_Changed = new TM_Event<TMUser>(tmUser);
this.After_User_Deleted = new TM_Event<TMUser>(tmUser);
}
[Test] public void user_XmlFile_Location()
{
var userName = 10.randomLetters();
var id = Guid.NewGuid();
var tmUser = new TMUser {
UserName = userName, ID = id
};
var expectedLocation = tmFileStorage.Path_UserData
.pathCombine(TMConsts.USERDATA_PATH_USER_XML_FILES)
.pathCombine(TMConsts.USERDATA_FORMAT_USER_XML_FILE.format(userName, id));
var location1 = tmFileStorage.user_XmlFile_Location(tmUser); // calling it twice should produce the same value
var location2 = tmFileStorage.user_XmlFile_Location(tmUser);
Assert.AreEqual(location1, location2);
Assert.AreEqual(location1, expectedLocation);
}
public void userGroup()
{
var tmUser = new TMUser();
Action <UserGroup, int> checkMapping =
(userGroup, id) => {
tmUser.GroupID = id;
Assert.AreEqual(userGroup, tmUser.userGroup());
};
checkMapping(UserGroup.None, -1);
checkMapping(UserGroup.Viewer, 0);
checkMapping(UserGroup.Admin, 1);
checkMapping(UserGroup.Reader, 2);
checkMapping(UserGroup.Editor, 3);
}
public void userRoles()
{
var tmUser = new TMUser();
Action <UserGroup> checkMapping =
(userGroup) => {
var expectedMapping = UserRolesMappings.Mappings[userGroup];
tmUser.GroupID = (int)userGroup;
Assert.AreEqual(expectedMapping, tmUser.userRoles());
};
checkMapping(UserGroup.None);
checkMapping(UserGroup.Viewer);
checkMapping(UserGroup.Admin);
checkMapping(UserGroup.Reader);
checkMapping(UserGroup.Editor);
}
public static bool tmUser_Delete(this TM_FileStorage tmFileStorage, TMUser tmUser)
{
if (tmUser.notNull())
{
lock (tmUser)
{
var userXmlFile = tmFileStorage.user_XmlFile_Location(tmUser);
if (userXmlFile.file_Delete())
{
return(userXmlFile.fileExists());
}
//userData.triggerGitCommit();
}
}
return(false);
}
public void isAdminEditorReaderAnonymous()
{
var tmUser = new TMUser();
Assert.IsTrue(tmUser.isAnonymous());
tmUser.make_Reader();
Assert.IsTrue(tmUser.isReader());
tmUser.make_Editor();
Assert.IsTrue(tmUser.isEditor());
tmUser.make_Admin();
Assert.IsTrue(tmUser.isAdmin());
Assert.IsFalse(tmUser.isEditor());
Assert.IsFalse(tmUser.isReader());
Assert.IsFalse(tmUser.isAnonymous());
}
public IActionResult Registration([FromBody] RegistrationRequest regModel)
{
var user = new TMUser()
{
UserName = regModel.Username
};
if (!_userManager.Users.Any(u => u.UserName.Equals(regModel.Username)))
{
var task = _userManager.CreateAsync(user, regModel.Password);
task.Wait(Constants.AsyncTaskWaitTime);
var result = task.Result;
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
}
return(Ok());
}
[Test] public void User_ExtMet_FullName()
{
var firstName = "firstName".add_RandomLetters(5);
var lastName = "lastName".add_RandomLetters(5);
var tmUser_NoValues = new TMUser();
var tmUser_JustFirst = new TMUser()
{
FirstName = firstName
};
var tmUser_JustLast = new TMUser()
{
LastName = lastName
};
var tmUser_Both = new TMUser()
{
FirstName = firstName, LastName = lastName
};
//Check that values are correctly set
Assert.IsTrue(tmUser_NoValues.notNull() && tmUser_NoValues.FirstName.empty() && tmUser_NoValues.LastName.empty(), "tmUser_NoValues setup");
Assert.IsTrue(tmUser_JustFirst.notNull() && tmUser_JustFirst.FirstName.valid() && tmUser_JustFirst.LastName.empty(), "tmUser_JustFirst setup");
Assert.IsTrue(tmUser_JustLast.notNull() && tmUser_JustLast.FirstName.empty() && tmUser_JustLast.LastName.valid(), "tmUser_JustLast setup");
Assert.IsTrue(tmUser_Both.notNull() && tmUser_Both.FirstName.valid() && tmUser_Both.LastName.valid(), "tmUser_Both setup");
//Check that userName extension method is working ok
var fullName_NoValues = tmUser_NoValues.fullName();
var fullName_JustFirst = tmUser_JustFirst.fullName();
var fullName_JustLast = tmUser_JustLast.fullName();
var fullName_Both = tmUser_Both.fullName();
Assert.AreEqual(fullName_NoValues, "");
Assert.AreEqual(fullName_JustFirst, firstName);
Assert.AreEqual(fullName_JustLast, "");
Assert.AreEqual(fullName_Both, "{0} {1}".format(firstName, lastName));
//last check
Assert.AreEqual("John Smith", new TMUser()
{
FirstName = "John", LastName = "Smith"
}.fullName());
}
public Guid authenticateUserBaseOn_ActiveDirectory()
{
var identity = WindowsIdentity.GetCurrent();
if (identity.notNull() && identity.IsAuthenticated &&
identity.ImpersonationLevel == TokenImpersonationLevel.Impersonation)
{
var username = identity.Name;
if (username != null)
{
var tmUser = new TMUser()
{
UserName = username,
FirstName = "",
LastName = "",
GroupID = (int)calculateUserGroupBasedOnWindowsIdentity()
};
return(tmUser.registerUserSession(Guid.NewGuid()));
}
}
return(Guid.Empty);
}
[Test] public void loadUsers__UsingFileStorage()
{
tmFileStorage.users_Load(); // when no user files exist
Assert.IsEmpty(userData.TMUsers); // we should get no users
var tmUser1 = new TMUser {
UserName = 10.randomLetters()
}; // without an ID this one will fail to load
var tmUser2 = new TMUser {
UserName = 10.randomLetters(), UserID = 1000.randomNumber() + 1
};
var tmUser3 = new TMUser {
UserName = 10.randomLetters(), UserID = 1000.randomNumber() + 1
};
Assert.IsTrue(tmFileStorage.saveTmUser(tmUser1));
Assert.IsTrue(tmFileStorage.saveTmUser(tmUser2));
Assert.IsTrue(tmFileStorage.saveTmUser(tmUser3));
tmFileStorage.users_Load(); // now
Assert.IsNotEmpty(userData.TMUsers); // we should get two users
Assert.AreEqual(userData.TMUsers.size(), 2); // which are the ones with a valid UserID
}
public void UserSession_Object()
{
userData.resetAllSessions();
//test empty UserSession Object
var userSession0 = new UserSession();
Assert.AreEqual(userSession0.SessionID, Guid.Empty);
Assert.AreEqual(userSession0.CreationDate, default(DateTime));
Assert.AreEqual(userSession0.LoginMethod, default(string));
Assert.IsNull(userSession0.IpAddress);
// temp user object
var tmUser = new TMUser();
//test expected values for 1st session
var userSession1 = tmUser.add_NewSession();
Assert.IsNotNull(userSession1, "New UserSession was null");
Assert.AreNotEqual(userSession1.SessionID, Guid.Empty);
Assert.AreNotEqual(userSession1.CreationDate, default(DateTime));
Assert.IsNotNull(userSession1.IpAddress);
Assert.AreEqual(tmUser.Sessions.size(), 1, "There should only be one sessions here");
Assert.AreEqual(tmUser.Sessions.first(), userSession1);
//test expected values for 2nd session
var userSession2 = tmUser.add_NewSession();
Assert.IsNotNull(userSession2, "New UserSession was null");
Assert.AreNotEqual(userSession2.SessionID, Guid.Empty);
Assert.AreNotEqual(userSession2.CreationDate, default(DateTime));
Assert.IsNotNull(userSession2.IpAddress);
Assert.AreEqual(tmUser.Sessions.size(), 2, "There should only be two sessions here");
Assert.AreEqual(tmUser.Sessions.second(), userSession2);
Assert.AreNotEqual(userSession1, userSession2);
Assert.AreEqual(userData.validSessions().size(), 0); // there should be no sessions here in global sessions handler since the user was created manually
}
public static UserGroup userGroup(this TMUser tmUser)
{
return((UserGroup)tmUser.GroupID);
}
public void setup()
{
tmUser = userData.createUser();
Assert.IsEmpty(tmUser.AuthTokens);
user_AuthToken = tmUser.add_AuthToken();
}
public bool IsBaslanceEnough(string userId, decimal price)
{
TMUser user = _tmuserRepository.GetById(userId);
return(user.Balance >= price);
}
public static string user_XmlFile_Location(this TM_FileStorage tmFileStorage, TMUser tmUser)
{
if (tmFileStorage.isNull())
{
return(null);
}
var fileName = tmUser.user_XmlFile_Name();
return(fileName.valid()
? tmFileStorage.users_XmlFile_Location().pathCombine(fileName)
: null);
}
public static TMUser user_Make_Admin(this TM_Proxy tmProxy, TMUser tmUser)
{
return(tmProxy.invoke_Static <TMUser>(typeof(TMUser_ExtensionMethods), "make_Admin", tmUser));
}
public static List <UserRole> userRoles(this TMUser tmUser)
{
return(UserRolesMappings.Mappings[tmUser.userGroup()]);
}
public static bool user_Logout(this TM_Proxy tmProxy, TMUser tmUser)
{
return(tmProxy.invoke_Static <bool>(typeof(TM_UserData_Ex_ActiveSessions), "logout", tmUser));
}
public decimal GetBalance(string userId)
{
TMUser user = _tmuserRepository.GetById(userId);
return(user.Balance);
}
public static AuthToken user_AuthToken_Add(this TM_Proxy tmProxy, TMUser tmUser)
{
//var authToken = tmProxy.invoke_Static(typeof(TokenAuthentication_ExtensionMethods), "add_AuthToken", tmUser);
return(tmProxy.invoke_Static <AuthToken>(typeof(TokenAuthentication_ExtensionMethods), "add_AuthToken", tmUser));
}
public void CreateTMUser(TMUser user)
{
_tmuserRepository.Create(user);
}
