Exemplo n.º 1
0
 public override void Add(StockOrder stockOrder)
 {
     if (stockOrder.State != StockOrder.OrderStatus.Executed)
      {
     throw new System.Exception("Cannot add a not executed order to a position");
      }
      if (stockOrder.IsShortOrder ^ this.IsShortPosition)
      {
     throw new System.Exception("Cannot add a short order to a long position");
      }
      if (stockOrder.IsBuyOrder())
      {
     this.UnitCost = (this.UnitCost * this.Number + stockOrder.UnitCost * stockOrder.Number) / (float)(this.Number + stockOrder.Number);
     this.Number += stockOrder.Number;
      }
      else
      {
     if (this.Number > stockOrder.Number)
     {
        this.Number -= stockOrder.Number;
     }
     else
     {
        if (this.Number == stockOrder.Number)
        {
           this.Number = 0;
           this.Status = PositionStatus.Closed;
        }
        else
        {
           throw new System.Exception("Cannot sell more stock than owned");
        }
     }
      }
 }
 public override void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
 {
     base.Initialise(stockSerie, lastBuyOrder, supportShortSelling);
      this.oscSerie = null;
      this.trailStop = StockTrailStopManager.CreateTrailStop("TRAILHL(3)");
      this.trailStop.ApplyTo(stockSerie);
 }
