} // set deactivationdate with current datetime
public async Task <Account> EditAsync(Account account)
{
ObjectEmpty(account);
if (int.TryParse(account.Id, out int id))
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == id);
ObjectEmptyFromDb(sqlAccount);
var oldAccount = mapper.Map <Account>(sqlAccount);
if (sqlAccount.DeactivationDate == null)
{
if (oldAccount.GetType() != account.GetType())
{
account.Email = sqlAccount.Email;
account.Nickname = sqlAccount.Nickname;
account.CreationDate = account.CreationDate;
account.IsDefault = sqlAccount.IsDefault;
return(await ChangeTypeAccount(account));
}
account.LastEdit = DateTime.Now;
mapper.Map(account, sqlAccount);
await dbContext.SaveChangesAsync();
return(mapper.Map <Account>(sqlAccount));
}
}
throw new NullReferenceException(Resource.InvalidOperation);
} // set values of object passed on params with new values
public async Task <bool> SaveVeicleAssignement(VeicleAssignement veicleAssignement)
{
if (veicleAssignement != null)
{
if (int.TryParse(veicleAssignement.Account.Id, out int accountId) & int.TryParse(veicleAssignement.Veicle.Id, out int veicleId))
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accountId);
SqlVeicle sqlVeicle = await dbContext.SqlVeicles.FirstOrDefaultAsync(x => x.Id == veicleId);
SqlVeicleAssignement sqlVeicleAssignement = mapper.Map <SqlVeicleAssignement>(veicleAssignement);
List <SqlVeicleAssignement> validYet = dbContext.SqlVeicleAssignements.Where(x => x.SqlVeicle == sqlVeicle).ToList();
foreach (var vA in validYet)
{
if (vA.From == veicleAssignement.From)
{
return(false);
}
}
sqlVeicleAssignement.SqlAccount = sqlAccount;
sqlVeicleAssignement.SqlVeicle = sqlVeicle;
await dbContext.SqlVeicleAssignements.AddAsync(sqlVeicleAssignement);
return(await dbContext.SaveChangesAsync() > 0);
}
}
return(false);
}
public void Update()
{
if (account != null)
{
GotAccount(account);
account = null;
}
}
public void GotAccount(SqlAccount account)
{
if (account == null)
{
return;
}
Account = account;
}
public void Update()
{
if (PendingRefresh != null)
{
Set(PendingRefresh);
Loading.Instance.SetOpen(false);
PendingRefresh = null;
}
}
public void Close()
{
gameObject.SetActive(false);
account = null;
AccountsView.Instance.Refresh();
AccountDetailsView.Instance.OpenAccount(AccountDetailsView.Instance.ID);
}
public void Open(SqlAccount account)
{
gameObject.SetActive(true);
BalanceChange.text = "";
Notes.text = "";
this.account = account;
Title.text = account.Name.Trim();
}
public void Update()
{
if (Account != null)
{
Loading.Instance.SetOpen(false);
AccountOptionsWindow.Instance.TriggerOpen(Account);
Account = null;
}
}
} // return a list of users that have deactivationdate setted on null
public async Task <Account> GetById(string id)
{
ObjectEmpty(id);
if (int.TryParse(id, out int accountId))
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accountId);
ObjectEmptyFromDb(sqlAccount);
return(mapper.Map <Account>(sqlAccount));
}
throw new NullReferenceException(Resource.InvalidOperation);
} // return a user from it's id
} // return a list of accounts
public async Task <Account> CreateAccountAsync(Account account)
{
ObjectEmpty(account);
account.CreationDate = DateTime.Now;
account.LastEdit = DateTime.Now;
SqlAccount sqlAccount = mapper.Map <SqlAccount>(account);
dbContext.SqlAccounts.Add(sqlAccount);
await dbContext.SaveChangesAsync();
return(mapper.Map <Account>(sqlAccount));
} // create a new istance of an account
public SqlAccount ParseAccount(MySqlDataReader reader)
{
int id = reader.GetInt32("id");
string name = reader.GetString("name");
int balance = reader.GetInt32("balance");
SqlAccount account = new SqlAccount()
{
ID = id, Name = name, Balance = balance
};
return(account);
}
public async Task <User> CheckUser(string email, string password)
{
if (email != null && password != null)
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.Where(x => x.Email.Equals(email)).FirstOrDefaultAsync(x => x.Password.Equals(password));
SqlAssignement sqlAssignement = await dbContext.SqlAssignements.FirstOrDefaultAsync(x => x.SqlAccount.Id == sqlAccount.Id);
SqlUser sqlUser = sqlAssignement.SqlUser;
return(mapper.Map <User>(sqlUser));
}
throw new NullReferenceException();
}
public SqlAccount GetSqlAccount(int id)
{
using (MySqlDataReader reader = ExecuteReader("SELECT * FROM " + accountsTable + " WHERE id = " + id.ToString()))
{
while (reader.Read())
{
SqlAccount acc = ParseAccount(reader);
return(acc);
}
Debug.LogError("No account for that ID was found!");
return(null);
}
}
} // return a list of account by an user that has a relations
public async Task <ICollection <Assignement> > AssignementsbyAccountIdAsync(string id)
{
ObjectEmpty(id);
if (int.TryParse(id, out int accountId))
{
List <Assignement> listAssignement = new List <Assignement>();
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accountId);
ObjectEmptyFromDb(sqlAccount);
List <SqlAssignement> sqlAssignements = dbContext.SqlAssignements.Where(x => x.SqlAccount == sqlAccount).Where(x => x.DeactivationDate == null).ToList();
return(mapper.Map <List <Assignement> >(sqlAssignements));
}
throw new NullReferenceException(Resource.InvalidOperation);
} // return a list of relations from an account passed on params
} // return an user from it's id
public async Task <bool> ChangePassword(Account account)
{
if (account != null)
{
if (int.TryParse(account.Id, out int accId))
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accId);
sqlAccount.Password = account.Password;
return(await dbContext.SaveChangesAsync() > 0);
}
}
return(false);
}
public void UpdateAccountBalance(int Id, int balanceChange, UnityAction done)
{
Thread thread = new Thread(() =>
{
SqlAccount account = GetSqlAccount(Id);
int currentBalance = account.Balance;
int updated = currentBalance + balanceChange;
ExecuteNonQuery("UPDATE " + accountsTable + " SET balance = " + updated.ToString() + " WHERE id = " + account.ID);
done.Invoke();
});
thread.Start();
}
public async Task <ICollection <User> > UsersFromAccount(SqlAccount sqlAccount)
{
await Task.Delay(0);
if (sqlAccount == null)
{
throw new NullReferenceException(Resource.ObjectEmpty);
}
List <User> users = new List <User>();
List <SqlAssignement> sqlAssignements = dbContext.SqlAssignements.Where(x => x.SqlAccount.Id == sqlAccount.Id).ToList();
foreach (var assignement in sqlAssignements.Where(x => x.DeactivationDate == null))
{
users.Add(mapper.Map <User>(assignement.SqlUser));
}
return(users);
}
public async Task <bool> DeleteAssignement(SqlAccount sqlAccount, SqlUser sqlUser)
{
if (sqlAccount == null || sqlUser == null)
{
throw new NullReferenceException(Resource.ObjectEmpty);
}
SqlAssignement sqlAssignement = dbContext.SqlAssignements.Where(x => x.SqlAccount.Id == sqlAccount.Id)
.Where(x => x.SqlUser.Id == sqlUser.Id)
.Where(x => x.DeactivationDate == null)
.FirstOrDefault();
sqlAssignement.DeactivationDate = DateTime.UtcNow;
sqlAssignement.LastEdit = DateTime.UtcNow;
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <bool> ResetAccountAsync(Account account)
{
if (int.TryParse(account.Id, out int accountId))
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accountId);
sqlAccount.DeactivationDate = null;
foreach (var assignement in sqlAccount.SqlAssignements)
{
assignement.DeactivationDate = null;
}
await dbContext.SaveChangesAsync();
return(true);
}
return(false);
}
public void Update()
{
if (this.account != null)
{
this.Title.text = account.Name;
Connection.Instance.GetAllLogsFor(account.ID, GotLogsThreaded);
this.account = null;
}
if (descriptions != null)
{
GotLogs(descriptions);
Loading.Instance.SetOpen(false);
descriptions = null;
}
}
public async Task <bool> SaveRequestAssignementAsync(RequestAssignement requestAssignement)
{
if (requestAssignement != null)
{
if (int.TryParse(requestAssignement.Account.Id, out int accountId) & int.TryParse(requestAssignement.Request.Id, out int requestId))
{
SqlAccount sqlAccount = await dbcontext.SqlAccounts.FirstOrDefaultAsync(x => x.Id == accountId);
SqlRequest sqlRequest = await dbcontext.SqlRequests.FirstOrDefaultAsync(x => x.Id == requestId);
SqlRequestAssignement sqlRequestAssignement = mapper.Map <SqlRequestAssignement>(requestAssignement);
sqlRequestAssignement.SqlAccount = sqlAccount;
sqlRequestAssignement.SqlRequest = sqlRequest;
dbcontext.SqlRequestAssignements.Add(sqlRequestAssignement);
return(await dbcontext.SaveChangesAsync() > 0);
}
}
return(false);
}
public void Set(SqlAccount account)
{
Loading.Instance.SetOpen(false);
if (account == null)
{
Title.text = "Account: None Selected";
CurrentBalance.text = "---";
HistoryButton.Disable();
ChangeBalanceButton.interactable = false;
}
else
{
Title.text = "Account: " + account.Name.Trim();
CurrentBalance.text = Convert.BalanceToCurrency(account.Balance);
HistoryButton.Enable();
ChangeBalanceButton.interactable = true;
}
}
public async Task <bool> SetAssignemet(SqlUser sqlUser, SqlAccount sqlAccount)
{
if (sqlUser == null || sqlAccount == null)
{
throw new NullReferenceException(Resource.ObjectEmpty);
}
SqlAssignement sqlAssignement = new SqlAssignement
{
SqlUser = sqlUser,
SqlAccount = sqlAccount,
CreationDate = DateTime.UtcNow,
LastEdit = DateTime.UtcNow
};
dbContext.SqlAssignements.Add(sqlAssignement);
await dbContext.SaveChangesAsync();
return(true);
}
public void GetSqlAccount(int id, UnityAction <SqlAccount> callback)
{
Thread thread = new Thread(() =>
{
using (MySqlDataReader reader = ExecuteReader("SELECT * FROM " + accountsTable + " WHERE id = " + id.ToString()))
{
while (reader.Read())
{
SqlAccount acc = ParseAccount(reader);
callback.Invoke(acc);
return;
}
Debug.LogError("No account for that ID was found!");
callback.Invoke(null);
}
});
thread.Start();
}
} // create a new istance of an account
public async Task <bool> DeleteAsync(string id)
{
ObjectEmpty(id);
if (int.TryParse(id, out int accountId))
{
SqlAccount sqlAccount = dbContext.SqlAccounts.FirstOrDefault(x => x.Id == accountId);
ObjectEmptyFromDb(sqlAccount);
if (sqlAccount.DeactivationDate == null)
{
sqlAccount.DeactivationDate = DateTime.Now;
sqlAccount.LastEdit = DateTime.Now;
foreach (var ass in dbContext.SqlAssignements.Where(x => x.SqlAccount.Id == accountId))
{
ass.DeactivationDate = DateTime.UtcNow;
ass.LastEdit = DateTime.UtcNow;
}
await dbContext.SaveChangesAsync();
return(true);
}
}
throw new NullReferenceException(Resource.InvalidOperation);
} // set deactivationdate with current datetime
private void SetPending(SqlAccount account)
{
this.PendingRefresh = account;
}
public void GotAccount(SqlAccount account)
{
Loading.Instance.SetOpen(false);
ChangeBalanceView.Instance.Open(account);
}
private void GotAccountThreaded(SqlAccount account)
{
this.account = account;
}
