public override bool Handle(TradeModel tradeModel)
{
try
{
if (!ShareExists(tradeModel.Symbol) || !UserExits(tradeModel.PortfolioId))
{
return(false);
}
var newTrade = new Trade
{
Action = "BUY",
NoOfShares = tradeModel.NoOfShares,
Price = GetSharePrice(tradeModel.Symbol),
PortfolioId = tradeModel.PortfolioId,
Symbol = tradeModel.Symbol
};
_tradeRepository.InsertAsync(newTrade);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
public async Task Post_ErrorActionTrade()
{
var tradeModel = new TradeModel
{
Symbol = "CBI",
Action = "ERR",
PortfolioId = 1,
NoOfShares = 5
};
// Arrange
// Act
try
{
var result = await _tradeController.Post(tradeModel);
Assert.Fail();
}
catch (HttpStatusCodeException ex)
{
// Assert
Assert.AreEqual(400, ex.StatusCode);
}
catch (Exception)
{
Assert.Fail();
}
}
public async Task Post_ErrorPortfolioNotExists()
{
var tradeModel = new TradeModel
{
Symbol = "CBI",
Action = "ERR",
PortfolioId = 1,
NoOfShares = 5
};
_portfolioRepositoryMock.Setup(p => p.Query()).Returns(new List <Portfolio> {
new Portfolio {
Id = 1000
}
}.AsQueryable());
// Arrange
// Act
try
{
var result = await _tradeController.Post(tradeModel);
Assert.Fail();
}
catch (HttpStatusCodeException ex)
{
// Assert
Assert.AreEqual(400, ex.StatusCode);
}
catch (Exception)
{
Assert.Fail();
}
}
public void HourlyShareRateValidateData()
{
var TradeModelNotValid = new TradeModel
{
Symbol = "REL",
NoOfShares = 10,
PortfolioId = 1,
Action = "OUT"
};
var context1 = new ValidationContext(TradeModelNotValid, null, null);
var results1 = new List <ValidationResult>();
var isModelStateNotValid = Validator.TryValidateObject(TradeModelNotValid, context1, results1, true);
var TradeModelValid = new TradeModel
{
Symbol = "REL",
NoOfShares = 10,
PortfolioId = 1,
Action = "BUY"
};
var context = new ValidationContext(TradeModelValid, null, null);
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(TradeModelValid, context, results, true);
// Assert
Assert.False(isModelStateNotValid);
Assert.True(isModelStateValid);
}
public string AddUpdate(TradeModel t)
{
int IntStatus = 0;
string strStatus = "";
if (t != null)
{
obj.IntClientID = t.IntClientID;
obj.StrDate = t.StrDate;
obj.FltCRDR = t.FltCRDR;
obj.IntMode = t.IntMode;
IntStatus = obj.AddUpdate();
if (IntStatus == 1)
{
strStatus = "Trade Added Successfully!";
}
if (IntStatus == 2)
{
strStatus = "Trade Updated Successfully!";
}
if (IntStatus == 3)
{
strStatus = "Trade Deleted Successfully!";
}
}
return(strStatus);
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
if (!ModelState.IsValid || model == null)
{
return(BadRequest(ModelState));
}
var latestShareInfo = await _shareRepository.GetLatestPrice(model.Symbol);
if (null == latestShareInfo)
{
return(BadRequest());
}
Trade trade = new Trade
{
NoOfShares = model.NoOfShares,
PortfolioId = model.PortfolioId,
Symbol = model.Symbol,
Action = model.Action,
Price = latestShareInfo.Rate
};
await _tradeRepository.InsertAsync(trade);
return(Created("Trade", trade));
}
//扫码支付
public override async Task <AlipayReponse> ExecuteAsync(TradeModel request, ServerCallContext context)
{
var model = new AlipayTradePrecreateModel
{
OutTradeNo = request.OutTradeNo,
Subject = request.Subject,
TotalAmount = request.TotalAmount,
Body = request.Body
};
var req = new AlipayTradePrecreateRequest();
req.SetBizModel(model);
req.SetNotifyUrl("http://domain.com/alipay/notify/precreate");
var response = await _client.ExecuteAsync(req, _optionsAccessor.Value);
return(new AlipayReponse
{
Message = response.Body,
Qrcode = response.QrCode
});
//return base.ExecuteAsync(request, context);
}
public IActionResult Post([FromBody]TradeModel model)
{
var handler = _tradeHandlerFactory.GetTradeHandler(model.Action);
if (handler.Handle(model))
return Created("Trade", model);
return BadRequest();
}
public async Task GetAllTradings_OK()
{
// Arrange
TradeModel value = new TradeModel()
{
NoOfShares = 2, PortfolioId = 1, Symbol = "WWW", Action = "SELL"
};
_tradeServiceMock.Setup(t => t.GetByPortfolioId(value.PortfolioId))
.Returns(Task.FromResult((IList <Trade>) new List <Trade>()
{
new Trade()
{
}
}));
// Act
var result = await _tradeController.GetAllTradings(value.PortfolioId);
// Assert
Assert.NotNull(result);
var okresult = result as OkObjectResult;
Assert.AreEqual(200, okresult.StatusCode);
}
public async Task Post_ShouldRetrunOK()
{
TradeModel model = new TradeModel
{
Action = "BUY",
NoOfShares = 50,
Symbol = "REL",
PortfolioId = 1
};
// Arrange
HourlyShareRate share = new HourlyShareRate()
{
Id = 1,
Rate = 90,
Symbol = "REL",
TimeStamp = DateTime.Now
};
// Arrange
_shareRepositoryMock.Setup(x => x.GetLatestPrice(It.IsAny <string>())).ReturnsAsync(share);
// Act
var result = await _tradeController.Post(model);
// Assert
Assert.NotNull(result);
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
}
public async Task <IActionResult> ExportExcel(TradeModel entity)
{
string filename = "SGXTrades_" + DateTime.Now.ToString("yyyy-MM-dd") + $".xlsx";
var list = await _tradeSevice.GetTrades(entity);
list.ForEach(x => { x.SecType = (x.SecType == "FUT" ? "Future" : "Option"); x.Side = (x.Side == "1" ? "Buy" : "Sell"); });
var columns = new Dictionary <string, string>()
{
{ "BizDate", "Clearing Date" },
{ "TradeDate", "Trade Date" },
{ "OrderID", "OrderID" },
{ "Exchange", "Exchange" },
{ "AccountNo", "AccountNo" },
{ "BizUnit", "BizUnit" },
{ "ProductCode", "ProductCode" },
{ "MMY", "MMY" },
{ "SecType", "Security Type" },
{ "PutCall", "PutCall" },
{ "StrikePx", "StrikePrice" },
{ "Side", "Side" },
{ "Qty", "Quantity" },
{ "TradePrice", "TradePrice" },
{ "Ccy", "Currency" }
};
var fs = ExcelHelper.GetByteToExportExcel(list, columns, new List <string>(), "Trades", "", 0);
return(File(fs, "application/vnd.android.package-archive", filename));
}
public async Task Buy_PortfolioNotExists()
{
Func <HourlyShareRate> func = () =>
{
return(new HourlyShareRate
{
Rate = 20.00M
});
};
TradeModel model = new TradeModel
{
Action = "BUY",
NoOfShares = 10,
PortfolioId = 1,
Symbol = "SIM"
};
// Arrange
_exchangeContext.Setup(p => p.Set <Trade>().Add(It.IsAny <Trade>()));
_exchangeContext.Setup(p => p.SaveChangesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(1);
// Act
Trade trade = await _tradeRepository.Buy(model, func);
// Assert
Assert.NotNull(trade);
Assert.AreEqual(trade.Symbol, model.Symbol);
Assert.AreEqual(trade.PortfolioId, model.PortfolioId);
Assert.AreEqual(trade.NoOfShares, model.NoOfShares);
Assert.AreEqual(trade.Price, 20.00M);
}
private async Task <IActionResult> Sell(TradeModel model, HourlyShareRate r, Portfolio pf)
{
IEnumerable <Trade> t = GetTrades(model.PortfolioId, model.Symbol);
var aShares = 0;
for (int i = 0; i < t.Count(); i++)
{
aShares += (t.ElementAt(i).Action.Equals("SELL", StringComparison.OrdinalIgnoreCase) ? -1 : 1) *
t.ElementAt(i).NoOfShares;
}
if (aShares < model.NoOfShares)
{
return(NotFound("not enough shares"));
}
var result = new Trade()
{
Price = model.NoOfShares * r.Rate,
NoOfShares = model.NoOfShares,
Action = "SELL",
PortfolioId = model.PortfolioId,
Symbol = model.Symbol
};
await _tradeRepository.InsertAsync(result);
return(Created("Trade", result));
}
public async Task Post()
{
// Arrange
var trade = new TradeModel
{
Symbol = "NAS",
NoOfShares = 10,
PortfolioId = 1,
Action = "BUY"
};
_tradeServiceMock
.Setup(mock => mock.BuyOrSell(1, "NAS", 10, "BUY"))
.Returns(Task.FromResult(new Trade {
}));
// Act
var result = await _tradeController.Post(trade);
// Assert
Assert.NotNull(result);
// TODO: This unit test is broken, the result received from the Post method is correct.
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HourlyShareRate r = null;
Portfolio pf = null;
Parallel.Invoke(
() => { r = GetLatestRate(model.Symbol); },
() => { pf = GetPortfolio(model.PortfolioId); });
if (r == null)
{
return(BadRequest("no symbol"));
}
if (pf == null)
{
return(BadRequest("no portfolio"));
}
if (model.Action.Equals("SELL", StringComparison.OrdinalIgnoreCase))
{
return(await Sell(model, r, pf));
}
else
{
return(await Buy(model, r, pf));
}
}
public static IEnumerable <HistoryResponseModel> ToResponseModel(this TradeModel trade)
{
yield return(new HistoryResponseModel
{
Id = trade.Id.ToString(),
DateTime = trade.Timestamp,
Type = HistoryType.Trade,
Asset = trade.BaseAssetId,
Amount = trade.BaseVolume,
AssetPair = trade.AssetPairId,
Price = trade.Price,
State = HistoryState.Finished,
FeeSize = trade.FeeSize > 0 && trade.FeeAssetId == trade.BaseAssetId ? trade.FeeSize.GetValueOrDefault(0) : 0,
FeeType = FeeType.Absolute
});
yield return(new HistoryResponseModel
{
Id = trade.Id.ToString(),
DateTime = trade.Timestamp,
Type = HistoryType.Trade,
Asset = trade.QuotingAssetId,
Amount = trade.QuotingVolume,
AssetPair = trade.AssetPairId,
Price = trade.Price,
State = HistoryState.Finished,
FeeSize = trade.FeeSize > 0 && trade.FeeAssetId == trade.QuotingAssetId ? trade.FeeSize.GetValueOrDefault(0) : 0,
FeeType = FeeType.Absolute
});
}
public IActionResult deletetrade(int id)
{
var model = new TradeModel();
model.Remove(id);
return(View("index"));
}
public async Task Post_SupplyCorrectModelValue_ShouldReturnSuccess()
{
var portfolioModel = new TradeModel
{
Symbol = "DGA",
NoOfShares = 2,
PortfolioId = 1,
Action = "Sell"
};
_tradeServiceMock
.Setup(e => e.BuyOrSell(portfolioModel.PortfolioId, portfolioModel.Symbol, portfolioModel.NoOfShares,
portfolioModel.Action)).Returns(Task.FromResult(new Trade
{
Symbol = "DGA",
NoOfShares = 1,
PortfolioId = 2,
Action = "Sell"
}));
var act = await _tradeController.Post(portfolioModel);
var result = act as CreatedResult;
Assert.IsNotNull(result);
Assert.That(result.Location, Is.EqualTo("Trade/2"));
Assert.That(result.StatusCode, Is.EqualTo(201));
}
public bool OpenPage(TradeModel model)
{
//TODO:权限检测
var page = PageFactory.CreatePage(model.Action);
if (page == null)
{
MessageBox.Show("未能正确加载交易:" + model.Code + "[" + model.Action + "]");
return(false);
}
//查找同一个交易的清单，移除需要稍后进行，否则会触发意外的AllPagesClosed事件
var removeList = pages.Where(x => (x.Tag as TradeModel) == model).ToList();
//若打开的交易数目太多，也移除一部分
if (pages.Count - removeList.Count > 9)
{
removeList.AddRange(pages.Take(pages.Count - removeList.Count - 10).ToList());
}
//载入页面交易
page.Tag = model;
pages.Add(page);
foreach (var item in removeList)
{
pages.Remove(item);
}
tab_Host.Items.Refresh();
tab_Host.SelectedIndex = tab_Host.Items.Count - 1;
return(true);
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
var rate = _tradeRepository.Query().Where(x => x.Symbol == model.Symbol)
.Select(x => x.Price).LastOrDefault();
var portfolio = _portfolioRepository.Query().Where(x => x.Id == model.PortfolioId).FirstOrDefault();
if (portfolio == null)
{
return(BadRequest());
}
var share = _shareRepository.Query().Where(x => x.Symbol == model.Symbol);
if (share == null)
{
return(BadRequest());
}
if (model.Action == "BUY")
{
var e = new Trade
{
Action = "BUY",
NoOfShares = model.NoOfShares,
PortfolioId = portfolio.Id,
Price = rate,
Symbol = model.Symbol
};
var result = _tradeRepository.InsertAsync(e);
}
else if (model.Action == "SELL")
{
var buyedShare = portfolio.Trade.Where(x => x.Symbol == model.Symbol && x.Action == "BUY")
.Sum(x => x.NoOfShares);
var sellShare = portfolio.Trade.Where(x => x.Symbol == model.Symbol && x.Action == "SELL")
.Sum(x => x.NoOfShares);
var remainShare = buyedShare - sellShare;
if (remainShare >= model.NoOfShares)
{
var e = new Trade
{
Action = "SELL",
NoOfShares = model.NoOfShares,
PortfolioId = portfolio.Id,
Price = rate,
Symbol = model.Symbol
};
var result = _tradeRepository.InsertAsync(e);
}
}
return(Created("Trade", model));
}
public async Task Sell_ReturnTradeCreated()
{
IQueryable <Trade> trades = new List <Trade>
{
new Trade
{
Action = "BUY",
NoOfShares = 10,
PortfolioId = 1,
Symbol = "SIM",
Price = 10.00M
},
new Trade
{
Action = "SELL",
NoOfShares = 3,
PortfolioId = 1,
Symbol = "SIM",
Price = 12.00M
}
}.AsQueryable();
Func <HourlyShareRate> func = () =>
{
return(new HourlyShareRate
{
Rate = 20.00M
});
};
TradeModel model = new TradeModel
{
Action = "SELL",
NoOfShares = 4,
PortfolioId = 1,
Symbol = "SIM"
};
// Arrange
_exchangeContext.Setup(p => p.Set <Trade>().Add(It.IsAny <Trade>()));
_exchangeContext.Setup(p => p.SaveChangesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(1);
_dbSetTrade.As <IQueryable <Trade> >().Setup(m => m.Provider).Returns(trades.Provider);
_dbSetTrade.As <IQueryable <Trade> >().Setup(m => m.Expression).Returns(trades.Expression);
_dbSetTrade.As <IQueryable <Trade> >().Setup(m => m.ElementType).Returns(trades.ElementType);
_dbSetTrade.As <IQueryable <Trade> >().Setup(m => m.GetEnumerator()).Returns(trades.GetEnumerator());
_exchangeContext.Setup(p => p.Trades).Returns(_dbSetTrade.Object);
// Act
Trade trade = await _tradeRepository.Sell(model, func);
// Assert
Assert.NotNull(trade);
Assert.AreEqual(trade.Symbol, model.Symbol);
Assert.AreEqual(trade.PortfolioId, model.PortfolioId);
Assert.AreEqual(trade.NoOfShares, model.NoOfShares);
Assert.AreEqual(trade.Price, 20.00M);
}
public TestTradesView()
{
InitializeComponent();
model = new TradeModel();
viewModel = new TradeViewModel(model);
grdTest.ItemsSource = new [] { viewModel };
}
public IActionResult SaveTrade([FromBody] TradeModel trade)
{
if (TradeRepo.SaveTrade(trade) != null)
{
return(Ok(trade));
}
return(StatusCode(500));
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var portfolio = _portfolioRepository.Query().Where(x => x.Id == model.PortfolioId).ToList();
if (portfolio == null || portfolio.Count == 0)
{
return(BadRequest(ModelState));
}
var latestPrice = _shareRepository.Query().Where(x => x.Symbol.Equals(model.Symbol)).OrderByDescending(x => x.TimeStamp).FirstOrDefault();
if (latestPrice == null)
{
return(BadRequest(ModelState));
}
Trade tradeObj = null;
if (model.Action == "BUY")
{
tradeObj = new Trade();
tradeObj.PortfolioId = model.PortfolioId;
tradeObj.Symbol = model.Symbol;
tradeObj.NoOfShares = model.NoOfShares;
tradeObj.Action = model.Action;
tradeObj.Price = model.NoOfShares * latestPrice.Rate;
}
if (model.Action == "SELL")
{
var shareDetails = _tradeRepository.Query().Where(x => x.PortfolioId == model.PortfolioId && x.Symbol == model.Symbol).ToList();
if (shareDetails == null || shareDetails.Count == 0)
{
return(BadRequest(ModelState));
}
var totalBought = shareDetails.Where(x => x.Action == "BUY").Sum(x => x.NoOfShares);
var totalSold = shareDetails.Where(x => x.Action == "SELL").Sum(x => x.NoOfShares);
if (totalBought - totalSold >= model.NoOfShares)
{
tradeObj = new Trade();
tradeObj.PortfolioId = model.PortfolioId;
tradeObj.Symbol = model.Symbol;
tradeObj.NoOfShares = model.NoOfShares;
tradeObj.Action = model.Action;
tradeObj.Price = model.NoOfShares * latestPrice.Rate;
}
else
{
return(BadRequest(ModelState));
}
}
await _tradeRepository.InsertAsync(tradeObj);
return(Created("Trade", tradeObj));
}
/// <summary>
///
/// </summary>
/// <param name="MaxAmount">Граница товара</param>
/// <param name="BuyPrice">Цена покупки товара</param>
/// <param name="AlowBuy">Разрешить покупку</param>
/// <param name="SalePrice">Цена продажи товара</param>
/// <param name="AlowSale">Разрешить продажу</param>
/// <param name="storeMode">Режим торговли данным предметом</param>
public MyItem(int MaxAmount = 0, int BuyPrice = 1, bool AlowBuy = false, int SalePrice = 2, bool AlowSale = false, TradeModel storeMode = TradeModel.Storage)
{
this.MaxAmount = MaxAmount;
this.BuyPrice = BuyPrice;
this.SalePrice = SalePrice;
this.AlowBuy = AlowBuy;
this.AlowSale = AlowSale;
Mode = storeMode;
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
try
{
if (ModelState.IsValid)
{
var isExists = _portfolioRepository.IsExists(model.PortfolioId);
if (!isExists)
{
return(BadRequest());
}
switch (model.Action)
{
case "BUY":
if (IsSymbolExists(model.Symbol))
{
var buyShare = await _shareRepository.Query().Where(x => x.Symbol.Equals(model.Symbol)).OrderByDescending(x => x.TimeStamp).FirstOrDefaultAsync();
await _tradeRepository.InsertAsync(MapToDb(model, buyShare));
}
else
{
return(BadRequest());
}
break;
case "SELL":
var sellShare = await _shareRepository.Query().Where(x => x.Symbol.Equals(model.Symbol)).OrderByDescending(x => x.TimeStamp).FirstOrDefaultAsync();
var availableForSell = GetAvailableShareToSell(model);
if (availableForSell < model.NoOfShares)
{
return(BadRequest());
}
else
{
var sellDetail = MapToDb(model, sellShare);
await _tradeRepository.InsertAsync(sellDetail);
}
break;
default:
return(BadRequest());
break;
}
}
return(Created("Trade", model));
}
catch (Exception ex)
{
throw;
}
}
// POST: api/Trade
public IHttpActionResult PostTrade([FromBody] TradeModel tradeModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_service.Add(tradeModel);
return(Ok(tradeModel));
}
// GET: api/Trade/5
public IHttpActionResult GetTrade(int id)
{
TradeModel tradeModel = _service.GetById(id);
if (tradeModel == null)
{
return(NotFound());
}
return(Ok(tradeModel));
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _tradeService.BuyOrSell(model.PortfolioId, model.Symbol, model.NoOfShares, model.Action);
return(Created($"Trade/{result.PortfolioId}", Map(result)));
}
private Trade MapToDb(TradeModel model, HourlyShareRate shareDetail)
{
var trade = new Trade();
trade.PortfolioId = model.PortfolioId;
trade.Symbol = model.Symbol;
trade.NoOfShares = model.NoOfShares;
trade.Price = model.NoOfShares * shareDetail.Rate;
trade.Action = model.Action;
return(trade);
}