Exemplo n.º 3
0
 public static IStockStrategy CreateStrategy(string name, StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
 {
     IStockStrategy strategy = null;
      try
      {
     if (name.StartsWith("@"))
        return CreateFilteredStrategy(name, stockSerie, lastBuyOrder, supportShortSelling);
     if (strategyList == null)
     {
        GetStrategyList();
     }
     if (strategyList.Contains(name))
     {
        StrategyManager sm = new StrategyManager();
        strategy =
                    (IStockStrategy)
                        sm.GetType().Assembly.CreateInstance("StockAnalyzer.StockStrategyClasses." + name);
        strategy.Initialise(stockSerie, lastBuyOrder, supportShortSelling);
     }
      }
      catch (Exception ex)
      {
     throw new StockAnalyzerException("Failed to create strategy " + name, ex);
      }
      return strategy;
 }
Exemplo n.º 4
0
        public override void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
        {
            base.Initialise(stockSerie, lastBuyOrder, supportShortSelling);
             this.SRTrailStop = stockSerie.GetTrailStop(trailName);

             this.adxDecorator = stockSerie.GetDecorator("DIV(1)", ((IStockIndicator)TriggerIndicator).Name);
        }
Exemplo n.º 5
0
        public OrderEditionDlg(string currentStockName, string[] portofolioList, StockOrder stockOrderTemplate)
        {
            InitializeComponent();

             //Initialise stock name combo list
             StockDictionary stockDictionary = StockAnalyzerForm.MainFrame.StockDictionary;
             foreach (string stockName in stockDictionary.Keys)
             {
            this.stockNameCombo.Items.Add(stockName);
             }

             // Order Type change combo box
             string[] orderTypeNames = Enum.GetNames(typeof(StockOrder.OrderType));
             this.orderTypeComboBox.Enabled = true;
             this.orderTypeComboBox.Items.Clear();
             foreach (string name in orderTypeNames)
             {
            this.orderTypeComboBox.Items.Add(name);
             }
             this.orderTypeComboBox.SelectedIndex = 0;

             // UpDownState combo box
             string[] stateNames = Enum.GetNames(typeof(StockOrder.OrderStatus));
             this.stateComboBox.Enabled = true;
             this.stateComboBox.Items.Clear();
             foreach (string name in stateNames)
             {
            this.stateComboBox.Items.Add(name);
             }
             this.stateComboBox.SelectedIndex = 0;

             // Portofolio change
             if (portofolioList == null)
             {
            portofolioList = StockAnalyzerForm.MainFrame.StockPortofolioList.GetPortofolioNames();
             }
             this.portofolioComboBox.Enabled = true;
             this.portofolioComboBox.Items.Clear();
             foreach (string name in portofolioList)
             {
            this.portofolioComboBox.Items.Add(name);
             }
             this.portofolioComboBox.SelectedItem = this.portofolioComboBox.Items[0];

             // Create default order
             if (stockOrderTemplate == null)
             {
            this.Order = StockOrder.CreateExecutedOrder(currentStockName, StockOrder.OrderType.BuyAtLimit, false, DateTime.Today, DateTime.Today, 0, 0.0f, 0.0f);
             }
             else
             {
            this.Order = stockOrderTemplate;
             }
        }
Exemplo n.º 6
0
        public override void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
        {
            base.Initialise(stockSerie, lastBuyOrder, supportShortSelling);

             IStockIndicator indicator = TriggerIndicator as IStockIndicator;
             middleUpBandSerie = indicator.Series[1];
             middleBandSerie = indicator.Series[2];
             middleDownBandSerie = indicator.Series[3];

             lowSerie = stockSerie.GetSerie(StockDataType.LOW);
             highSerie = stockSerie.GetSerie(StockDataType.HIGH);
             closeSerie = stockSerie.GetSerie(StockDataType.CLOSE);
        }
Exemplo n.º 7
0
        public StockPosition(StockOrder stockOrder)
        {
            if (stockOrder.State != StockOrder.OrderStatus.Executed)
             {
            throw new System.Exception("Cannot create a position from a not executed order");
             }

             this.OpenDate = stockOrder.ExecutionDate;
             this.Number = stockOrder.Number;
             this.StockName = stockOrder.StockName;
             this.UnitCost = stockOrder.UnitCost;
             this.CloseDate = DateTime.MinValue;
             this.IsShortPosition = stockOrder.IsShortOrder;
             this.Status = PositionStatus.Opened;
        }
 public override void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
 {
     this.Serie = stockSerie;
      this.LastBuyOrder = lastBuyOrder;
      this.SupportShortSelling = supportShortSelling;
      if (StockDictionary.StockDictionarySingleton.ContainsKey("TB." + stockSerie.StockName))
      {
     StockSerie breadthSerie = StockDictionary.StockDictionarySingleton["TB." + stockSerie.StockName];
     if (breadthSerie.Initialise())
     {
        IStockIndicator OSCIndicator = breadthSerie.GetIndicator(((IStockIndicator)TriggerIndicator).Name);
        if (OSCIndicator != null)
        {
           OSCSerie = OSCIndicator.Series[0];
        }
     }
      }
 }
Exemplo n.º 9
0
        public OrderEditionDlg(StockOrder stockOrder)
        {
            InitializeComponent();

             //Initialise stock name combo list
             this.stockNameCombo.Items.Add(stockOrder.StockName);
             this.stockNameCombo.SelectedItem = stockOrder.StockName;

             this.Order = stockOrder;

             // Disable the portofolio change
             this.portofolioComboBox.Enabled = false;

             this.parseOrderBtn.Enabled = false;
             this.orderText.Enabled = false;

             this.amountToInvestTextBox.Text = "1000";
        }
Exemplo n.º 10
0
        public virtual void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
        {
            this.Serie = stockSerie;
             this.LastBuyOrder = lastBuyOrder;
             this.SupportShortSelling = supportShortSelling;

             IStockViewableSeries triggerSerie = this.TriggerIndicator as IStockViewableSeries;
             if (triggerSerie != null)
             {
            if (stockSerie.HasVolume || !triggerSerie.RequiresVolumeData)
            {
               triggerSerie.ApplyTo(stockSerie);
            }
            else
            {
               throw new System.Exception("This serie has probably no volume");
            }
             }
        }
Exemplo n.º 11
0
 public static StockFilteredStrategyBase CreateFilteredStrategy(string name, StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
 {
     StockFilteredStrategyBase strategy = null;
      if (filteredStrategyList == null)
      {
     GetFilteredStrategyList(false);
      }
      if (filteredStrategyList.Contains(name))
      {
     // Deserialize strategy file
     string fileName = Settings.Default.RootFolder + @"\FilteredStrategies\" + name.Replace("@", "") + ".xml";
     using (FileStream fs = new FileStream(fileName, FileMode.Open))
     {
        System.Xml.XmlReaderSettings settings = new System.Xml.XmlReaderSettings();
        settings.IgnoreWhitespace = true;
        System.Xml.XmlReader xmlReader = System.Xml.XmlReader.Create(fs, settings);
        XmlSerializer serializer = new XmlSerializer(typeof(StockFilteredStrategyBase));
        strategy = (StockFilteredStrategyBase)serializer.Deserialize(xmlReader);
        strategy.Initialise(stockSerie, lastBuyOrder, supportShortSelling);
     }
      }
      return strategy;
 }
Exemplo n.º 12
0
        void shortMenu_Click(object sender, System.EventArgs e)
        {
            if (lastMouseIndex != -1 && this.openCurveType != null && this.dateSerie != null)
            {
                StockOrder newOrder = new StockOrder();
                newOrder.State = StockOrder.OrderStatus.Executed;
                newOrder.StockName = this.serieName;
                newOrder.Type = StockOrder.OrderType.SellAtLimit;
                newOrder.IsShortOrder = true;
                newOrder.Value = this.openCurveType.DataSerie[lastMouseIndex];
                newOrder.Number = 10;
                newOrder.CreationDate = this.dateSerie[lastMouseIndex];
                newOrder.ExecutionDate = this.dateSerie[lastMouseIndex];
                newOrder.ExpiryDate = this.dateSerie[lastMouseIndex].AddMonths(1);

                OrderEditionDlg dlg = new OrderEditionDlg(newOrder);
                if (dlg.ShowDialog() == DialogResult.OK)
                {
                    StockAnalyzerForm.MainFrame.CurrentPortofolio.OrderList.Add(newOrder);

                    this.ForegroundDirty = true;
                }
            }
        }
Exemplo n.º 13
0
        public override void Initialise(StockSerie stockSerie, StockOrder lastBuyOrder, bool supportShortSelling)
        {
            base.Initialise(stockSerie, lastBuyOrder, supportShortSelling);

             movingAverage.ApplyTo(stockSerie);
        }
Exemplo n.º 14
0
 private static int compareDate(StockOrder stockOrder1, StockOrder stockOrder2)
 {
     return stockOrder1.ExecutionDate.CompareTo(stockOrder2.ExecutionDate);
 }
Exemplo n.º 15
0
 public static StockOrder CreateBuyAtLimitStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, float amountToInvest, float limit, StockDailyValue dailyValue, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.BuyAtLimit;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.AmountToInvest = amountToInvest;
      stockOrder.Limit = limit;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      if (limit > dailyValue.CLOSE)
      {
     StockLog.Write("Invalid limit in CreateBuyAtLimitStockOrder");
      }
      return stockOrder;
 }
Exemplo n.º 16
0
 public static StockOrder CreateBuyTrailingStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, float amountToInvest, float benchmark, float gapInPoints, StockDailyValue dailyValue)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.BuyTrailing;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.AmountToInvest = amountToInvest;
      stockOrder.Benchmark = benchmark;
      stockOrder.GapInPoints = gapInPoints;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      return stockOrder;
 }
