public void TreeMonDbContext_Context_Transaction_Succeed()
{
User u = TestHelper.GenerateTestUser("ALPHA");
Account a = new Account()
{
Name = "ALPHA_ACCOUNT", DateCreated = DateTime.Now
};
TreeMonDbContext context = new TreeMonDbContext("MSSQL_TEST");
using (var dbContext = new DbContext(context.ConnectionKey))
{
using (var contextTransaction = context.Database.BeginTransaction())
{
try
{
Assert.IsTrue(context.Insert <User>(u), "Failed to insert user.");
Assert.IsTrue(context.Insert <Account>(a), "Failed to insert account.");
contextTransaction.Commit();
}
catch (Exception ex)
{
contextTransaction.Rollback();
Assert.Fail(ex.Message);
}
}
}
Assert.AreEqual(context.Get <User>(u.Id).Name, "ALPHA");
Assert.AreEqual(context.Get <Account>(a.Id).Name, "ALPHA_ACCOUNT");
}
public void Api_RoleController_GetUsersInRole()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role role = new Role();
role.AccountUUID = SystemFlag.Default.Account;
role.Name = Guid.NewGuid().ToString("N");
role.DateCreated = DateTime.Now;
role.EndDate = DateTime.Now;
role.StartDate = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(role));
User user = TestHelper.GenerateTestUser(Guid.NewGuid().ToString("N"));
Assert.IsTrue(context.Insert <User>(user));
AccountMember am = new AccountMember()
{
AccountUUID = role.AccountUUID,
MemberUUID = user.UUID,
UUID = Guid.NewGuid().ToString("N")
};
Assert.IsTrue(context.Insert <AccountMember>(am));
UserRole userRole = new UserRole();
userRole.RoleUUID = role.UUID;
userRole.UUID = Guid.NewGuid().ToString("N");
userRole.AccountUUID = role.AccountUUID;
userRole.UserUUID = user.UUID;
userRole.DateCreated = DateTime.Now;
userRole.StartDate = DateTime.Now;
userRole.EndDate = DateTime.Now;
Assert.IsTrue(context.Insert <UserRole>(userRole));
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Roles/" + role.UUID + "/Users/", "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <User> usersInRole = JsonConvert.DeserializeObject <List <User> >(res.Result.ToString());
Assert.IsNotNull(usersInRole);
Assert.IsTrue(usersInRole.Count >= 1);
int found = 0;
foreach (User p in usersInRole)
{
if (p.Name == user.Name)
{
found++;
}
}
Assert.AreEqual(found, 1);
}).GetAwaiter().GetResult();
}
public void TreeMonDbContext_Context_Transaction_Fail()
{
User u = TestHelper.GenerateTestUser("BETA");
Account a = new Account()
{
Name = "BETA_ACCOUNT"
};
string failTest = null;
TreeMonDbContext context = new TreeMonDbContext("MSSQL_TEST");
using (var dbContext = new DbContext(context.ConnectionKey))
{
using (var contextTransaction = context.Database.BeginTransaction())
{
try
{
context.Insert <User>(u);
failTest.ToUpper();//this should blow up.
context.Insert <Account>(a);
contextTransaction.Commit();
}
catch (Exception)
{
contextTransaction.Rollback();
}
}
}
//Should have removed the user and not inserted the account.
Assert.IsNull(context.Get <User>(u.Id), "BETA");
Assert.IsNull(context.Get <Account>(a.Id), "BETA_ACCOUNT");
}
public void TestSetup()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Random rand = new Random();
//Seed AuthenticationLog
for (int i = 0; i < 100; i++)
{
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = i % 3 == 0? false: true,
AuthenticationDate = DateTime.UtcNow.AddMonths(rand.Next(0, 12) * -1),
UserName = "******"
});
}
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = false,
AuthenticationDate = DateTime.UtcNow.AddMonths(-1),
UserName = "******"
});
//Seed Measurements
for (int i = 0; i < 100; i++)
{
context.Insert <MeasurementLog>(new MeasurementLog()
{
DateTaken = DateTime.UtcNow.AddMonths(rand.Next(0, 12) * -1),
Measure = rand.Next(0, 100),
UnitOfMeasure = "centimeters"
});
}
}
public void Api_RoleController_GetPermissionsForRole()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role role = new Role();
role.AccountUUID = SystemFlag.Default.Account;
role.Name = Guid.NewGuid().ToString("N");
role.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(role));
Permission p = new Permission()
{
Action = "get",
Active = true,
Type = "t",
AccountUUID = SystemFlag.Default.Account,
AppType = "appType",
Persists = true,
StartDate = DateTime.UtcNow,
Weight = 0,
Key = "get" + Guid.NewGuid().ToString("N"),
Name = Guid.NewGuid().ToString("N"),
Deleted = false,
DateCreated = DateTime.Now
};
context.Insert <Permission>(p);
RolePermission rolePermission = new RolePermission();
rolePermission.RoleUUID = role.UUID;
rolePermission.AccountUUID = role.AccountUUID;
rolePermission.PermissionUUID = p.UUID;
rolePermission.UUID = Guid.NewGuid().ToString("N");
rolePermission.DateCreated = DateTime.Now;
context.Insert <RolePermission>(rolePermission);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("GET", "api/Roles/" + role.UUID + "/Permissions/", "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <Permission> permissions = JsonConvert.DeserializeObject <List <Permission> >(res.Result.ToString());
Assert.IsNotNull(permissions);
Assert.IsTrue(permissions.Count >= 1);
int foundPermission = 0;
foreach (Permission perm in permissions)
{
if (perm.Name == p.Name && perm.AccountUUID == role.AccountUUID)
{
foundPermission++;
}
}
Assert.AreEqual(foundPermission, 1);
}).GetAwaiter().GetResult();
}
public void Api_SideAffectController_GetChildSideAffects()
{
string parentId = Guid.NewGuid().ToString("N");
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
DoseLog dose = new DoseLog()
{
UUID = Guid.NewGuid().ToString("N"),
DateCreated = DateTime.UtcNow,
DoseDateTime = DateTime.UtcNow
};
Assert.IsTrue(context.Insert <DoseLog>(dose));
SideAffect mdl = new SideAffect();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUParentID = parentId;
mdl.DoseUUID = dose.UUID;
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <SideAffect>(mdl));
SideAffect mdl2 = new SideAffect();
mdl2.AccountUUID = SystemFlag.Default.Account;
mdl2.Name = Guid.NewGuid().ToString("N");
mdl2.UUParentID = parentId;
mdl2.DoseUUID = dose.UUID;
mdl2.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <SideAffect>(mdl2));
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Doses/" + dose.UUID + "/SideAffects/History/" + mdl.UUParentID, "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <SideAffect> SideAffects = JsonConvert.DeserializeObject <List <SideAffect> >(res.Result.ToString());
Assert.IsNotNull(SideAffects);
Assert.IsTrue(SideAffects.Count >= 2);
int foundSideAffects = 0;
foreach (SideAffect p in SideAffects)
{
if (p.Name == mdl.Name || p.Name == mdl2.Name)
{
foundSideAffects++;
}
}
Assert.AreEqual(foundSideAffects, 2);
}).GetAwaiter().GetResult();
}
public void Api_RoleController_AddPermissionsToRole()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role role = new Role();
role.UUID = Guid.NewGuid().ToString("N");
role.AccountUUID = SystemFlag.Default.Account;
role.Name = Guid.NewGuid().ToString("N");
role.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(role));
Permission p = new Permission()
{
Action = "get",
Active = true,
Type = "t",
AccountUUID = SystemFlag.Default.Account,
AppType = "appType",
Persists = true,
StartDate = DateTime.UtcNow,
Weight = 0,
Key = "get" + Guid.NewGuid().ToString("N"),
Name = Guid.NewGuid().ToString("N"),
Deleted = false,
DateCreated = DateTime.Now
};
context.Insert <Permission>(p);
RolePermission rolePermission = new RolePermission();
rolePermission.RoleUUID = role.UUID;
rolePermission.AccountUUID = role.AccountUUID;
rolePermission.PermissionUUID = p.UUID;
rolePermission.UUID = Guid.NewGuid().ToString("N");
rolePermission.DateCreated = DateTime.Now;
List <RolePermission> rolePerissions = new List <RolePermission>();
rolePerissions.Add(rolePermission);
string postData = JsonConvert.SerializeObject(rolePerissions);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Roles/" + role.UUID + "/Permissions/Add", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
RolePermission dbRolePermission = context.GetAll <RolePermission>().Where(w => w.RoleUUID == role.UUID).FirstOrDefault();
Assert.IsNotNull(dbRolePermission);
Assert.AreEqual(rolePermission.AccountUUID, dbRolePermission.AccountUUID);
Assert.AreEqual(rolePermission.PermissionUUID, p.UUID);
}).GetAwaiter().GetResult();
}
public void Api_AppsController_GetSettings()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Setting mdl = new Setting();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.AppType = "web";
mdl.SettingClass = "app";
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Setting>(mdl));
Setting mdl2 = new Setting();
mdl2.AccountUUID = SystemFlag.Default.Account;
mdl2.Name = Guid.NewGuid().ToString("N");
mdl2.AppType = "web";
mdl2.SettingClass = "app";
mdl2.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Setting>(mdl2));
Task.Run(async() =>
{
DataFilter filter = new DataFilter();
filter.PageResults = false;
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Apps/Settings?filter=" + JsonConvert.SerializeObject(filter), "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <Setting> Apps = JsonConvert.DeserializeObject <List <Setting> >(res.Result.ToString());
Assert.IsNotNull(Apps);
Assert.IsTrue(Apps.Count >= 2);
int foundApps = 0;
foreach (Setting p in Apps)
{
if (p.Name == mdl.Name || p.Name == mdl2.Name)
{
foundApps++;
}
}
Assert.AreEqual(foundApps, 2);
}).GetAwaiter().GetResult();
}
public void Api_RoleController_GetRole()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role mdl = new Role();
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(mdl));
User user = TestHelper.GenerateTestUser(Guid.NewGuid().ToString("N"));
SessionManager sessionManager = new SessionManager(connectionKey);
string userJson = JsonConvert.SerializeObject(user);
UserSession us = sessionManager.SaveSession("127.1.1.33", user.UUID, userJson, false);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("GET", "api/Roles/" + mdl.Name, "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
Role p = JsonConvert.DeserializeObject <Role>(res.Result.ToString());
Assert.IsNotNull(p);
Assert.AreEqual(mdl.Name, p.Name);
}).GetAwaiter().GetResult();
}
public void Api_NotificationController_GetNotification()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Notification mdl = new Notification();
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
mdl.DateFirstViewed = DateTime.Now;
mdl.DateLastViewed = DateTime.Now;
Assert.IsTrue(context.Insert <Notification>(mdl));
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("GET", "api/Notifications/" + mdl.Name, "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
Notification p = JsonConvert.DeserializeObject <Notification>(res.Result.ToString());
Assert.IsNotNull(p);
Assert.AreEqual(mdl.Name, p.Name);
}).GetAwaiter().GetResult();
}
public void Api_MODELNAMEController_UpdateMODELNAME()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
MODELNAME mdl = new MODELNAME();
mdl.AccountId = SystemFlag.Default.Account;//todo create SystemFlag.Test.Account
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUID = Guid.NewGuid().ToString("N");
Assert.IsTrue(context.Insert <MODELNAME>(mdl));
mdl = context.GetAll <MODELNAME>().Where(w => w.Name == mdl.Name).FirstOrDefault();
MODELNAMEView pv = new MODELNAMEView();
pv.Id = mdl.Id;
pv.UUID = mdl.UUID;
pv.AccountId = mdl.AccountId;
pv.Name = mdl.Name;
//~~~ Updatable fields ~~~
string postData = JsonConvert.SerializeObject(pv);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/MODELNAMEs/Update", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
MODELNAME dbMODELNAME = context.GetAll <MODELNAME>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Assert.IsNotNull(dbMODELNAME);
}).GetAwaiter().GetResult();
}
public bool Insert(LogEntry l)
{
if (UseFileLogging)
{
_fileLog.LogFile(PathToFileLog);
Exception ex = _fileLog.Write(
l.LogDate.ToString() + "," +
l.Level + "," +
l.StackTrace + "," +
l.Source + "," +
l.InnerException);
if (ex == null)
{
return(true);
}
else
{
return(false);
}
}
using (var context = new TreeMonDbContext(_dbConnectionKey))
{
return(context.Insert <LogEntry>(l));
}
}
public ServiceResult Insert(INode n, bool validateFirst = true)
{
if (!this.DataAccessAuthorized(n, "POST", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight);
var s = (DoseLog)n;
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
DoseLog dbU = context.GetAll <DoseLog>().FirstOrDefault(wu => (wu.Name?.EqualsIgnoreCase(s.Name) ?? false) && wu.AccountUUID == s.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("Dose already exists."));
}
}
if (context.Insert <DoseLog>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting Dose " + s.Name));
}
public void TreeMonDbContext_Context_TransactionScope_Fail()
{
User u = TestHelper.GenerateTestUser("ECHO");
Account a = new Account()
{
Name = "ECHO_ACCOUNT"
};
string failTest = null;
TreeMonDbContext contextUser = new TreeMonDbContext("MSSQL_TEST");
TreeMonDbContext contextAccount = new TreeMonDbContext("MSSQL_TEST");
using (var scope = new TransactionScope())
{
try
{
contextUser.Insert <User>(u);
failTest.ToUpper();//this should blow up.
contextAccount.Insert <Account>(a);
scope.Complete();
}
catch (Exception)
{
}
}
//Should have removed the user and not inserted the account.
Assert.IsNull(contextUser.Get <User>(u.Id), "ECHO");
Assert.IsNull(contextAccount.Get <Account>(a.Id), "ECHO_ACCOUNT");
}
public ServiceResult Insert(Credential c, bool validateFirst = true)
{
if (!this.DataAccessAuthorized(c, "POST", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
Credential dbU = context.GetAll <Credential>().FirstOrDefault(wu => wu.Name.EqualsIgnoreCase(c.Name) && wu.AccountUUID == c.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("Credential already exists."));
}
}
if (string.IsNullOrWhiteSpace(c.UUID))
{
c.UUID = Guid.NewGuid().ToString("N");
}
c.UUIDType = "Credential";
if (context.Insert <Credential>(c))
{
return(ServiceResponse.OK("", c));
}
}
return(ServiceResponse.Error("An error occurred inserting credential " + c.Name));
}
public void TreeMonDbContext_Context_TransactionScope_Succeed()
{
User u = TestHelper.GenerateTestUser("CHARLIE");
Account a = new Account()
{
Name = "CHARLIE_ACCOUNT", DateCreated = DateTime.Now
};
TreeMonDbContext contextUser = new TreeMonDbContext("MSSQL_TEST");
TreeMonDbContext contextAccount = new TreeMonDbContext("MSSQL_TEST");
using (var scope = new TransactionScope())
{
try
{
contextUser.Insert <User>(u);
contextAccount.Insert <Account>(a);
scope.Complete();
}
catch (Exception)
{
}
}
Assert.AreEqual(contextUser.Get <User>(u.Id).Name, "CHARLIE");
Assert.AreEqual(contextAccount.Get <Account>(a.Id).Name, "CHARLIE_ACCOUNT");
}
public ServiceResult Insert(INode n, bool validateFirst = true)
{
if (n == null)
{
return(ServiceResponse.Error("Invalid account data."));
}
if (!this.DataAccessAuthorized(n, "POST", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight);
var a = (Account)n;
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
Account dbU = context.GetAll <Account>().FirstOrDefault(wu => (wu.Name?.EqualsIgnoreCase(a.Name) ?? false) && wu.AccountUUID == a.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("Account already exists."));
}
}
if (context.Insert <Account>(a))
{
return(ServiceResponse.OK("", a));
}
}
return(ServiceResponse.Error("System error, account was not added."));
}
public void Api_SideAffectController_DeleteSideAffect()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
SideAffect mdl = new SideAffect();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <SideAffect>(mdl));
string postData = JsonConvert.SerializeObject(mdl);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/SideAffects/Delete", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
SideAffect dbSideAffect = context.GetAll <SideAffect>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Assert.IsNotNull(dbSideAffect);
Assert.IsTrue(dbSideAffect.Deleted);
//Assert.IsNull(dbSideAffect);
}).GetAwaiter().GetResult();
}
public ServiceResult Insert(SymptomLog s, bool validateFirst = true)
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
SymptomLog dbU = context.GetAll <SymptomLog>().FirstOrDefault(wu => wu.Name.EqualsIgnoreCase(s.Name) && wu.AccountUUID == s.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("SymptomLog already exists."));
}
}
s.UUID = Guid.NewGuid().ToString("N");
s.UUIDType = "SymptomLog";
if (!this.DataAccessAuthorized(s, "POST", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
if (context.Insert <SymptomLog>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting SymptomLog " + s.Name));
}
public void Api_UserSessionController_GetStatus()
{
Assert.IsNotNull(ConfigurationManager.AppSettings["AppKey"]);
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
User u = TestHelper.GenerateTestUser(Guid.NewGuid().ToString("N"));
string loginPassword = u.Password;
string tmpHashPassword = PasswordHash.CreateHash(u.Password);
u.Password = PasswordHash.ExtractHashPassword(tmpHashPassword);
u.PasswordHashIterations = PasswordHash.ExtractIterations(tmpHashPassword);
u.PasswordSalt = PasswordHash.ExtractSalt(tmpHashPassword);
Assert.IsTrue(context.Insert <User>(u));
// set a user session then pass the authtoken
SessionManager sessionManager = new SessionManager(connectionKey);
string userJson = JsonConvert.SerializeObject(u);
UserSession us = sessionManager.SaveSession("127.1.1.34", u.UUID, userJson, false);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("GET", "api/Sessions/Status/" + us.AuthToken, "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
}).GetAwaiter().GetResult();
}
/// <summary>
/// Validate param not implemented
/// </summary>
/// <param name="n"></param>
/// <param name="validateFirst"></param>
/// <returns></returns>
public ServiceResult Insert(INode n, bool validateFirst = true)
{
if (n == null)
{
return(ServiceResponse.Error("No record sent."));
}
n.Initialize("", "", 5);
var s = (EmailLog)n;
using (var context = new TreeMonDbContext(_dbConnectionKey))
{
//if (validateFirst)
//{
// EmailLog dbU = context.GetAll<EmailLog>().FirstOrDefault(wu => (wu.Name?.EqualsIgnoreCase(s.Name) ?? false) && wu.AccountUUID == s.AccountUUID);
// if (dbU != null)
// return ServiceResponse.Error("Email log already exists.");
//}
if (context.Insert <EmailLog>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting EmailLog "));
}
public void Api_UnitOfMeasureController_UpdateUnitOfMeasure()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
UnitOfMeasure mdl = new UnitOfMeasure();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.UtcNow;
Assert.IsTrue(context.Insert <UnitOfMeasure>(mdl));
mdl = context.GetAll <UnitOfMeasure>().Where(w => w.Name == mdl.Name).FirstOrDefault();
UnitOfMeasure pv = new UnitOfMeasure();
pv.Id = mdl.Id;
pv.UUID = mdl.UUID;
pv.AccountUUID = mdl.AccountUUID;
pv.Name = mdl.Name;
//~~~ Updatable fields ~~~
string postData = JsonConvert.SerializeObject(pv);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/UnitsOfMeasure/Update", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
UnitOfMeasure dbUnitOfMeasure = context.GetAll <UnitOfMeasure>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Assert.IsNotNull(dbUnitOfMeasure);
}).GetAwaiter().GetResult();
}
public ServiceResult Insert(INode n, bool validateFirst = true)
{
if (n == null)
{
return(ServiceResponse.Error("Value is empty."));
}
n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight);
var s = (UnitOfMeasure)n;
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
UnitOfMeasure dbU = context.GetAll <UnitOfMeasure>().FirstOrDefault(wu => (wu.Name?.EqualsIgnoreCase(s.Name) ?? false) && wu.AccountUUID == s.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("UnitOfMeasure already exists."));
}
}
if (context.Insert <UnitOfMeasure>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting UnitOfMeasure " + s.Name));
}
/// <summary>
/// Saves user session, expects the authtoken to
/// not be null or empty. If authtoken is null it uses
/// the user id instead of ip to generate it.
/// </summary>
/// <param name="us"></param>
/// <returns></returns>
public UserSession SaveSession(UserSession us)
{
if (us == null)
{
return(us);
}
if (string.IsNullOrWhiteSpace(us.AuthToken))
{
Debug.Assert(false, "AUTHTOKEN IS NULL");
us.AuthToken = GenerateToken(us.UserUUID);
}
if (us.SessionLength != SessionLength)
{
us.SessionLength = this.SessionLength;
}
us.Expires = DateTime.UtcNow.AddMinutes(us.SessionLength);
using (var context = new TreeMonDbContext(_connectionKey))
{
if (context.Insert <UserSession>(us))
{
return(us);
}
}
_logger.InsertError("Failed to save session." + us.UserName, "SessionManager", "SaveSession");
return(null);
}
public void Api_RoleController_GetRoles()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role mdl = new Role();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
mdl.StartDate = DateTime.Now;
mdl.EndDate = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(mdl));
Role mdl2 = new Role();
mdl2.AccountUUID = SystemFlag.Default.Account;
mdl2.Name = Guid.NewGuid().ToString("N");
mdl2.DateCreated = DateTime.Now;
mdl2.EndDate = DateTime.Now;
mdl2.StartDate = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(mdl2));
Task.Run(async() =>
{
DataFilter filter = new DataFilter();
filter.PageResults = false;
ServiceResult res = await TestHelper.SentHttpRequest("GET", "api/Roles/?filter=" + JsonConvert.SerializeObject(filter), "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <Role> Roles = JsonConvert.DeserializeObject <List <Role> >(res.Result.ToString());
Assert.IsNotNull(Roles);
Assert.IsTrue(Roles.Count >= 2);
int foundRoles = 0;
foreach (Role p in Roles)
{
if (p.Name == mdl.Name || p.Name == mdl2.Name)
{
foundRoles++;
}
}
Assert.AreEqual(foundRoles, 2);
}).GetAwaiter().GetResult();
}
public void TestSetup()
{
ServiceResult res = TestHelper.InitializeControllerTestData(connectionKey, "OWNER");
Assert.AreNotEqual(res.Code, 500, res.Message);//should not be error. if it is assert.
_ownerAuthToken = res.Result.ToString();
Assert.IsNotNull(ConfigurationManager.AppSettings["DefaultDbConnection"]);
Random rand = new Random();
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
for (int i = 0; i < 100; i++)
{
MeasurementLog m = new MeasurementLog()
{
AccountUUID = SystemFlag.Default.Account,
Name = "name-" + i.ToString(),
DateTaken = DateTime.UtcNow.AddMonths(rand.Next(0, 12) * -1),
Measure = (float)rand.Next(0, 100),
MeasureType = "numeric",
UnitOfMeasure = "inches"
};
context.Insert <MeasurementLog>(m);
}
#region from DatasetManager.Tests.cs
//TreeMonDbContext context = new TreeMonDbContext(connectionKey);
//Random rand = new Random();
////Seed AuthenticationLog
//for (int i = 0; i < 100; i++)
//{
// context.Insert<AuthenticationLog>(new AuthenticationLog()
// {
// Authenticated = i % 3 == 0 ? false : true,
// AuthenticationDate = DateTime.UtcNow.AddMonths(rand.Next(0, 12) * -1),
// UserName = "******"
// });
//}
//context.Insert<AuthenticationLog>(new AuthenticationLog()
//{
// Authenticated = false,
// AuthenticationDate = DateTime.UtcNow.AddMonths(-1),
// UserName = "******"
//});
////Seed Measurements
//for (int i = 0; i < 100; i++)
//{
// context.Insert<MeasurementLog>(new MeasurementLog()
// {
// DateTaken = DateTime.UtcNow.AddMonths(rand.Next(0, 12) * -1),
// Measure = rand.Next(0, 100),
// UnitOfMeasure = "centimeters"
// });
//}
#endregion
}
/// <summary>
/// This is just a basic check if they're banned, locked,
/// approved etc.
///
/// </summary>
/// <param name="u"></param>
/// <returns></returns>
public ServiceResult IsUserAuthorized(User user, string ip)
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (user.Deleted)
{
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = false, AuthenticationDate = DateTime.UtcNow, IPAddress = ip, FailType = "Deleted User", UserName = user.Name, UUIDType = "AuthenticationLog", Vector = "UserManager.AuthenticateUser"
});
return(ServiceResponse.Error("User was deleted."));
}
//this is set by clicking the validation email.
if (!user.Approved)
{
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = false, AuthenticationDate = DateTime.UtcNow, IPAddress = ip, FailType = "Unapproved User", UserName = user.Name, UUIDType = "AuthenticationLog", Vector = "UserManager.AuthenticateUser"
});
return(ServiceResponse.Error("Account has not been approved. You must activate the account with the confirmation email before logging in. Check your spam/junk folder for the confirmation email if you have not received it. <a href=\"/Account/SendValidationEmail/?userUUID=" + user.UUID + "\">Resend Validation Email</a><br/>"));
}
if (user.LockedOut)
{
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = false, AuthenticationDate = DateTime.UtcNow, IPAddress = ip, FailType = "Locked User", UserName = user.Name, UUIDType = "AuthenticationLog", Vector = "UserManager.AuthenticateUser"
});
return(ServiceResponse.Error("User is locked out."));
}
if (user.Banned)
{
context.Insert <AuthenticationLog>(new AuthenticationLog()
{
Authenticated = false, AuthenticationDate = DateTime.UtcNow, IPAddress = ip, FailType = "Banned User", UserName = user.Name, UUIDType = "AuthenticationLog", Vector = "UserManager.AuthenticateUser"
});
return(ServiceResponse.Error("User is banned."));
}
}
return(ServiceResponse.OK());
}
public void Api_AnatomyController_Get_Anatomy_()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Anatomy mdl = new Anatomy();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Anatomy>(mdl));
Anatomy mdl2 = new Anatomy();
mdl2.AccountUUID = SystemFlag.Default.Account;
mdl2.Name = Guid.NewGuid().ToString("N");
mdl2.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Anatomy>(mdl2));
Task.Run(async() =>
{
DataFilter filter = new DataFilter();
filter.PageResults = false;
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Anatomy/?filter=" + JsonConvert.SerializeObject(filter), "", _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
List <Anatomy> Anatomy = JsonConvert.DeserializeObject <List <Anatomy> >(res.Result.ToString());
Assert.IsNotNull(Anatomy);
Assert.IsTrue(Anatomy.Count >= 2);
int foundAnatomy = 0;
foreach (Anatomy p in Anatomy)
{
if (p.Name == mdl.Name || p.Name == mdl2.Name)
{
foundAnatomy++;
}
}
Assert.AreEqual(foundAnatomy, 2);
}).GetAwaiter().GetResult();
}
public void Api_RoleController_AddUsersToRole()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Role role = new Role();
role.UUID = Guid.NewGuid().ToString("N");
role.AccountUUID = SystemFlag.Default.Account;
role.Name = Guid.NewGuid().ToString("N");
role.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Role>(role));
User u = TestHelper.GenerateTestUser(Guid.NewGuid().ToString("N"));
Assert.IsTrue(context.Insert <User>(u));
UserRole userRole = new UserRole();
userRole.RoleUUID = role.UUID;
userRole.UUID = Guid.NewGuid().ToString("N");
userRole.AccountUUID = role.AccountUUID;
userRole.UserUUID = u.UUID;
role.DateCreated = DateTime.Now;
List <UserRole> userRoles = new List <UserRole>();
userRoles.Add(userRole);
string postData = JsonConvert.SerializeObject(userRoles);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Roles/" + role.UUID + "/Users/Add", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
UserRole dbUserRole = context.GetAll <UserRole>().Where(w => w.RoleUUID == role.UUID).FirstOrDefault();
Assert.IsNotNull(dbUserRole);
Assert.AreEqual(userRole.AccountUUID, dbUserRole.AccountUUID);
// Assert.AreEqual(userRole.PermissionUUID, p.UUID);
}).GetAwaiter().GetResult();
}
public ServiceResult AddUserToAccount(string accountUUID, string userUUID, User requestingUser)
{
if (string.IsNullOrWhiteSpace(accountUUID))
{
return(ServiceResponse.Error("Invalid account id"));
}
if (string.IsNullOrWhiteSpace(userUUID))
{
return(ServiceResponse.Error("Invalid user id"));
}
using (var context = new TreeMonDbContext(this._connectionKey))
{
Account a = context.GetAll <Account>().FirstOrDefault(w => w.UUID == accountUUID);
if (a == null)
{
return(ServiceResponse.Error("Account not found."));
}
if (!this.DataAccessAuthorized(a, "DELETE", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
// if (!_roleManager.DataAccessAuthorized(a, requestingUser, "post", false))
// return ServiceResponse.Error("Access denied for account " + a.Name );
User u = context.GetAll <User>().FirstOrDefault(w => w.UUID == userUUID);
if (u == null)
{
return(ServiceResponse.Error("User not found."));
}
if (!_roleManager.DataAccessAuthorized(u, requestingUser, "post", false))
{
return(ServiceResponse.Error("Access denied for user " + u.Name));
}
if (IsUserInAccount(accountUUID, userUUID))
{
return(ServiceResponse.OK("User is already a member of the account."));
}
if (context.Insert <AccountMember>(new AccountMember()
{
AccountUUID = accountUUID, MemberUUID = userUUID, MemberType = "User"
}))
{
return(ServiceResponse.OK(string.Format("User {0} added account.", u.Name)));
}
}
return(ServiceResponse.Error("Server error, member was not added to the account."));
}
