public async Task <Holdings> GetHoldingDataForUserAndStock(IDbConnection connection, ulong userId, ulong stockId)
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("userId", userId);
dynamicParameters.Add("stockId", stockId);
connection.Open();
var holdingData = await connection.QueryFirstAsync(_selHoldingDetailsForParticularStock, dynamicParameters);
connection.Close();
var holdingId = holdingData.holding_id;
var holdingDetails = holdingData.holding_details;
var deserializedHoldingDetails = JsonSerializer.Deserialize <IEnumerable <HoldingDetails> >(holdingDetails);
var holding = new Holdings()
{
HoldingDetails = deserializedHoldingDetails,
HoldingId = holdingId,
StockId = stockId,
UserId = userId
};
return(holding);
}
/// <summary>
/// Get a list of the top gainers
/// </summary>
/// <param name="count">How many holdings do you want in the list?</param>
/// <param name="Gains">If true, returns top gainers, if false, top losers.</param>
/// <returns></returns>
public List <Holding> GetTopGainers(int count, bool gains)
{
refresh();
List <Holding> topGainers;
if (gains)
{
topGainers = Holdings.OrderByDescending(o => o.GetPerformance()).ToList();
}
else
{
topGainers = Holdings.OrderBy(o => o.GetPerformance()).ToList();
}
if (count < Holdings.Count)
{
List <Holding> topGainersConstrained = new List <Holding>();
for (int i = 0; i < count; i++)
{
topGainersConstrained.Add(topGainers[i]);
}
return(topGainersConstrained);
}
return(topGainers);
}
public async Task <IEnumerable <Holdings> > GetAllHoldingsForUser(IDbConnection connection, ulong userId)
{
var userHoldings = new List <Holdings>();
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("userId", userId);
connection.Open();
var holdings = await connection.QueryAsync(_selAllHoldingsForUser, dynamicParameters);
connection.Close();
foreach (var holdingData in holdings)
{
var holdingId = holdingData.holding_id;
var holdingDetails = holdingData.holding_details;
var stockId = holdingData.stock_id;
var deserializedHoldingDetails = JsonSerializer.Deserialize <IEnumerable <HoldingDetails> >(holdingDetails);
var holding = new Holdings()
{
HoldingDetails = deserializedHoldingDetails,
HoldingId = holdingId,
UserId = userId,
StockId = stockId
};
userHoldings.Add(holding);
}
return(userHoldings);
}
public async Task NewHolding(int AccountId, string CompanyName, string Symbol, int StockCount,
float LatestCostPerStock, float Change, float ChangePercentage, DateTime LastUpdated)
{
try
{
using (ITransaction transaction = _session.BeginTransaction())
{
var holdings = new Holdings
{
AccountId = AccountId,
CompanyName = CompanyName,
Symbol = Symbol,
StockCount = StockCount,
LatestCostPerStock = LatestCostPerStock,
Change = Change,
ChangePercentage = ChangePercentage,
LastUpdated = LastUpdated,
};
await _session.SaveAsync(holdings);
await transaction.CommitAsync();
}
}
catch
{
throw new NewHoldingException(_path, "NewHolding()");
}
finally
{
_nHibernateService.CloseSession();
}
}
public async Task <ActionResult <Holdings> > PostHoldings(Holdings holdings)
{
_context.Holdings.Add(holdings);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetHoldings", new { id = holdings.HoldingId }, holdings));
}
protected override void Add()
{
HoldingViewModel holding =
new HoldingViewModel(new HoldingModel {
Name = "New", IpServer = "localhost", Nom = Holdings.Count + 1
});
var conf = ConfigTempoSinglenton.GetInstance();
holding.ConnectionString = string.Format(Entrence.ConectionStringTemplate, holding.IpServer, conf.BaseDbPath, "H" + holding.Nom);
Holdings.Add(holding);
if (
MessageBoxWrapper.Show("Копиране на празна база от темплейтите?", "Предупреждение",
MessageBoxWrapperButton.YesNo) == MessageBoxWrapperResult.Yes)
{
IoHelper.DirectoryCopy(ConfigTempoSinglenton.GetInstance().BaseTemplatePath,
Path.Combine(ConfigTempoSinglenton.GetInstance().BaseDbPath, "H" + holding.Nom), true);
}
foreach (var item in conf.ConfigNames)
{
var spliter = item.Split('|');
FirmSettingModel newsett = new FirmSettingModel();
newsett.Key = spliter[0];
newsett.Name = spliter[1];
newsett.Value = spliter[2];
newsett.FirmaId = 1;
newsett.HoldingId = holding.Nom;
conf.FirmSettings.Add(newsett);
}
conf.SaveConfiguration();
}
public PlayerResults(int postion, Holdings holding, uint handStrength, HoleCards holeCards)
{
Position = postion;
Holding = holding;
HandStrength = handStrength;
HoleCards = holeCards;
}
public void UpdateHoldings_ShouldThrowException()
{
int AccountId = 2;
string CompanyName = "General Electric Co.";
string Symbol = "GE";
int StockCount = 5;
float LatestCostPerStock = 10.65F;
float Change = -0.33F;
float ChangePercentage = -0.02957F;
var LastUpdated = DateTime.Now;
var holdings = new Holdings
{
Id = 2,
AccountId = AccountId,
CompanyName = CompanyName,
Symbol = Symbol,
StockCount = StockCount,
LatestCostPerStock = LatestCostPerStock,
Change = Change,
ChangePercentage = ChangePercentage,
LastUpdated = LastUpdated
};
_session.BeginTransaction().ThrowsForAnyArgs(new Exception());
Assert.ThrowsAsync <UpdateHoldingsException>(() => _sut.UpdateHoldings(JObject.FromObject(holdings)));
}
public async Task UpdateHoldingDetails(ulong userId, Holdings holding)
{
using (var connection = _connectionService.GetOpenConnection(userId))
{
var holdingDetail = holding.HoldingDetails;
await _holdingsData.UpdateHoldingDetail(connection, holding.HoldingId, holdingDetail);
}
}
HoldingValue ComputeTotalStockValue(string user, string password)
{
Token token = AuthService.Check(user, password);
Holdings stocks = DbService.GetStockHoldings(token);
StockRates rates = StockService.GetRates(token);
return(ProcessStocks(stocks, rates));
}
/// <summary>
/// Creates an instance of the PointInTimePortfolio object
/// </summary>
/// <param name="order">Order applied to the portfolio</param>
/// <param name="portfolio">Algorithm portfolio at a point in time</param>
public PointInTimePortfolio(Order order, SecurityPortfolioManager portfolio)
{
Time = order.Time;
Order = order;
TotalPortfolioValue = portfolio.TotalPortfolioValue;
Holdings = portfolio.Securities.Values.Select(x => new PointInTimeHolding(x.Symbol, x.Holdings.HoldingsValue, x.Holdings.Quantity)).ToList();
Leverage = Holdings.Sum(x => x.AbsoluteHoldingsValue) / TotalPortfolioValue;
}
public void UpdateHoldings(Holdings holdingsToUpdate)
{
using (var transaction = _session.BeginTransaction())
{
_session.Update(holdingsToUpdate);
transaction.Commit();
}
}
/// <summary>
/// Update market price of this Security
/// </summary>
/// <param name="data">Data to pull price from</param>
protected virtual void UpdateConsumersMarketPrice(BaseData data)
{
if (data is OpenInterest || data.Price == 0m)
{
return;
}
Holdings.UpdateMarketPrice(Price);
VolatilityModel.Update(this, data);
}
public Holding AddHolding(string holdingname)
{
var newHolding = new Holding()
{
HoldingId = Holdings.Count() + 1,
HoldingName = holdingname
};
Holdings.Add(newHolding);
return newHolding;
}
/// <summary>
/// Update any security properties based on the lastest market data and time
/// </summary>
/// <param name="data">New data packet from LEAN</param>
public void SetMarketPrice(BaseData data)
{
//Add new point to cache:
if (data == null)
{
return;
}
Cache.AddData(data);
Holdings.UpdateMarketPrice(data.Value);
}
public List <Holding> GetHoldings(string ticker)
{
if (Holdings.ContainsKey(ticker))
{
if (Holdings.First(v => v.Key == ticker).Value.Any())
{
return(Holdings.First(v => v.Key == ticker).Value);
}
}
return(null);
}
/// <summary>
/// Update any security properties based on the latest market data and time
/// </summary>
/// <param name="data">New data packet from LEAN</param>
public void SetMarketPrice(BaseData data)
{
//Add new point to cache:
if (data == null)
{
return;
}
Cache.AddData(data);
Holdings.UpdateMarketPrice(Price);
VolatilityModel.Update(this, data);
}
/// <summary>
/// Update the Market Online Calculations:
/// </summary>
/// <param name="data">New Data packet:</param>
/// <param name="frontier">time frontier / where we are in time.</param>
public void Update(DateTime frontier, BaseData data)
{
//Update the Exchange/Timer:
Exchange.SetDateTimeFrontier(frontier);
//Add new point to cache:
if (data != null)
{
Cache.AddData(data);
Holdings.UpdatePrice(data.Value);
}
}
public Holdings ReadHoldingsById(int id)
{
var holdingRead = new Holdings();
using (var transaction = _session.BeginTransaction())
{
holdingRead = _session.Get <Holdings>(id);
transaction.Commit();
}
return(holdingRead);
}
/// <summary>
/// Update any security properties based on the lastest market data and time
/// </summary>
/// <param name="data">New data packet from LEAN</param>
/// <param name="frontier">Time frontier / where we are in time.</param>
public void SetMarketPrice(DateTime frontier, BaseData data)
{
//Update the Exchange/Timer:
Exchange.SetDateTimeFrontier(frontier);
//Add new point to cache:
if (data == null)
{
return;
}
Cache.AddData(data);
Holdings.UpdateMarketPrice(data.Value);
}
private void AddHolding(string ticker, Holding holding)
{
if (Holdings.ContainsKey(ticker))
{
Holdings.FirstOrDefault(v => v.Key == ticker).Value.Add(holding);
}
else
{
var holdingsList = new List <Holding>();
holdingsList.Add(holding);
Holdings.Add(ticker, holdingsList);
}
}
private void AddTestDataToHoldings()
{
Holding holding = new Holding("AAPL");
holding.numOfShares = 5;
holding.totalInvested = 80.00;
Holdings.Add(holding);
holding = new Holding("TSLA");
holding.numOfShares = 10;
holding.totalInvested = 10000.00;
Holdings.Add(holding);
}
public Holdings CreateHolding(Holdings holdingToCreate)
{
var holdingCreated = new Holdings();
using (var transaction = _session.BeginTransaction())
{
var newId = _session.Save(holdingToCreate);
holdingCreated = _session.Get <Holdings>(newId);
transaction.Commit();
}
return(holdingCreated);
}
private async Task AddNewHoldingDetails(IDbConnection connection, ulong userId, ulong stockId, HoldingDetails holdingDetails)
{
var holdings = new Holdings()
{
HoldingDetails = new List <HoldingDetails>()
{
holdingDetails
},
StockId = stockId,
UserId = userId
};
var holdingId = await _holdingsData.AddHolding(connection, holdings);
}
/// <summary>
/// Update any security properties based on the latest realtime data and time
/// </summary>
/// <param name="data">New data packet from LEAN</param>
public void SetRealTimePrice(BaseData data)
{
//Add new point to cache:
if (data == null)
{
return;
}
Cache.AddData(data);
if (data is OpenInterest || data.Price == 0m)
{
return;
}
Holdings.UpdateMarketPrice(Price);
}
/// <summary>
/// Update the Market Online Calculations:
/// </summary>
/// <param name="data">New Data packet:</param>
/// <param name="frontier"></param>
public void Update(DateTime frontier, MarketData data)
{
//Update the Exchange/Timer:
Exchange.SetDateTimeFrontier(frontier);
//Update the Holdings Copy of Price Variable:
Holdings.UpdatePrice(Close);
//Add new point to cache:
if (data != null)
{
Cache.AddData(data);
}
//Update Online Calculations:
}
/// <summary>
/// Ovveriding Equality method results in getting invalid hash code which is necessary for
/// hashtables and dictionary pairs as they use hashcode to retrieve small set in dictionary
/// and then compare them with equals method.If it is not overriden, then the dictionaries will behave improperly while adding
/// new dictionary or retrieving saved ones.Hence,GetHashCode should be overriden while overriding Equality method.
/// </summary>
/// <returns>int;hashcode</returns>
public override int GetHashCode()
{
//Allowing system to not check the overflow conditions as we are fine with having overflow but to wrap
//reference:https://stackoverflow.com/questions/263400/what-is-the-best-algorithm-for-an-overridden-system-object-gethashcode
unchecked
{
// Choose large primes to avoid hashing collisions
int hash = 17;
//Use XOR instead of addition for improved performance
//checking for null object references
hash = (hash * 23) ^ (!Object.ReferenceEquals(null, Symbol) ? Symbol.GetHashCode() : 0);
hash = (hash * 23) ^ (!Object.ReferenceEquals(null, Name) ? Name.GetHashCode() : 0);
hash = (hash * 23) ^ (!Object.ReferenceEquals(null, Holdings) ? Holdings.GetHashCode() : 0);
hash = (hash * 23) ^ (!Object.ReferenceEquals(null, CurrentPrice) ? CurrentPrice.GetHashCode() : 0);
return(hash);
}
}
public async Task <ulong> AddHolding(IDbConnection connection, Holdings holdings)
{
var serializedHoldingDetails = JsonSerializer.Serialize(holdings.HoldingDetails);
var parameters = new DynamicParameters();
parameters.Add("userId", holdings.UserId);
parameters.Add("stockId", holdings.StockId);
parameters.Add("holdingDetails", serializedHoldingDetails);
connection.Open();
var holdingId = await connection.QueryFirstAsync <ulong>(_insHolding, parameters);
connection.Close();
return(holdingId);
}
public static Holdings InsertHolding(int accountID, int exchangeID, string Symbol, decimal Quantity, decimal price)
{
Holdings holding = new Holdings();
holding.Accounts_AccountID = accountID;
holding.StockExchangeID = exchangeID;
holding.Quantity = Quantity;
holding.Quotes_Symbol = Symbol;
holding.PurchaseDate = DateTime.Now;
holding.PricePaid = price;
holding.Open = true;
//Add it to the DB
DB.Holdings.InsertOnSubmit(holding);
//Adjust the AccountBalances in Accounts
Accounts account = DB.GetTable <Accounts>().Where(acct => (acct.AccountID == accountID)).SingleOrDefault();
decimal?cashBalance = account.CashBalance;
account.CashBalance = cashBalance - (Quantity * price);
decimal?assetBalance = account.AssetBalance;
//need to use the Current Market price
decimal?currentPrice = GetPriceforSymbol(Symbol);
account.AssetBalance = assetBalance + (Quantity * currentPrice);
DB.SubmitChanges();
//Get the added one from DB
Holdings hold = (from h in DB.Holdings
where h == holding
select h).SingleOrDefault();
//Check it with the current object
if (hold == holding)
{
return(holding);
}
return(null);
}
private void UpdateUserHoldings(Holdings holding,
StockSplit splitDetails,
IEnumerable <ulong> purchaseIdsUpdated)
{
var ratio = splitDetails.NewStockRatio / splitDetails.OldStockRatio;
if (holding != null && purchaseIdsUpdated.Count() > 0)
{
var holdingDetails = holding.HoldingDetails;
foreach (var detail in holdingDetails)
{
if (purchaseIdsUpdated.Contains(detail.PurchaseId))
{
detail.Price = detail.Price / ratio;
detail.Quantity = detail.Quantity * ratio;
}
}
}
}