Exemplo n.º 17
0
 public StockPosition AddToPosition(StockOrder stockOrder)
 {
     StockPosition stockPosition = null;
      if (this.StockName == stockOrder.StockName && !(this.IsShortOrder ^ stockOrder.IsShortOrder))
      {
     stockPosition = StockPositionBase.CreatePosition(this);
     stockPosition.Add(stockOrder);
      }
      else
      {
     throw new System.ArithmeticException("Cannot add orders for different stock name");
      }
      return stockPosition;
 }
Exemplo n.º 18
0
 public static StockOrder CreateSellAtThresholdStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, int number, float threshold, StockDailyValue dailyValue, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.SellAtThreshold;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.Number = number;
      stockOrder.Threshold = threshold;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      if (threshold > dailyValue.CLOSE) // OK Due to dodgy short sell management
      {
        // throw new Exception("Invalid threshold");
      }
      return stockOrder;
 }
Exemplo n.º 19
0
 public static StockOrder CreateSellTrailingStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, int number, float benchmark, float gapInPoints, StockDailyValue dailyValue)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.SellTrailing;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.Number = number;
      stockOrder.Benchmark = benchmark;
      stockOrder.GapInPoints = gapInPoints;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      return stockOrder;
 }
        public override StockOrder TryToSell(int index, ref float benchmark)
        {
            StockDailyValue dailyValue = this.Serie.Values.ElementAt(index);
            benchmark = dailyValue.CLOSE;

            #region Create Sell Order
            StockOrder stockOrder = null;

            // Check if we are in profit
            bool inProfit = false;
            float limit;
            if (LastBuyOrder.IsShortOrder)
            {
                if (LastBuyOrder.UnitCost > dailyValue.CLOSE)
                {
                    inProfit = true;
                    if (this.Serie.GetSerie(StockDataType.EMA3)[index] > dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA3)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.EMA6)[index] > dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA6)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.EMA12)[index] > dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA12)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.SAREX_FOLLOWER)[index] > dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.SAREX_FOLLOWER)[index];
                    }
                    else
                    {
                        limit = dailyValue.HIGH;
                    }
                }
                else
                {
                    limit = dailyValue.HIGH;
                }
            }
            else
            {
                if (LastBuyOrder.UnitCost < dailyValue.CLOSE)
                {
                    inProfit = true;
                    if (this.Serie.GetSerie(StockDataType.EMA3)[index] < dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA3)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.EMA6)[index] < dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA6)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.EMA12)[index] < dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.EMA12)[index];
                    }
                    else if (this.Serie.GetSerie(StockDataType.SAREX_FOLLOWER)[index] < dailyValue.CLOSE)
                    {
                        limit = this.Serie.GetSerie(StockDataType.SAREX_FOLLOWER)[index];
                    }
                    else
                    {
                        limit = dailyValue.LOW;
                    }
                }
                else
                {
                    limit = dailyValue.LOW;
                }
            }

            // Review sell limit according to indicators
            float buySellRate = this.Serie.GetSerie(StockIndicatorType.BUY_SELL_RATE).Values[index];
            if (LastBuyOrder.IsShortOrder)
            {
                if (inProfit || buySellRate > 0.0f)
                {
                    stockOrder = StockOrder.CreateSellAtLimitStockOrder(dailyValue.NAME, dailyValue.DATE, dailyValue.DATE.AddDays(5), this.LastBuyOrder.Number, limit, dailyValue, true);
                }
            }
            else
            {
                if (inProfit || buySellRate < 0.0f)
                {
                    stockOrder = StockOrder.CreateSellAtThresholdStockOrder(dailyValue.NAME, dailyValue.DATE, dailyValue.DATE.AddDays(5), this.LastBuyOrder.Number, limit, dailyValue, false);
                }
            }
            #endregion
            lastSellOrder = stockOrder;
            return stockOrder;
        }
