public void Save(SellOrder order)
{
var dbOrder = _dbContext.SellOrders.FirstOrDefault(o => o.Id == order.Id);
if (dbOrder != null)
{
dbOrder.Qty = order.Qty;
}
else
{
_dbContext.SellOrders.Add(order);
}
_dbContext.SaveChanges();
}
private SellRecord SaveOrderToDatabase(SellOrder order)
{
var sellRecord = new SellRecord
{
SellerId = order.SellerId,
Price = order.Price,
Quantity = order.Quantity,
TickerSymbol = order.TickerSymbol
};
_context.SellRecords.Add(sellRecord);
_context.SaveChanges();
return(sellRecord);
}
public SellOrders(SellOrder order)
{
if (order == null)
{
Reset();
}
else
{
Id = order.Id;
SellDate = order.SellDate;
SellPrice = order.SellPrice;
NumbersToSell = order.NumbersToSell;
SellComment = order.SellComment;
}
}
public void Insert()
{
var sellOrder = new SellOrder
{
SellComment = SellComment,
SellDate = SellDate,
SellPrice = SellPrice,
NumbersToSell = NumbersToSell
};
Repository?.SellOrders?.InsertOnSubmit(sellOrder);
Repository?.SellOrders?.Context?.SubmitChanges();
Id = sellOrder.Id;
}
/// <summary>
/// Imports an enumeration of API objects.
/// </summary>
/// <param name="src"></param>
/// <param name="endedOrders"></param>
/// <returns>The list of expired orders.</returns>
internal void Import(IEnumerable <SerializableOrderListItem> src, List <MarketOrder> endedOrders)
{
// Mark all orders for deletion
// If they are found again on the API feed, they won't be deleted
// and those set as ignored will be left as ignored
foreach (MarketOrder order in Items)
{
order.MarkedForDeletion = true;
}
// Import the orders from the API
List <MarketOrder> newOrders = new List <MarketOrder>();
foreach (SerializableOrderListItem srcOrder in src.Select(
srcOrder => new
{
srcOrder,
limit = srcOrder.Issued.AddDays(srcOrder.Duration + MarketOrder.MaxExpirationDays)
}).Where(order => order.limit >= DateTime.UtcNow).Where(
order => !Items.Any(x => x.TryImport(order.srcOrder, endedOrders))).Select(
order => order.srcOrder))
{
// It's a new order, let's add it
if (srcOrder.IsBuyOrder != 0)
{
BuyOrder order = new BuyOrder(srcOrder);
if (order.Item != null)
{
newOrders.Add(order);
}
}
else
{
SellOrder order = new SellOrder(srcOrder);
if (order.Item != null)
{
newOrders.Add(order);
}
}
}
// Add the items that are no longer marked for deletion
newOrders.AddRange(Items.Where(x => !x.MarkedForDeletion));
// Replace the old list with the new one
Items.Clear();
Items.AddRange(newOrders);
}
/// <summary>
/// Imports an enumeration of API objects.
/// </summary>
/// <param name="src">The orders to import.</param>
/// <param name="issuedFor">Whether the orders were issued for a character or
/// corporation.</param>
/// <param name="ended">The location to place ended orders.</param>
/// <returns>The list of expired orders.</returns>
internal void Import(IEnumerable <EsiOrderListItem> src, IssuedFor issuedFor,
ICollection <MarketOrder> ended)
{
var now = DateTime.UtcNow;
// Mark all orders for deletion
// If they are found again on the API feed, they will not be deleted and those set
// as ignored will be left as ignored
foreach (var order in Items)
{
order.MarkedForDeletion = true;
}
var newOrders = new LinkedList <MarketOrder>();
foreach (var srcOrder in src)
{
var limit = srcOrder.Issued.AddDays(srcOrder.Duration + MarketOrder.
MaxExpirationDays);
var orderFor = AdjustIssuer(issuedFor, srcOrder);
if (limit >= now && orderFor != IssuedFor.None && !Items.Any(x => x.TryImport(
srcOrder, orderFor, ended)))
{
// New order
if (srcOrder.IsBuyOrder)
{
var order = new BuyOrder(srcOrder, orderFor, m_character);
if (order.Item != null)
{
newOrders.AddLast(order);
}
}
else
{
var order = new SellOrder(srcOrder, orderFor, m_character);
if (order.Item != null)
{
newOrders.AddLast(order);
}
}
}
}
// Add the items that are no longer marked for deletion
newOrders.AddRange(Items.Where(x => !x.MarkedForDeletion));
Items.Clear();
Items.AddRange(newOrders);
}
public string SendSellOrder(SellOrder sellOrder)
{
if (_sellOrder.IsSellOrderExists(sellOrder))
{
sellOrder.Id = _sellOrder.GetOrderId(sellOrder);
if (_sellOrder.UpdateSendSellOrder(sellOrder) > 0)
{
return("Sell Order Successfully Updated.");
}
}
if (_sellOrder.SendSellOrder(sellOrder) > 0)
{
return("Sell Order Send Successfully.");
}
return("Sell Order Sending Faild.");
}
public string SendSellOrder(SellOrder sellOrder)
{
if (_sellOrder.IsSellOrderExists(sellOrder))
{
sellOrder.Id = _sellOrder.GetOrderId(sellOrder);
if (_sellOrder.UpdateSendSellOrder(sellOrder) > 0)
{
return("Sell Order Updated!");
}
}
if (_sellOrder.SendSellOrder(sellOrder) > 0)
{
return("Sell Order Send!");
}
return("Order Sending Faild");
}
public async Task LogSellOrderToDB(SellOrder order)
{
try
{
await CreateDatabaseAsync();
await CreateContainerAsync();
await AddSellOrderToDbAsync(order);
}
catch (CosmosException ce)
{
// Log Error
}
catch (Exception e)
{
// Log Error
}
}
public async Task <bool> IsValidOwnershipAsync(SellOrder order)
{
var request = await Client.GetAsync("checkOwnership?" +
$"tickerSymbol={order.TickerSymbol}&" +
$"sellerId={order.SellerId}&" +
$"quantity={order.Quantity}");
var content = await request.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <RegistryResponseDto>(content);
if (response.Owner.ToLower().Contains("t"))
{
return(true);
}
return(false);
}
public async Task <HttpResponseMessage> PostSellOrder(SellOrder sellorder)
{
if (ModelState.IsValid)
{
sellorder.CreatedAt = DateTime.Now;
await repository.SaveSellOrderAsync(sellorder);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, sellorder);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = sellorder.SellOrderID }));
await CompletedOrderAdded();
return(response);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public static List <SellOrder> GetSellingOrders(string username)
{
List <SellOrder> orders = new List <SellOrder>();
int id = GetUserId(username);
if (id == 0)
{
return(orders);
}
using (SqlConnection connection = GetConnection())
{
string commandString;
commandString = string.Format("SELECT id, quantity, timestamp, suspension FROM \"SellOrder\" WHERE user_id = '{0}'", id);
using (var command = new SqlCommand(commandString, connection))
{
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
int orderId = int.Parse(reader["id"].ToString());
int quantity = int.Parse(reader["quantity"].ToString());
DateTime timestamp = Convert.ToDateTime(reader["timestamp"].ToString());
DateTime suspension = new DateTime();
try
{
suspension = Convert.ToDateTime(reader["suspension"].ToString());
}
catch (Exception e)
{
}
SellOrder sellOrder = new SellOrder(orderId, quantity, timestamp, suspension);
orders.Add(sellOrder);
}
}
}
}
return(orders);
}
void Start()
{
SetPriceText();
SetAmountText();
SetLoanFundsText();
Hour = 0;
Day = 1;
buyOrder = GameObject.FindObjectOfType(typeof(BuyOrder)) as BuyOrder; //Funciona!!!!! Sirve para poder llamar funciones de otros scripts
sellOrder = GameObject.FindObjectOfType(typeof(SellOrder)) as SellOrder;
loanController = GameObject.FindObjectOfType(typeof(LoanController)) as LoanController;
shareHolder = GameObject.FindObjectOfType(typeof(ShareHolder)) as ShareHolder;
lastTradesList = GameObject.FindObjectOfType(typeof(LastTradesList)) as LastTradesList;
matchEngine = GameObject.FindObjectOfType(typeof(MatchEngine)) as MatchEngine;
InvokeRepeating("DistributeBalance", 1, 1);
InvokeRepeating("GetData", 5, 5);
InvokeRepeating("SetMarketData", 1, 1);
InvokeRepeating("GetTime", 1, 1);
InvokeRepeating("TimeContador", 0.1f, 0.1f);
}
private void btnUpdateSellOrderstton1_Click(object sender, EventArgs e)
{
SellOrder[] sellOrders = new SellOrder[this.SellOrdersGridView.SelectedRows.Count];
int i = 0;
foreach (DataGridViewRow item in this.SellOrdersGridView.SelectedRows)
{
sellOrders[i] = new SellOrder
{
Id = (int)item.Cells[0].Value,
CreatedAt = (DateTime)item.Cells[1].Value,
Quote = (float)item.Cells[2].Value,
Status = (OrderStatus)item.Cells[3].Value,
CreatedById = (int)item.Cells[4].Value,
DiginoteId = (int)item.Cells[5].Value
};
}
MessageBox.Show(Client.State.UpdateSellOrders(sellOrders));
}
public void Sell(string seller, float sellPrice, float sellAmount, int timeCreated)
{
Init();
float sellFunds = 0;
bool tradeable = false;
if (sellAmount <= 0)
{
sellAmount = 0.01f;
}
if (sellPrice <= 0)
{
sellPrice = 0.00001f;
}
else if (sellPrice <= 0.001f)
{
sellPrice = variables.Round(sellPrice, 5);
}
else if (sellPrice < 1)
{
sellPrice = variables.Round(sellPrice, 4);
}
else if (sellPrice >= 1)
{
sellPrice = variables.Round(sellPrice, 2);
}
sellFunds = sellAmount * sellPrice;
tradeable = CheckEnough(seller, sellAmount);
if (tradeable == true)
{
var order = new SellOrder(seller, sellAmount, sellFunds, sellPrice, timeCreated);
sellOrders.Add(order);
Availability(seller, sellAmount);
matchEngine.CheckMatch();
}
tradeable = false;
sellOrders.Sort((p1, p2) => p1.Price.CompareTo(p2.Price)); //Order the bidList based in the price in a ascending order
DisplaySellList();
}
public async Task <ActionResult <string> > AddSellOrderAsync(SellOrder order)
{
string result = string.Empty;
try
{
// validate the sell order here before deciding to accept it. E.g. check if the currency pair is valid.
if (SellOrderHelper.IsSellOrderValid(order))
{
await _dbLogger.LogSellOrderToDB(order);
result = $"Sell order: {order.CurrencyPair} {order.Amount} {order.MaximumSellPrice} {order.ExpiryDateTime} successfully added to CarbBank systems";
}
}
catch (Exception ex)
{
_ = _dbLogger.LogError(ex);
result = "An error occurred whilst processing your request. This has been logged with CarbBank, please try again later.";
}
return(result);
}
public async Task <IActionResult> Sell([FromBody] SellOrder sellOrder)
{
if (await _registryService.IsValidOwnershipAsync(sellOrder) == false)
{
var ownershipCouldNotBeVerified = "Ownership could not be verified.";
Console.Out.WriteLine(ownershipCouldNotBeVerified);
return(Json(new { status = ownershipCouldNotBeVerified }));
}
if (await _brokerService.CreateSellOrderAsync(sellOrder))
{
Response.StatusCode = 201;
var sellorderSubmittedToBroker = "Sellorder submitted to broker!";
Console.Out.WriteLine(sellorderSubmittedToBroker);
return(Json(new { status = sellorderSubmittedToBroker }));
}
Response.StatusCode = 500;
var brokerReturnedError = "Broker returned error";
Console.Out.WriteLine(brokerReturnedError);
return(Json(new { status = brokerReturnedError }));
}
public void Start()
{
shareHolder = GameObject.FindObjectOfType(typeof(ShareHolder)) as ShareHolder;
variables = GameObject.FindObjectOfType(typeof(Variables)) as Variables;
matchEngine = GameObject.FindObjectOfType(typeof(MatchEngine)) as MatchEngine;
Init();
//var order0 = new SellOrder(shareHolder.companyName, 400000, 320, 0.0008f, variables.timeContador);
var order = new SellOrder("Limit", 1, 9999999, 9999999, variables.timeContador);
sellOrders.Add(order);
//sellOrders.Add(order0);
for (int i = 0; i < 20; i++)
{
var orderi = new SellOrder(shareHolder.companyName, 100000 * i, 100000 * i * 0.0008f * i, 0.0008f * i, variables.timeContador);
sellOrders.Add(orderi);
}
sellOrders.Sort((p1, p2) => p1.Price.CompareTo(p2.Price));
DisplaySellList();
}
public async Task <ActionResult <SellOrder> > PostsellOrder([FromBody] SellOrder sellOrderItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.SellOrders.Add(sellOrderItem);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetsellOrder), new
{
id = sellOrderItem.Id,
sellTargetUpper = sellOrderItem.SellTargetUpper,
sellTargetLower = sellOrderItem.SellTargetLower,
quantity = sellOrderItem.Quantity,
datePlaced = sellOrderItem.DatePlaced,
dateExecuted = sellOrderItem.DateExecuted,
crypto = sellOrderItem.Crypto
}, sellOrderItem));
}
private static Order CreateOrder(BuyOrder buyOrder, SellOrder sellOrder)
{
var order = new Order();
order.TypeId = sellOrder != null ? sellOrder.TypeId : buyOrder.ItemId;
if (sellOrder != null)
{
order.IsSellOrder = true;
order.MinSellPrice = sellOrder.MinPrice;
order.MinSellQuantity = sellOrder.Quantity;
order.MaxSellQuantity = sellOrder.MaxQuantity;
order.UpdateTime = sellOrder.UpdateTime;
}
if (buyOrder != null)
{
order.IsBuyOrder = true;
order.MaxBuyPrice = buyOrder.MaxPrice;
order.BuyQuantity = buyOrder.Quantity;
}
order.AutoProcess = true;
return(order);
}
internal bool SendCorrectionOrder(string time, string price, uint number, int residue)
{
if (SellOrder.ContainsValue(number) && SellOrder.Remove(SellOrder.First(o => o.Value == number).Key) && Residue.Remove(number))
{
SellOrder[price] = Count;
Residue[Count++] = residue;
if (verify)
{
statement.Enqueue(new Conclusion
{
Time = ConvertDateTime(time),
Division = string.Concat(sell, correction),
Price = price,
OrderNumber = SellOrder[price].ToString("N0")
});
}
return(true);
}
if (BuyOrder.ContainsValue(number) && BuyOrder.Remove(BuyOrder.First(o => o.Value == number).Key) && Residue.Remove(number))
{
BuyOrder[price] = Count;
Residue[Count++] = residue;
if (verify)
{
statement.Enqueue(new Conclusion
{
Time = ConvertDateTime(time),
Division = string.Concat(buy, correction),
Price = price,
OrderNumber = BuyOrder[price].ToString("N0")
});
}
return(true);
}
return(false);
}
public void TestAddSellOrder()
{
Random rd = new Random();
var listPds = ProductMgr.Mgr.GetList();
var listEmp = EmployeeMgr.Mgr.GetList();
var listCus = CustomerMgr.Mgr.GetList();
int year = DateTime.Now.Year;
int month = DateTime.Now.Month;
int curMonth = month;
// 循环每年
for (int i = 0; i < 15; i++)
{
// 循环每个月
while (curMonth > 0)
{
int daysInMonth = DateTime.DaysInMonth(year - i, curMonth);
// 每个月插入 100条 测试数据
for (int j = 0; j < 100; j++)
{
int rVal = rd.Next(1, 100);
SellOrder entity = new SellOrder();
entity.ProductID = listPds.ToArray()[rVal % listPds.Count].ID;
entity.SellOrderNumber = rd.Next(1, 100) * 10;
entity.EmployeeID = listEmp.ToArray()[rVal % listEmp.Count].ID;
entity.CustomerID = listCus.ToArray()[rVal % listCus.Count].ID;
entity.SellOrderDate = new DateTime(year - i, curMonth, rd.Next(1, daysInMonth + 1));
var res = SellOrderMgr.Mgr.Insert(entity);
}
curMonth--;
}
curMonth = 12;
}
Assert.IsTrue(true);
}
public ActionResult SendSellOrder(SellOrder sellOrder)
{
sellOrder.EntryDate = DateTime.Now;
sellOrder.Status = "Ordered";
sellOrder.EmployeeId = (int)Session["user"];
if (ModelState.IsValid)
{
try
{
ViewBag.ShowMsg = _sellOrder.SendSellOrder(sellOrder);
}
catch (Exception exception)
{
ViewBag.ShowMsg = exception.Message;
}
}
ViewBag.area = _shopInfo.GetAreaList();
ViewBag.category = _sellOrder.GetAllCategory();
// ViewBag.item = _sellOrder.GetAllItem();
return(View());
}
public ICollection <Order> ImportOrders(string path)
{
var orders = new List <Order>();
try {
BuyOrderCollection buyOrders =
OrderInstallerIoService.ReadBuyOrders(path + Path.DirectorySeparatorChar + BuyOrdersFileName);
SellOrderCollection sellOrders =
OrderInstallerIoService.ReadSellOrders(path + Path.DirectorySeparatorChar + SellOrdersFileName);
ILookup <int, SellOrder> sellOrderLookup = sellOrders.ToLookup(f => f.TypeId);
foreach (BuyOrder buyOrder in buyOrders)
{
SellOrder sellOrder = sellOrderLookup[buyOrder.ItemId].SingleOrDefault();
sellOrders.Remove(sellOrder);
orders.Add(CreateOrder(buyOrder, sellOrder));
}
foreach (SellOrder sellOrder in sellOrders)
{
orders.Add(CreateOrder(null, sellOrder));
}
} catch (FileNotFoundException) {
}
return(orders);
}
public void AddBuyOrder(BuyOrder buyOrder)
{
var completeOrders = new List <SellOrder>();
var deals = new List <Deal>();
var sellOrders = _sellOrderRepository.Orders
.Where(o => o.Price <= buyOrder.Price)
.OrderBy(o => o.Price);
SellOrder updatedSellOrder = null;
foreach (var sellOrder in sellOrders)
{
var dealQty = Math.Min(sellOrder.Qty, buyOrder.Qty);
deals.Add(new Deal(buyOrder, sellOrder, sellOrder.Price, dealQty));
sellOrder.Qty -= dealQty;
if (sellOrder.Qty > 0)
{
updatedSellOrder = sellOrder;
}
else
{
completeOrders.Add(sellOrder);
}
buyOrder.Qty -= dealQty;
if (buyOrder.Qty <= 0)
{
break;
}
}
SaveOrderIfNotEmpty(_sellOrderRepository, updatedSellOrder);
SaveDeals(deals);
SaveOrderIfNotEmpty(_buyOrderRepository, buyOrder);
_sellOrderRepository.DeleteMany(completeOrders);
}
public string SendSellOrder(SellOrder sellOrder)
{
if (_sellOrder.IsItemExists(sellOrder))
{
if (_sellOrder.IsSellOrderExists(sellOrder))
{
sellOrder.Id = _sellOrder.GetOrderId(sellOrder);
if (_sellOrder.UpdateSendSellOrder(sellOrder) > 0)
{
return("Sell Order Updated!");
}
}
if (_sellOrder.SendSellOrder(sellOrder) > 0)
{
return("Sell Order Send!");
}
}
else
{
return("Sorry! This item are not available");
}
return("Order Sending Faild");
}
public IOrderDetails PlaceSellOrder(SellOptions options)
{
OrderDetails orderDetails = new OrderDetails();
tradingService.StopTrailingSell(options.Pair);
tradingService.StopTrailingBuy(options.Pair);
try
{
string normalizedPair = tradingService.NormalizePair(options.Pair);
ITradingPair tradingPair = tradingService.Account.GetTradingPair(normalizedPair, includeDust: true);
options.Price = tradingService.GetPrice(options.Pair, TradePriceType.Bid);
options.Amount = options.Amount ?? tradingPair?.Amount ?? 0;
options.Price = options.Price != 1 ? tradingService.Exchange.ClampOrderPrice(options.Pair, options.Price.Value) : 1; // 1 = USDT price
options.Amount = tradingService.Exchange.ClampOrderAmount(options.Pair, options.Amount.Value);
if (tradingService.CanSell(options, out string message))
{
IPairConfig pairConfig = tradingService.GetPairConfig(normalizedPair);
SellOrder sellOrder = new SellOrder
{
Type = pairConfig.SellType,
Date = DateTimeOffset.Now,
Pair = options.Pair,
Price = options.Price.Value,
Amount = options.Amount.Value
};
lock (tradingService.Account.SyncRoot)
{
tradingPair.SetCurrentValues(tradingService.GetPrice(normalizedPair), tradingService.Exchange.GetPriceSpread(normalizedPair));
string sellPairName = normalizedPair != options.Pair ? options.Pair : tradingPair.FormattedName;
loggingService.Info($"Place sell order for {sellPairName}. " +
$"Price: {sellOrder.Price:0.00000000}, Amount: {sellOrder.Amount:0.########}, Margin: {tradingPair.CurrentMargin:0.00}");
if (!tradingService.Config.VirtualTrading)
{
orderDetails = tradingService.Exchange.PlaceOrder(sellOrder) as OrderDetails;
}
else
{
string pairMarket = tradingService.Exchange.GetPairMarket(options.Pair);
orderDetails = new OrderDetails
{
OrderId = DateTime.Now.ToFileTimeUtc().ToString(),
Side = OrderSide.Sell,
Result = OrderResult.Filled,
Date = sellOrder.Date,
Pair = sellOrder.Pair,
Amount = sellOrder.Amount,
AmountFilled = sellOrder.Amount,
Price = sellOrder.Price,
AveragePrice = sellOrder.Price,
Fees = sellOrder.Amount * sellOrder.Price * tradingService.Config.VirtualTradingFees,
FeesCurrency = pairMarket
};
}
NormalizeOrder(orderDetails, TradePriceType.Bid);
tradingPair.SetMetadata(tradingPair.Metadata.MergeWith(options.Metadata));
orderDetails.Metadata = tradingPair.Metadata;
var tradeResult = tradingService.Account.AddSellOrder(orderDetails) as TradeResult;
tradeResult.IsSwap = options.Swap;
tradeResult.IsArbitrage = options.Arbitrage;
tradingService.Account.Save();
tradingService.LogOrder(orderDetails);
decimal fees = tradingService.CalculateOrderFees(orderDetails);
decimal margin = (tradeResult.Profit / (tradeResult.Cost + (tradeResult.Metadata.AdditionalCosts ?? 0)) * 100);
string swapPair = options.Metadata.SwapPair != null ? $", Swap Pair: {options.Metadata.SwapPair}" : "";
string arbitrage = options.Metadata.Arbitrage != null ? $", Arbitrage: {options.Metadata.Arbitrage} ({options.Metadata.ArbitragePercentage:0.00})" : "";
loggingService.Info("{@Trade}", orderDetails);
loggingService.Info("{@Trade}", tradeResult);
loggingService.Info($"Sell order result for {orderDetails.OriginalPair ?? tradingPair.FormattedName}: {orderDetails.Result} ({orderDetails.Message}). " +
$"Price: {orderDetails.AveragePrice:0.00000000}, Amount: {orderDetails.Amount:0.########}, Filled: {orderDetails.AmountFilled:0.########}, " +
$"Cost: {orderDetails.Cost:0.00000000}, Fees: {fees:0.00000000}, Margin: {margin:0.00}, Profit: {tradeResult.Profit:0.00000000}{swapPair}{arbitrage}");
notificationService.Notify($"Sold {tradingPair.FormattedName}. Amount: {orderDetails.AmountFilled:0.########}, " +
$"Price: {orderDetails.AveragePrice:0.00000000}, Margin: {margin:0.00}, Profit: {tradeResult.Profit:0.00000000}{swapPair}{arbitrage}");
}
tradingService.ReapplyTradingRules();
}
else
{
loggingService.Info(message);
}
}
catch (Exception ex)
{
loggingService.Error($"Unable to place sell order for {options.Pair}", ex);
notificationService.Notify($"Unable to sell {options.Pair}: {ex.Message}");
}
return(orderDetails);
}
public TestDbState AddOrder(SellOrder sellOrder)
{
SellOrders.Add(sellOrder);
return(this);
}
internal void SetStatisticalStorage(string date, double price, bool over)
{
if (over || Array.Exists(Information.RemainingDay, o => o.Equals(date)))
{
while (Quantity != 0)
{
if (verify)
{
statement.Enqueue(new Conclusion
{
Time = ConvertDateTime(date),
Division = string.Concat(Quantity > 0 ? sell : buy, conclusion),
Price = price.ToString("F2"),
OrderNumber = Count.ToString("N0")
});
}
Quantity += Quantity > 0 ? -1 : 1;
SetConclusion(price);
}
}
Revenue = CumulativeRevenue - Commission;
long revenue = Revenue - TodayRevenue, unrealized = (long)(Quantity == 0 ? 0 : (Quantity > 0 ? price - PurchasePrice : PurchasePrice - price) * Const.TransactionMultiplier * Math.Abs(Quantity));
var avg = EMA.Make(++Accumulative, SetWeight(revenue + unrealized - UnRealize), Before);
games.Enqueue(new Models.Strategics
{
Primary = Convert.ToString(GetPrimary(game.Assets, game.Code, game.Commission, game.MarginRate, game.RollOver), 0x10),
Assets = game.Assets,
Code = game.Code,
Commission = game.Commission,
MarginRate = game.MarginRate,
Strategy = game.Strategy,
RollOver = game.RollOver,
BaseTime = game.BaseTime,
BaseShort = game.BaseShort,
BaseLong = game.BaseLong,
NonaTime = game.NonaTime,
NonaShort = game.NonaShort,
NonaLong = game.NonaLong,
OctaTime = game.OctaTime,
OctaShort = game.OctaShort,
OctaLong = game.OctaLong,
HeptaTime = game.HeptaTime,
HeptaShort = game.HeptaShort,
HeptaLong = game.HeptaLong,
HexaTime = game.HexaTime,
HexaShort = game.HexaShort,
HexaLong = game.HexaLong,
PentaTime = game.PentaTime,
PentaShort = game.PentaShort,
PentaLong = game.PentaLong,
QuadTime = game.QuadTime,
QuadShort = game.QuadShort,
QuadLong = game.QuadLong,
TriTime = game.TriTime,
TriShort = game.TriShort,
TriLong = game.TriLong,
DuoTime = game.DuoTime,
DuoShort = game.DuoShort,
DuoLong = game.DuoLong,
MonoTime = game.MonoTime,
MonoShort = game.MonoShort,
MonoLong = game.MonoLong,
Date = date,
Unrealized = unrealized,
Revenue = revenue,
Cumulative = CumulativeRevenue - Commission,
Fees = (int)(Commission - TodayCommission),
Statistic = (int)avg
});
if (Count > 5000)
{
new ExceptionMessage(game.Strategy, string.Concat(date, '_', Count));
}
Before = avg;
TodayCommission = (int)Commission;
TodayRevenue = Revenue;
UnRealize = unrealized;
SellOrder.Clear();
BuyOrder.Clear();
Residue.Clear();
Count = 0;
}
/// <summary>
/// 获取当前相关参数
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private void getP(object data)
{
String result = getRequest.future_kline(symbol, type, contractType, "60", "");
String[] sArray = result.Split(',');//开高低收
double EMA12 = 0;
double EMA26 = 0;
double DIF = 0;
double DEA = 0;
double nowPrice = 0;
double K = 50;
double D = 50;
double RSV = 0;
for (int i = 4; i < sArray.Length; i += 7)
{
double price;
double high;
double low;
double.TryParse(sArray[i], out price);
double.TryParse(sArray[i - 2], out high);
double.TryParse(sArray[i - 1], out low);
nowPrice = price;
EMA12 = (EMA12 * 11) / 13 + price * 2 / 13;
EMA26 = (EMA26 * 25) / 27 + price * 2 / 27;
DIF = EMA12 - EMA26;
DEA = (DEA * 8) / 10 + DIF * 2 / 10;
RSV = (price - low) * 100 / (high - low);
K = 2 * K / 3 + RSV / 3;
D = 2 * D / 3 + K / 3;
}
double MACD = (DIF - DEA) * 2;
double J = 3 * K - 2 * D;
page.setMACD(MACD.ToString());
String kdj = "K:" + K.ToString().Substring(0, 2) + " D:" + D.ToString().Substring(0, 2) + " J:" + J.ToString().Substring(0, 2);
page.setKDJ(kdj);
if (strategy.strategyname == "MACD")
{
if (MACD > strategy.p1)
{//买入
if (order == null)
{
if (minBetween == timecount)
{
if (sell1 != 0)
{
if (Coin >= exchangeCoin)
{
order = new Order(exchangeCoin, sell1, page);
wait = 0;
}
}
}
}
}
else
{//卖出
if (order != null)
{
if (order.judge == false)
{
order = null;
page.交易信息_Add("买入订单删除");
return;
}
if (minBetween == timecount)
{
if (buy1 != 0)
{
sellorder = new SellOrder(order.getcoin(), order.getbuyprice(), buy1, page);
wait = 0;
}
}
}
}
}
else if (strategy.strategyname == "KDJ")
{
if (D - K > strategy.p1)
{//买入
if (order == null)
{
if (minBetween == timecount)
{
if (sell1 != 0)
{
if (Coin >= exchangeCoin)
{
order = new Order(exchangeCoin, sell1, page);
wait = 0;
}
}
}
}
}
else
{//卖出
if (order != null)
{
if (order.judge == false)
{
order = null;
page.交易信息_Add("买入订单删除");
return;
}
if (minBetween == timecount)
{
if (buy1 != 0)
{
sellorder = new SellOrder(order.getcoin(), order.getbuyprice(), buy1, page);
wait = 0;
}
}
}
}
}
else
{
int masmall = (int)strategy.p1;
int masbig = (int)strategy.p2;
double sum1 = 0, sum2 = 0;
int index = 0;
for (int i = 417; index < masmall; index++)
{
double price;
double.TryParse(sArray[i], out price);
sum1 += price;
i -= 7;
}
index = 0;
for (int i = 417; index < masbig; index++)
{
double price;
double.TryParse(sArray[i], out price);
sum2 += price;
i -= 7;
}
double ma1 = sum1 / masmall;
double ma2 = sum2 / masbig;
if (ma1 > ma2)
{
//买入
if (order == null)
{
if (minBetween == timecount)
{
if (sell1 != 0)
{
if (Coin >= exchangeCoin)
{
order = new Order(exchangeCoin, sell1, page);
wait = 0;
}
}
}
}
}
else
{
//卖出
if (order != null)
{
if (order.judge == false)
{
order = null;
page.交易信息_Add("买入订单删除");
return;
}
if (minBetween == timecount)
{
if (buy1 != 0)
{
sellorder = new SellOrder(order.getcoin(), order.getbuyprice(), buy1, page);
wait = 0;
}
}
}
}
}
}
