/// <summary>
/// Create new user in database
/// </summary>
/// <param name="nickName"></param>
/// <param name="password"></param>
/// <param name="email"></param>
/// <returns></returns>
internal DbOperationStatus <User> CreateNew(string nickName, string password, string email)
{
DbOperationStatus <User> status = new DbOperationStatus <User>();
User newUser = new User()
{
Nickname = nickName,
Email = email,
ID = new Guid(),
IsOnline = false,
LastLoginDate = DateTime.MinValue,
RegistrationDate = DateTime.Now,
Verified = false,
VerificationToken = Guid.NewGuid()
};
using (var userPasswordCrypto = new UserPasswordCryptography(password))
{
var encryptionResult = userPasswordCrypto.EncryptUserPassword();
newUser.Salt = encryptionResult.Salt;
newUser.HashedPassword = encryptionResult.HashedPassword;
}
var num = newUser.Salt.Count();
_comparerDatabaseContext.Users.Add(newUser);
status.RowsAffected = _comparerDatabaseContext.SaveChanges();
status.OperationSuccess = true;
status.ReturnedObject = newUser;
return(status);
}
/// <summary>
/// Set new password to the user
/// </summary>
/// <param name="userID">User ID</param>
/// <param name="newPassword">Password selected by user</param>
/// <returns></returns>
internal DbOperationStatus <User> UpdatePassword(Guid userID, string newPassword)
{
DbOperationStatus <User> status = new DbOperationStatus <User>
{
QueryResult = _comparerDatabaseContext.Users.Where(u => u.ID.Equals(userID))
.SingleOrDefault()
};
if (status.QueryResult != null)
{
User user = status.QueryResult as User;
using (var userPasswordCrypto = new UserPasswordCryptography(newPassword))
{
var encryptionResult = userPasswordCrypto.EncryptUserPassword();
user.Salt = encryptionResult.Salt;
user.HashedPassword = encryptionResult.HashedPassword;
}
status.RowsAffected = _comparerDatabaseContext.SaveChanges();
status.OperationSuccess = true;
}
else
{
_logger.LogError("Update user's password - no user has been found");
status.OperationSuccess = false;
}
return(status);
}
public int CreateBrokerage(AddBrokerageVm addBrokerageVm)
{
var brokerage = new Brokerage
{
Title = addBrokerageVm.Title
};
DbOperationStatus opStatus = BrokerageAccountRepository.InsertBrokerage(brokerage);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
public int Create(AddStockVm addStockVm)
{
var stock = new Stock
{
Title = addStockVm.Title,
Symbol = addStockVm.Symbol,
};
DbOperationStatus opStatus = StockRepository.InsertStock(stock);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
public int Create(AddMutualFundVm addMutualFundVm)
{
var mutualFund = new MutualFund()
{
Title = addMutualFundVm.Title,
Symbol = addMutualFundVm.Symbol,
};
DbOperationStatus opStatus = MutualRepository.InsertMutualFund(mutualFund);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
public int CreateBrokerageAccount(AddBrokerageAccountVm addBrokerageAccountVm)
{
var brokerageAccount = new BrokerageAccount
{
Title = addBrokerageAccountVm.Title,
IsRetirement = addBrokerageAccountVm.IsRetirement,
AccountNumber = addBrokerageAccountVm.AccountNumber,
UserId = ActiveUserService.GetUserId(),
BrokerageId = addBrokerageAccountVm.BrokerageId
};
DbOperationStatus opStatus = BrokerageAccountRepository.InsertBrokerageAccount(brokerageAccount);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
public IActionResult Confirmation(string userID)
{
try
{
DbOperationStatus <User> operationStatus = _dbAccessUser.ActivateAccount(userID);
if (!operationStatus.OperationSuccess)
{
throw new Exception("Error while activating account");
}
}
catch (Exception ex)
{
return(View("Error", ex));
}
return(View("GenericUserInformation", new GenericInformationModelView("Account activated!", UserMessages.AccountHasBeenActivated)));
}
/// <summary>
/// Select user from database by Guid (ID)
/// </summary>
/// <param name="userGuid"></param>
/// <returns></returns>
internal DbOperationStatus <User> GetUserByGuid(Guid userGuid)
{
DbOperationStatus <User> status = new DbOperationStatus <User>
{
QueryResult = _comparerDatabaseContext.Users.Where(u => u.ID.Equals(userGuid)).SingleOrDefault()
};
if (status.QueryResult == null)
{
status.OperationSuccess = false;
_logger.LogError($"Can't find user with id: \"{userGuid}\" in database");
}
else
{
status.ReturnedObject = status.QueryResult as User;
}
return(status);
}
/// <summary>
/// Activate user's account by set verified property to true
/// </summary>
/// <param name="userID"></param>
/// <param name="accountActivationGuid"></param>
/// <returns></returns>
internal DbOperationStatus <User> ActivateAccount(string accountActivationGuid)
{
DbOperationStatus <User> status = new DbOperationStatus <User>()
{
QueryResult = _comparerDatabaseContext.Users.Where(x => x.VerificationToken.ToString() == accountActivationGuid).SingleOrDefault(),
};
if (status.QueryResult != null)
{
(status.QueryResult as User).Verified = true;
status.RowsAffected = _comparerDatabaseContext.SaveChanges();
status.OperationSuccess = true;
}
else
{
status.OperationSuccess = false;
_logger.LogError("Account activation failed - no user has been found");
}
return(status);
}
public DbOperationStatus InsertStock(Stock stock)
{
var opStatus = new DbOperationStatus
{
OperationSuccessStatus = false,
AffectedIndices = new List <int>()
};
try
{
DataContext.Set <Stock>().Add(stock);
opStatus.OperationSuccessStatus = DataContext.SaveChanges() > 0;
if (opStatus.OperationSuccessStatus)
{
opStatus.AffectedIndices.Add(stock.Id);
}
}
catch (Exception ex)
{
opStatus = DbOperationStatus.CreateFromException("Error inserting " + stock.GetType(), ex);
}
return(opStatus);
}
public DbOperationStatus InsertMutualFund(MutualFund mutualFund)
{
var opStatus = new DbOperationStatus
{
OperationSuccessStatus = false,
AffectedIndices = new List <int>()
};
try
{
DataContext.Set <MutualFund>().Add(mutualFund);
opStatus.OperationSuccessStatus = DataContext.SaveChanges() > 0;
if (opStatus.OperationSuccessStatus)
{
opStatus.AffectedIndices.Add(mutualFund.Id);
}
}
catch (Exception ex)
{
opStatus = DbOperationStatus.CreateFromException("Error inserting " + mutualFund.GetType(), ex);
}
return(opStatus);
}
public DbOperationStatus InsertPurchaseTransaction(PurchaseTransaction purchaseTransaction)
{
var opStatus = new DbOperationStatus
{
OperationSuccessStatus = false,
AffectedIndices = new List <int>()
};
try
{
DataContext.Set <PurchaseTransaction>().Add(purchaseTransaction);
opStatus.OperationSuccessStatus = DataContext.SaveChanges() > 0;
if (opStatus.OperationSuccessStatus)
{
opStatus.AffectedIndices.Add(purchaseTransaction.Id);
}
}
catch (Exception ex)
{
opStatus = DbOperationStatus.CreateFromException("Error inserting " + purchaseTransaction.GetType(), ex);
}
return(opStatus);
}
public int CreateStockPurchase(AddPurchaseTransactionVm addPurchaseTransactionVm)
{
var purchaseTransaction = new PurchaseTransaction()
{
BrokerageAccountId = addPurchaseTransactionVm.BrokerageAccountId,
Commission = addPurchaseTransactionVm.Commission,
SecurityId = addPurchaseTransactionVm.SecurityId,
ShareQuantity = addPurchaseTransactionVm.ShareQuantity,
UnitPrice = addPurchaseTransactionVm.UnitPrice,
TransactionDate = addPurchaseTransactionVm.TransactionDate,
ClosedShares = 0,
RemainingShares = addPurchaseTransactionVm.ShareQuantity,
PositionClosedStatus = false
};
DbOperationStatus opStatus = PurchaseTransactionRepository.InsertPurchaseTransaction(purchaseTransaction);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
public DbOperationStatus InsertBrokerageAccount(BrokerageAccount brokerageAccount)
{
var opStatus = new DbOperationStatus
{
OperationSuccessStatus = false,
AffectedIndices = new List <int>()
};
try
{
DataContext.Set <BrokerageAccount>().Add(brokerageAccount);
opStatus.OperationSuccessStatus = DataContext.SaveChanges() > 0;
if (opStatus.OperationSuccessStatus)
{
opStatus.AffectedIndices.Add(brokerageAccount.Id);
}
}
catch (Exception ex)
{
opStatus = DbOperationStatus.CreateFromException("Error inserting " + brokerageAccount.GetType(), ex);
}
return(opStatus);
}
/// <summary>
/// Remove user by ID
/// </summary>
/// <param name="userID">User ID to search and remove user</param>
/// <returns>Database operation result</returns>
internal DbOperationStatus <User> RemoveByID(Guid userID)
{
DbOperationStatus <User> status = new DbOperationStatus <User>
{
QueryResult = _comparerDatabaseContext.Users.Where(u => u.ID.Equals(userID))
.SingleOrDefault()
};
if (status.QueryResult != null)
{
User user = status.QueryResult as User;
_comparerDatabaseContext.Remove(user);
status.OperationSuccess = true;
}
else
{
_logger.LogError("Failed to remove user - no user has been found");
status.OperationSuccess = false;
}
return(status);
}
public int CreateSellTransaction(AddSellTransactionVm addSellTransactionVm)
{
var shareQuantitySold = addSellTransactionVm.ShareQuantity;
var sellUnitPrice = addSellTransactionVm.UnitPrice;
var sellCommission = addSellTransactionVm.Commission;
var sellDate = addSellTransactionVm.TransactionDate;
decimal totalNetProfit = 0;
decimal longTermPositionsClosed = 0;
decimal longTermPositionsNetProfit = 0;
decimal shortTermPositionsClosed = 0;
decimal shortTermPositionsNetProfit = 0;
var closingTransactionMatches = new List <ClosingTransactionMatch>();
foreach (var purchaseTransaction in addSellTransactionVm.MatchingPurchaseTransactions)
{
if (purchaseTransaction.ShareQuantity > 0)
{
var purchaseTransactionDetails =
PurchaseTransactionRepository.GetPurchaseTransaction(purchaseTransaction.PurchaseTransactionId);
// Requesting to close out more shares than the position has remaining open?
if (purchaseTransaction.ShareQuantity > purchaseTransactionDetails.RemainingShares)
{
return(-1);
}
var capitalGain = (purchaseTransaction.ShareQuantity * sellUnitPrice) // Individual Match Sell Value
- (purchaseTransaction.ShareQuantity / shareQuantitySold) * sellCommission // Individual Match Sell Commission
- (purchaseTransaction.ShareQuantity * purchaseTransactionDetails.UnitPrice) // Individual Match Purchase Value
- (purchaseTransaction.ShareQuantity / purchaseTransactionDetails.ShareQuantity) * purchaseTransactionDetails.Commission; // Individual Match Purchase Commission
totalNetProfit += capitalGain;
if ((sellDate - purchaseTransactionDetails.TransactionDate).TotalDays > 365)
{
// Long Term Capital Gain - Greater than 1 year
longTermPositionsClosed += purchaseTransaction.ShareQuantity;
longTermPositionsNetProfit += capitalGain;
}
else
{
// Short Term Capital Gain - Less than 1 year
shortTermPositionsClosed += purchaseTransaction.ShareQuantity;
shortTermPositionsNetProfit += capitalGain;
}
purchaseTransactionDetails.ClosedShares += purchaseTransaction.ShareQuantity;
purchaseTransactionDetails.RemainingShares -= purchaseTransaction.ShareQuantity;
if (purchaseTransactionDetails.RemainingShares == 0)
{
purchaseTransactionDetails.PositionClosedStatus = true;
}
PurchaseTransactionRepository.UpdatePurchaseTransaction(purchaseTransactionDetails);
var closingTransactionMatch = new ClosingTransactionMatch
{
MatchingShareCount = purchaseTransaction.ShareQuantity,
PurchaseTransactionId = purchaseTransactionDetails.Id,
TotalNetProfit = capitalGain
};
closingTransactionMatches.Add(closingTransactionMatch);
}
}
var sellTransaction = new SellTransaction
{
BrokerageAccountId = addSellTransactionVm.BrokerageAccountId,
UnitPrice = sellUnitPrice,
ShareQuantity = shareQuantitySold,
SecurityId = addSellTransactionVm.SecurityId,
Commission = sellCommission,
TransactionDate = sellDate,
TotalNetProfit = totalNetProfit,
Profitable = (totalNetProfit >= 0),
LongTermPositionsClosed = longTermPositionsClosed,
LongTermPositionsNetProfit = longTermPositionsNetProfit,
ShortTermPositionsClosed = shortTermPositionsClosed,
ShortTermPositionsNetProfit = shortTermPositionsNetProfit,
ClosingTransactionMatches = closingTransactionMatches
};
DbOperationStatus opStatus = SellTransactionRepository.InsertSellTransaction(sellTransaction);
if (opStatus.OperationSuccessStatus)
{
return(opStatus.AffectedIndices.First());
}
return(-1);
}