Exemplo n.º 21
0
 public static StockOrder CreateSellAtMarketOpenStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, int number, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.SellAtMarketOpen;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.Number = number;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      return stockOrder;
 }
Exemplo n.º 22
0
 public static StockOrder CreateBuyAtMarketOpenStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, float amountToInvest, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.BuyAtMarketOpen;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.AmountToInvest = amountToInvest;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      return stockOrder;
 }
Exemplo n.º 23
0
        public static StockOrder CreateFromCAPCA(string line, ref string errorMsg)
        {
            StockOrder stockOrder = new StockOrder();
             try
             {
            string[] fields = line.Split('|');

            // Find order date
            stockOrder.ExecutionDate = DateTime.Parse(fields[0]);
            stockOrder.CreationDate = DateTime.Parse(fields[0]);

            // Find order type
            if (fields[1] == "Buy")
            {
               stockOrder.Type = StockOrder.OrderType.BuyAtLimit;
            }
            else if (fields[1] == "Sell")
            {
               stockOrder.Type = StockOrder.OrderType.SellAtLimit;
            }
            else
            {
               errorMsg = "Invalid order type: " + fields[1];
               return null;
            }

            // Find number of stocks
            stockOrder.Number = int.Parse(fields[2].Replace(" ", ""));

            // Find Stock Name
            string stockName = fields[3].Substring(fields[3].IndexOf(' ') + 1);
            int endIndex = stockName.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-' }) - 1;
            stockOrder.StockName = stockName.Substring(0, endIndex);

            // Find stock unit value
            stockOrder.Value = float.Parse(fields[4], StockAnalyzerApp.Global.EnglishCulture);

            // There'sno fee in the report :-(
            stockOrder.Fee = 0.0f;
             }
             catch (System.Exception e)
             {
            errorMsg = e.Message;
            stockOrder = null;
             }
             return stockOrder;
        }
