public IEnumerable <LogEntry> GetAll()
{
using (var context = new TreeMonDbContext(_dbConnectionKey))
{
return(context.GetAll <LogEntry>());
}
}
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();
}
public List <UnitOfMeasure> GetUnitsOfMeasure(string accountUUID, string category, bool deleted = false)
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
return(context.GetAll <UnitOfMeasure>().Where(sw => (sw.AccountUUID == accountUUID) && (sw.Category?.EqualsIgnoreCase(category) ?? false) && sw.Deleted == deleted).OrderBy(ob => ob.Name).ToList());
}
}
/// <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 List <dynamic> GetAll(string type = "")
{
List <dynamic> res = new List <dynamic>();
if (string.IsNullOrWhiteSpace(type))
{
return(res);
}
if (this._requestingUser == null || string.IsNullOrWhiteSpace(this._requestingUser.AccountUUID))
{
return(res);
}
if (type == "all")
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
res.AddRange(context.GetAll <TreeMon.Models.Plant.Plant>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
res.AddRange(context.GetAll <Ballast>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
res.AddRange(context.GetAll <Bulb>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
// res.AddRange( context.GetAll<Custom>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast<dynamic>().ToList());
res.AddRange(context.GetAll <Fan>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
res.AddRange(context.GetAll <Filter>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
res.AddRange(context.GetAll <Pump>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
res.AddRange(context.GetAll <Vehicle>().Where(w => w.AccountUUID == this._requestingUser.AccountUUID).Cast <dynamic>().ToList());
}
return(res);
}
return(this.GetEquipment(type).Where(w => w.AccountUUID == this._requestingUser.AccountUUID).ToList());
}
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 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 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 void Api_UnitOfMeasureController_AddUnitOfMeasure()
{
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;
string postData = JsonConvert.SerializeObject(mdl);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/UnitsOfMeasure/Add", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
UnitOfMeasure p = JsonConvert.DeserializeObject <UnitOfMeasure>(res.Result.ToString());
Assert.IsNotNull(p);
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
UnitOfMeasure dbUnitOfMeasure = context.GetAll <UnitOfMeasure>().Where(w => w.UUID == p.UUID).FirstOrDefault();
Assert.IsNotNull(dbUnitOfMeasure);
Assert.AreEqual(mdl.Name, dbUnitOfMeasure.Name);
}).GetAwaiter().GetResult();
}
/// <summary>
/// Gets the shipping methods.
/// </summary>
/// <param name="source">The source.</param>
/// <returns></returns>
public List <ShippingMethod> GetShippingMethods()
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
return(context.GetAll <ShippingMethod>().OrderBy(sm => sm.Price).ToList());
}
}
/// <summary>
/// Cheapests the specified source.
/// </summary>
/// <param name="source">The source.</param>
/// <returns></returns>
public ShippingMethod CheapestShipping()
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
return(context.GetAll <ShippingMethod>().OrderBy(sm => sm.Price).FirstOrDefault());
}
}
public ShoppingCartItem GetCartItem(string cartItemUUID)
{
using (var context = new TreeMonDbContext(this._connectionKey))
{
return(context.GetAll <ShoppingCartItem>().FirstOrDefault(w => w.UUID == cartItemUUID));
}
}
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 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 async void TreeMonDbContext_Context_Insert_Async()
{
TreeMonDbContext context = new TreeMonDbContext("MSSQL_TEST");
int res = await context.InsertAsync <User>(_userAsync);
Assert.IsTrue(res > 0);
}
/// <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 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 List <EmailLog> GetEmailLogs(string accountUUID, bool deleted = false)
{
using (var context = new TreeMonDbContext(_dbConnectionKey))
{
return(context.GetAll <EmailLog>().Where(sw => (sw.AccountUUID == accountUUID) && sw.Deleted == deleted).OrderBy(ob => ob.DateSent).ToList());
}
}
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(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 UserSession GetSession(string authToken, bool validate = true)
{
try {
using (var context = new TreeMonDbContext(_connectionKey))
{
if (!validate)
{
return(context.GetAll <UserSession>().OrderByDescending(ob => ob.Issued).FirstOrDefault(w => w.AuthToken == authToken));
}
if (!IsValidSession(authToken))
{
return(null);
}
return(context.GetAll <UserSession>().OrderByDescending(ob => ob.Issued).FirstOrDefault(w => w.AuthToken == authToken));
}
}
catch (Exception ex)
{
_logger.InsertError(ex.Message, "SessionManager", "GetSession");
Debug.Assert(false, ex.Message);
}
return(null);
}
/// <summary>
/// Returns accounts the users is not a member of
/// </summary>
/// <param name="userUUID"></param>
/// <returns></returns>
public List <Account> GetNonMemberAccounts(string userUUID)
{
string sql = @"SELECT
Accounts.Id,
Accounts.ParentId,
Accounts.UUID,
Accounts.UUIDType,
Accounts.UUParentID,
Accounts.UUParentIDType,
Accounts.Name,
Accounts.Status,
UsersInAccount.MemberUUID
FROM
Accounts ,
UsersInAccount
WHERE
UsersInAccount.MemberUUID <> @MEMBERID OR
Accounts.UUID <> '' and Accounts.Deleted = 0";
DynamicParameters p = new DynamicParameters();
p.Add("@MEMBERID", userUUID);
List <Account> userAccounts;
using (var context = new TreeMonDbContext(this._connectionKey))
{
userAccounts = context.Select <Account>(sql, p).ToList();
}
//if (!this.DataAccessAuthorized(u, "GET", false)) return ServiceResponse.Error("You are not authorized this action.");
return(userAccounts);
}
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 List <User> GetAccountMembers(string accountUUID, bool clearSensitiveData = true)
{
List <User> accountMembers;
using (var context = new TreeMonDbContext(this._connectionKey))
{
accountMembers = context.GetAll <AccountMember>().Where(w => w.AccountUUID == accountUUID)
.Join(
context.GetAll <User>()
.Where(w => w.Deleted == false),
acct => acct.MemberUUID,
users => users.UUID,
(acct, users) => new { acct, users }
)
.Select(s => s.users)
.ToList();
}
if (accountMembers == null)
{
return(new List <User>());
}
if (clearSensitiveData)
{
accountMembers = new UserManager(this._connectionKey, SessionKey).ClearSensitiveData(accountMembers);
}
//if (!this.DataAccessAuthorized(u, "GET", false)) return ServiceResponse.Error("You are not authorized this action.");
return(accountMembers);
}
public ServiceResult Update(INode n)
{
if (n == null)
{
return(ServiceResponse.Error("No record sent."));
}
var p = (Vendor)n;
if (!this.DataAccessAuthorized(p, "PATCH", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
ServiceResult res = ServiceResponse.OK();
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (context.Update <Vendor>(p) == 0)
{
return(ServiceResponse.Error(p.Name + " failed to update. "));
}
}
return(res);
}
/// <summary>
/// Gets all users not in the account
/// </summary>
/// <param name="accountUUID"></param>
/// <param name="clearSensitiveData"></param>
/// <returns></returns>
public List <User> GetAccountNonMembers(string accountUUID, bool clearSensitiveData = true)
{
List <User> nonMembers;
using (var context = new TreeMonDbContext(this._connectionKey))
{
//this query is from a bug, just kludge it in for now. backlog fix this damn mess.
nonMembers = context.GetAll <User>().Where(w => w.Deleted == false && string.IsNullOrWhiteSpace(w.AccountUUID) == true).ToList();
nonMembers.AddRange(context.GetAll <AccountMember>().Where(w => w.AccountUUID != accountUUID)
.Join(
context.GetAll <User>()
.Where(w => w.Deleted == false),
acct => acct.MemberUUID,
users => users.UUID,
(acct, users) => new { acct, users }
)
.Select(s => s.users)
.ToList());
}
List <User> members = GetAccountMembers(accountUUID, clearSensitiveData);
if (members != null)
{
nonMembers = nonMembers.Except(members).ToList();
}
//if (!this.DataAccessAuthorized(u, "GET", false)) return ServiceResponse.Error("You are not authorized this action.");
return(nonMembers);
}
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));
}
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 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 LogEntry Get(int id)
{
using (var context = new TreeMonDbContext(_dbConnectionKey))
{
return(context.Get <LogEntry>(id));
}
}
