public static List <StockValue> Read(string path, CsvFormat fmt)
{
var lines = File.ReadAllLines(path);
var result = new List <StockValue>();
int startlineCount = fmt.ContainsHeader ? 1 : 0;
for (int i = startlineCount; i < lines.Length; i++)
{
string[] cuts = lines[i].Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (cuts.Length == 0)
{
throw new FormatException("Check csv files format.");
}
var value = new StockValue(
symbol: path,
dateTime: DateTime.ParseExact(cuts[fmt.DateTimeIndex], fmt.DateTimeFormat, CultureInfo.InvariantCulture),
price: decimal.Parse(cuts[fmt.PriceIndex], CultureInfo.InvariantCulture),
volume: 1);
result.Add(value);
}
return(result);
}
public bool TryGetStocks(int page, StockValue searchParameter, out StockData data)
{
try
{
var query = GetQuery(page, searchParameter);
var url = $"https://jsonmock.hackerrank.com/api/stocks/search/?{query}";
var json = _client.GetStringAsync(url).Result; //make it synchronious
data = JsonConvert.DeserializeObject <StockData>(json.Replace("_", ""));
return(data.Data.Length > 0);
}
catch
{
data = new StockData
{
Data = new StockValue[0],
Page = 1,
PerPage = 0,
Total = 0,
TotalPages = 0
};
return(false);
}
}
public StatusMessage InsertStockValue(StockValue data)
{
StatusMessage result = new StatusMessage();
if (_stockContext != null)
{
try
{
if (!_stockContext.Stocks.Any(x => x.Code.Equals(data.Code, StringComparison.InvariantCultureIgnoreCase)))
{
_stockContext.Stocks.Add(data);
_stockContext.SaveChanges();
result = new StatusMessage(MSG_TYPE.SUCCESS, "Datos insertados correctamente");
}
}
catch (Exception error)
{
LoggerHelper.LogException(true, error);
result = GetErrorMessage(error);
}
}
return(result);
}
public async Task <Response <IEnumerable <StockValue> > > GetStockDataAsync(string ids)
{
var fnResult = new Response <IEnumerable <StockValue> >
{
StatusCode = (int)HttpStatusCode.BadRequest
};
try
{
var stockTickers = ids.Split(",");
var uri = _yahooFinanceApiSettings.BaseClient + string.Format(_yahooFinanceApiSettings.GetQuotesUri, ids);
var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, uri));
if (response.StatusCode != HttpStatusCode.OK)
{
return(fnResult);
}
var content = await response.Content.ReadAsStringAsync();
var stockProfiles = new List <StockValue>();
var requestBody = JObject.Parse(content);
var count = 0;
foreach (var stock in stockTickers)
{
if (stock != "")
{
if (requestBody.SelectToken($"quoteResponse.result[{count}].regularMarketPrice") != null)
{
var stockProfile = new StockValue
{
CurrentPrice = (double)requestBody.SelectToken($"quoteResponse.result[{count}].regularMarketPrice"),
Name = stock
};
stockProfiles.Add(stockProfile);
}
count++;
}
}
fnResult.Data = stockProfiles;
fnResult.StatusCode = (int)HttpStatusCode.OK;
return(fnResult);
}
catch (Exception e)
{
fnResult.StatusCode = (int)HttpStatusCode.InternalServerError;
fnResult.Message = e.Message;
return(fnResult);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
if (cmbFilter.SelectedItem == null)
{
return;
}
SelectedStockValue = cmbFilter.SelectedItem as StockValue;
DialogResult = DialogResult.OK;
Close();
}
private StockValue GetStockForCodeAndValue(string stockCode, int unit, decimal price)
{
StockValue stockValue = _db.StockValue
.AsNoTracking()
.Where(
x => x.Unit == unit &&
x.Price == price &&
x.Stock.Code.ToLower().Equals(stockCode.ToLower()))
.OrderByDescending(x => x.PublicationDate)
.FirstOrDefault();
return(stockValue);
}
public bool AddStockValueIfNewer(int stockId, int unit, decimal price, DateTime publicationDate)
{
bool saveResult = false;
StockValue latestValueForStock = GetLatestValueForStock(stockId);
if (latestValueForStock == null)
{
return(saveResult);
}
// compare d1 to d2
// d1 - publication date of the latest stock value for specified stock in Database
// d2 - publication date of specified stock fetched from external server
int dateComparisonResult = DateTime.Compare(latestValueForStock.PublicationDate, publicationDate);
// Less than zero => d1 is earlier than d2.
// Zero => d1 is the same as d2.
// Greater than zero => d1 is later than d2.
if (dateComparisonResult >= 0)
{
return(saveResult);
}
//_logger.Info("Date comparison result: " + dateComparisonResult + ", latest in db: "
// + latestValueForStock.PublicationDate + ", current: " + publicationDate);
try
{
var newStockValue = new StockValue
{
StockID = stockId,
Unit = unit,
Price = price,
PublicationDate = publicationDate
};
_db.StockValue.Add(newStockValue);
//_db.Entry(newStockValue).State = System.Data.Entity.EntityState.Added;
saveResult = _db.SaveChanges() > 0;
}
catch (Exception e)
{
_logger.Error("Exception during adding new stock VALUE: " + e.Message);
if (e.InnerException != null)
{
_logger.Error(e.InnerException.Message);
}
}
return(saveResult);
}
public StockValue GetStockValueByCode(string stockCode)
{
StockValue result = null;
try
{
result = _stockContext.Stocks.FirstOrDefault(x => x.Code.Equals(stockCode, StringComparison.InvariantCultureIgnoreCase));
}
catch (Exception error)
{
LoggerHelper.LogException(true, error);
}
return(result);
}
private void DrawStockCard(SKCanvas canvas)
{
var firstRect = MainGraphics !.GetActualRectangle(3, 10, 70, 20);
var secondRect = MainGraphics.GetActualRectangle(3, 31, 70, 20);
var thirdRect = MainGraphics.GetActualRectangle(3, 51, 70, 20);
var fourthRect = MainGraphics.GetActualRectangle(3, 76, 70, 20);
var fontSize = firstRect.Height * 0.75f; // trial and error
var otherSize = firstRect.Height * 1.2f;
var otherText = MiscHelpers.GetTextPaint(SKColors.Purple, otherSize);
var blackText = MiscHelpers.GetTextPaint(SKColors.Black, fontSize);
blackText.FakeBoldText = true;
otherText.FakeBoldText = true;
canvas.DrawCustomText(StockValue.ToString(), TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, otherText, firstRect, out _);
canvas.DrawCustomText("Stock", TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, blackText, secondRect, out _);
canvas.DrawCustomText("Certificate", TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, blackText, thirdRect, out _);
canvas.DrawCustomText("$50,000", TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, blackText, fourthRect, out _); // its okay to do manually
}
public StockValue GetLatestValueForStock(int stockId)
{
StockValue latestStockValue = null;
try
{
latestStockValue = _db.StockValue
.AsNoTracking()
.Where(x => x.StockID == stockId)
.OrderByDescending(x => x.PublicationDate)
.Take(1)
.FirstOrDefault();
}
catch (Exception e)
{
_logger.Error("Exception during fetching latest value for stock: " + e.Message);
}
return(latestStockValue);
}
private string GetQuery(int page, StockValue data)
{
var query = "";
if (page >= 1)
{
query += ("page=" + page);
}
if (data != null)
{
if (data.Close != null)
{
query += ((query.Length > 0 ? "&" : "") + "close=" + data.Close);
}
if (data.Open != null)
{
query += ((query.Length > 0 ? "&" : "") + "open=" + data.Open);
}
if (data.High != null)
{
query += ((query.Length > 0 ? "&" : "") + "high=" + data.High);
}
if (data.Low != null)
{
query += ((query.Length > 0 ? "&" : "") + "low=" + data.Low);
}
if (data.Date != null)
{
query += ((query.Length > 0 ? "&" : "") + "date=" + Helper.ToStockDate(data.Date));
}
}
return(query.ToString());
}
public StocksManager(IDependenciesManager _dependencies)
{
stocksValues = new List <StockValue>();
Task.Run(() =>
{
using (var client = new WebsocketClient(new Uri(_dependencies.stocksendpoint)))
{
client.ReconnectTimeout = TimeSpan.FromSeconds(30);
//client.ReconnectionHappened.Subscribe(info =>
// Log.Information($"Reconnection happened, type: {info.Type}"));
client.MessageReceived.Subscribe(msg =>
{
try
{
var value = JsonConvert.DeserializeObject <Dictionary <string, double> >(msg.ToString());
StockValue stock = stocksValues.FirstOrDefault(s => s.StockCode.Equals(value.Keys.ElementAt(0))) ?? new StockValue {
StockCode = value.Keys.ElementAt(0)
};
if (stock.Timestamp < value["timestamp"])
{
stock.Value = value[stock.StockCode];
stock.Timestamp = value["timestamp"];
if (!stocksValues.Any(s => s.StockCode.Equals(value.Keys.ElementAt(0))))
{
stocksValues.Add(stock);
}
}
}
catch (Exception ex)
{
throw ex;
}
});
client.Start();
new ManualResetEvent(false).WaitOne();
}
});
}
private bool Equals(StockValue other)
{
return(Stock.Equals(other.Stock) && Price.Equals(other.Price) && StockTotalPrice.Equals(other.StockTotalPrice) && StockGain.Equals(other.StockGain));
}
public static StockValueDTO FromModel(StockValue m)
{
return(new StockValueDTO(m.Id, m.StockId, m.ValueTypeId, m.Value));
}
public static StockValue ToModel(StockValueDTO d)
{
return(StockValue.New(d.Id, d.StockId, d.ValueTypeId, d.Value));
}
public StockBuyStatus BuyStock(string userId, BuyStockViewModel buyStockModel)
{
// check if user change the form data, provided stock value has to exists in database
StockValue purchasingStockValue = GetStockForCodeAndValue(buyStockModel.Code, buyStockModel.Unit, buyStockModel.Price);
if (purchasingStockValue == null)
{
return(StockBuyStatus.Unknown);
}
decimal totalCost = buyStockModel.AmountToBuy / purchasingStockValue.Unit * purchasingStockValue.Price;
// case 1: User does not have enough money
User buyer = _db.UserApp.Where(x => x.Id.Equals(userId) && x.Money >= totalCost)
.FirstOrDefault();
if (buyer == null)
{
return(StockBuyStatus.UserHasNotEnoughMoney);
}
// case 2: Stock Exchange does not have enough stock
if (purchasingStockValue.Stock.AvailableAmount < buyStockModel.AmountToBuy)
{
return(StockBuyStatus.AmountNotAvailable);
}
// case 3: Stock value data have changed - there was an update
StockDetails latestStockDetails = GetLatestStockDetails(buyStockModel.Code);
bool isBuyerBuyingStockByLatestPrice = AreDatesTheSameComparisonLikeHuman(
latestStockDetails.PublicationDate, purchasingStockValue.PublicationDate);
if (isBuyerBuyingStockByLatestPrice == false)
{
return(StockBuyStatus.StockValueDataHaveChanged);
}
using (var dbContextTransaction = _db.Database.BeginTransaction())
{
try
{
// then 1: Subtract money from User wallet
buyer.Money -= totalCost;
// then 2: Add specified amount of stock to UserStocks
UserStocks stockOwnedByBuyer = buyer.Stocks.FirstOrDefault(
x => x.StockID == purchasingStockValue.StockID);
if (stockOwnedByBuyer != null)
{
stockOwnedByBuyer.Amount += buyStockModel.AmountToBuy;
_db.Entry(stockOwnedByBuyer).State = System.Data.Entity.EntityState.Modified;
}
else
{
stockOwnedByBuyer = new UserStocks
{
UserID = userId,
StockID = purchasingStockValue.StockID,
Amount = buyStockModel.AmountToBuy
};
_db.UserStocks.Add(stockOwnedByBuyer);
}
// then 3: Decrease available stock amount
_db.Stock.Attach(purchasingStockValue.Stock);
_db.Entry(purchasingStockValue.Stock).Reload();
if (purchasingStockValue.Stock.AvailableAmount < buyStockModel.AmountToBuy)
{
_logger.Info("Rollback");
dbContextTransaction.Rollback();
return(StockBuyStatus.AmountNotAvailable);
}
purchasingStockValue.Stock.AvailableAmount -= buyStockModel.AmountToBuy;
_db.Entry(purchasingStockValue.Stock).State = System.Data.Entity.EntityState.Modified;
// save and commit
_db.SaveChanges();
dbContextTransaction.Commit();
return(StockBuyStatus.Success); // everything went well, so finally success
}
catch (Exception e)
{
_logger.Error("Transaction error during buying stock. Error:" + e.Message);
_logger.Error("Rollback...");
dbContextTransaction.Rollback();
}
}
return(StockBuyStatus.Unknown);
}
private void ProcessStockValue(StockValue stock)
{
}
public StockValue UpdateStockValue(StockValue stockValue)
{
return(_stockValues.Update(stockValue));
}
public StockValue AddStockValue(StockValue stockValue)
{
return(_stockValues.Add(stockValue));
}
public async Task <StockSymbol> UpdateStockSymbolDataAsync(StockSymbol Symbol)
{
//String baseUrl = null;
String apiKey = null;
try
{
//baseUrl = _config.Configuration["AlphavantageBaseUrl"];
apiKey = _config.Configuration["AlphavantageApiKey"];
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
if (String.IsNullOrWhiteSpace(apiKey))
{
throw new Exception("AlphavantageApiKey null or empty!");
}
AlphaVantageCoreClient client = new AlphaVantageCoreClient();
Dictionary <string, string> query = new Dictionary <string, string>()
{
{ "symbol", Symbol.Symbol },
{ "interval", "5min" },
{ "outputsize", "full" }
};
JObject result = await client.RequestApiAsync(apiKey, ApiFunction.TIME_SERIES_INTRADAY, query);
DateTime lastRefresh = Symbol.LastRefresh ?? DateTime.MinValue;
string timeZoneString = (string)result["Meta Data"]["6. Time Zone"];
//TODO: Move elsewhere
if ("US/Eastern".Equals(timeZoneString))
{
timeZoneString = "US Eastern Standard Time";
}
TimeZoneInfo timeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneString);
Symbol.Values = new List <StockValue>();
List <Task> waitingTasks = new List <Task>();
foreach (JObject timeSerie in result["Time Series (5min)"].Values())
{
JProperty prop = (JProperty)timeSerie.Parent;
String timestampProp = prop.Name;
DateTime localTimeStamp = DateTime.ParseExact(timestampProp, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
DateTime utcTimeStamp = TimeZoneInfo.ConvertTimeToUtc(localTimeStamp, timeZone);
if (utcTimeStamp < lastRefresh)
{
continue;
}
StockValue value = new StockValue()
{
TimeStamp = utcTimeStamp,
Open = Decimal.Parse(timeSerie.Value <string>("1. open")),
High = Decimal.Parse(timeSerie.Value <string>("2. high")),
Low = Decimal.Parse(timeSerie.Value <string>("3. low")),
Close = Decimal.Parse(timeSerie.Value <string>("4. close")),
Volume = Decimal.Parse(timeSerie.Value <string>("5. volume")),
ParentId = Symbol.Id
};
Symbol.Values.Add(value);
waitingTasks.Add(_repository.AddStockSymbolDataAsync(value));
if (waitingTasks.Count > 4)
{
int i = Task.WaitAny(waitingTasks.ToArray());
waitingTasks.RemoveAt(i);
}
}
Task.WaitAll(waitingTasks.ToArray());
waitingTasks.Clear();
DateTime localRefresh = DateTime.ParseExact((string)result["Meta Data"]["3. Last Refreshed"], "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
Symbol.LastRefresh = TimeZoneInfo.ConvertTimeToUtc(localRefresh, timeZone);
return(Symbol);
}
public StockSellStatus SellStock(string userId, SellStockViewModel sellStockModel)
{
// check if user change the form data, provided stock value has to exists in database
StockValue sellingStockValue = GetStockForCodeAndValue(
sellStockModel.Code, sellStockModel.Unit, sellStockModel.Price);
if (sellingStockValue == null)
{
return(StockSellStatus.Unknown);
}
decimal totalCost = sellStockModel.AmountToSell / sellingStockValue.Unit * sellingStockValue.Price;
// case 1: User does not have enough stock
User seller = _db.UserApp.Where(x => x.Id.Equals(userId)).FirstOrDefault();
UserStocks stockOwnedBySeller = seller.Stocks
.Where(x => x.StockID == sellingStockValue.StockID)
.FirstOrDefault();
if (stockOwnedBySeller == null || stockOwnedBySeller.Amount < sellStockModel.AmountToSell)
{
return(StockSellStatus.UserHasNotEnoughStocks);
}
// case 2: Stock value data have changed - there was an update
StockDetails latestStockDetails = GetLatestStockDetails(sellStockModel.Code);
bool isSellerSellingStockByLatestPrice = AreDatesTheSameComparisonLikeHuman(
latestStockDetails.PublicationDate, sellingStockValue.PublicationDate);
if (isSellerSellingStockByLatestPrice == false)
{
return(StockSellStatus.StockValueDataHaveChanged);
}
using (var dbContextTransaction = _db.Database.BeginTransaction())
{
try
{
// then 1: Add money to User wallet
seller.Money += totalCost;
// then 2: Subtract specified amount of stock from UserStocks
stockOwnedBySeller.Amount -= sellStockModel.AmountToSell;
if (stockOwnedBySeller.Amount == 0)
{
_db.UserStocks.Remove(stockOwnedBySeller);
}
//then 3: Increase available stock amount
_db.Stock.Attach(sellingStockValue.Stock);
_db.Entry(sellingStockValue.Stock).Reload();
sellingStockValue.Stock.AvailableAmount += sellStockModel.AmountToSell;
_db.Entry(sellingStockValue.Stock).State = System.Data.Entity.EntityState.Modified;
// save and commit
_db.SaveChanges();
dbContextTransaction.Commit();
return(StockSellStatus.Success); // everything went well, so finally success
}
catch (Exception e)
{
_logger.Error("Transaction error during selling stock. Error " + e.Message);
_logger.Error("Rollback...");
dbContextTransaction.Rollback();
}
}
return(StockSellStatus.Unknown);
}
public Task AddStockSymbolDataAsync(StockValue DataPoint)
{
IMongoCollection <StockValue> collection = _database.GetCollection <StockValue>(_stockDataCollectionName);
return(collection.InsertOneAsync(DataPoint));
}