Exemplo n.º 24
0
 public static StockOrder CreateExecutedOrder(int id, string stockName, OrderType type, bool isShortOrder, DateTime creationDate, DateTime executionDate, int number, float value, float fee)
 {
     StockOrder stockOrder = new StockOrder(id);
      stockOrder.StockName = stockName;
      stockOrder.Type = type;
      stockOrder.CreationDate = creationDate;
      stockOrder.ExecutionDate = executionDate;
      stockOrder.Number = number;
      stockOrder.ExecutedNumber = number;
      stockOrder.Value = value;
      stockOrder.Fee = fee;
      stockOrder.State = OrderStatus.Executed;
      stockOrder.IsShortOrder = isShortOrder;
      return stockOrder;
 }
Exemplo n.º 25
0
        private PointF GetScreenPointFromOrder(StockOrder stockOrder)
        {
            PointF valuePoint2D = PointF.Empty;

            DateTime orderDate = serieName.StartsWith("INT_") ? stockOrder.ExecutionDate : stockOrder.ExecutionDate.Date;
            valuePoint2D.X = this.IndexOf(orderDate);
            valuePoint2D.Y = stockOrder.UnitCost;
            return this.GetScreenPointFromValuePoint(valuePoint2D);
        }
Exemplo n.º 26
0
 /// <summary>
 /// Return a new order matching new position. THis method should be rewritten using StockPositions.
 /// </summary>
 /// <param name="stockOrder"></param>
 /// <returns></returns>
 public StockOrder Add(StockOrder stockOrder)
 {
     // #### Need to be reviewed due to the Buy at market OPEN or CLOSE difference.
      if (this.StockName == stockOrder.StockName)
      {
     int newNumber = 0;
     float newValue = 0;
     if (this.IsBuyOrder())
     {
        if (stockOrder.IsBuyOrder())
        {
           // Add new order to current position
           newNumber = this.Number + stockOrder.Number;
           newValue = (this.Value * this.Number + stockOrder.Value * stockOrder.Number) / (float)newNumber;
           return CreateExecutedOrder(this.StockName, this.Type, false, this.CreationDate, stockOrder.ExecutionDate, newNumber, newValue, this.Fee + stockOrder.Fee);
        }
        else // Sell order
        {
           newNumber = this.Number - stockOrder.Number;
           //if (newNumber == 0)
           //{
           //    // Everything is sold.
           //    return null;
           //}
           //else
           //{
           // Keep same value as initial order when selling it partially.
           newValue = this.Value;
           return CreateExecutedOrder(this.StockName, this.Type, false, this.CreationDate, stockOrder.ExecutionDate, newNumber, newValue, this.Fee + stockOrder.Fee);
           //}
        }
     }
     else // Sell order
     {
        if (stockOrder.IsBuyOrder())
        {
           newNumber = stockOrder.Number - this.Number;
           if (newNumber == 0)
           {
              return null;
           }
           else
           {
              // Keep same value as initial order when covering it partially.
              newValue = (stockOrder.Value * stockOrder.Number - this.Value * this.Number) / (float)newNumber;
              return CreateExecutedOrder(this.StockName, this.Type, false, this.CreationDate, stockOrder.ExecutionDate, newNumber, newValue, this.Fee + stockOrder.Fee);
           }
        }
        else // Sell order
        {
           // TODO test
           newNumber = this.Number + stockOrder.Number;
           newValue = (this.Value * this.Number + stockOrder.Value * stockOrder.Number) / (float)newNumber;
           return CreateExecutedOrder(this.StockName, this.Type, false, this.CreationDate, stockOrder.ExecutionDate, newNumber, newValue, this.Fee + stockOrder.Fee);
        }
     }
      }
      else
      {
     throw new System.ArithmeticException("Cannot add orders for different stock name");
      }
 }
