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; } } } } } }