Exemplo n.º 27
0
        public static StockOrder CreateFromStockBrokers(string line, ref string errorMsg)
        {
            StockOrder stockOrder = new StockOrder();
             try
             {
            string[] fields = line.Split('|');

            // Find order date
            stockOrder.ExecutionDate = DateTime.Parse(fields[0]);
            stockOrder.CreationDate = DateTime.Parse(fields[0]);

            // Find order type
            if (fields[1] == "Buy")
            {
               stockOrder.Type = StockOrder.OrderType.BuyAtLimit;
            }
            else if (fields[1] == "Sell")
            {
               stockOrder.Type = StockOrder.OrderType.SellAtLimit;
            }
            else
            {
               errorMsg = "Invalid order type: " + fields[1];
               return null;
            }

            // Find Stock Name
            stockOrder.StockName = fields[2];

            // Find number of stocks
            stockOrder.Number = int.Parse(fields[4]);

            // Find stock unit value
            stockOrder.Value = float.Parse(fields[5], StockAnalyzerApp.Global.EnglishCulture) / 100.0f;

            // Find Total order value and fee
            float totalOrderValue = 0.0f;
            if (stockOrder.IsBuyOrder())
            {
               totalOrderValue = float.Parse(fields[6], StockAnalyzerApp.Global.EnglishCulture);
               stockOrder.Fee = totalOrderValue - stockOrder.Number * stockOrder.Value;
            }
            else
            {
               totalOrderValue = float.Parse(fields[7], StockAnalyzerApp.Global.EnglishCulture);
               stockOrder.Fee = stockOrder.Number * stockOrder.Value - totalOrderValue;
            }
             }
             catch (System.Exception e)
             {
            errorMsg = e.Message;
            stockOrder = null;
             }
             return stockOrder;
        }
Exemplo n.º 28
0
 public static StockOrder CreateBuyAtThresholdStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, float amountToInvest, float threshold, StockDailyValue dailyValue, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.BuyAtThreshold;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.AmountToInvest = amountToInvest;
      stockOrder.Threshold = threshold;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      if (threshold < dailyValue.CLOSE)
      {
     throw new Exception("Invalid threshold"); // OK Due to dodgy shrt sell management
      }
      return stockOrder;
 }
Exemplo n.º 29
0
 public StockOrderViewModel(StockOrder stockOrder)
 {
     this.order = stockOrder;
 }
Exemplo n.º 30
0
 public static StockOrder CreateSellAtLimitStockOrder(string stockName, DateTime creationDate, DateTime expiryDate, int number, float limit, StockDailyValue dailyValue, bool isShortOrder)
 {
     StockOrder stockOrder = new StockOrder();
      stockOrder.Type = OrderType.SellAtLimit;
      stockOrder.StockName = stockName;
      stockOrder.CreationDate = creationDate;
      stockOrder.Number = number;
      stockOrder.Limit = limit;
      stockOrder.State = OrderStatus.Pending;
      stockOrder.ExpiryDate = expiryDate;
      stockOrder.IsShortOrder = isShortOrder;
      if (limit < dailyValue.CLOSE)
      {
     StockLog.Write("Invalid limit in CreateSellAtLimitStockOrder");
      }
      return stockOrder;
 }