コード例 #1
0
  /**
   * Request from fornt end to modify params
   */
  void TestContext::onCMDModifyStrategy(API2::AbstractUserParams* newParams)
  {
    DEBUG_METHOD(reqQryDebugLog());
    _modify = true;
    API2::UserParams* modParams = (API2::UserParams*) newParams;

    /**
     * setting new params in a new data structure of params
     */
    if(!setModifiedInternalParameters(modParams))
    {
      DEBUG_MESSAGE(reqQryDebugLog(),"Front End Parameters Failed");
      terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_VERSION_DIFFERS);
      return;
    }

    /**
     * If no order pending , we can modifyStartegy
     */
    if(_modify && !isAnyOrderPending())
      modifyStrategy();

    /** need to send this response to front end that strategy has successfully recieved modify command
    */
    reqSendStrategyResponse(API2::CONSTANTS::RSP_ResponseType_STRATEGY_RUNNING,
        API2::CONSTANTS::RSP_RiskStatus_SUCCESS,
        API2::CONSTANTS::RSP_StrategyComment_USER_INPUT);
  }
コード例 #2
0
bool API2::Test2::Context::setTestParameters()
{
  _userParams._symbolId = reqQrySymbolID("ESMNSE ESMNSE RELIANCE");
  DEBUG_VARSHOW(reqQryDebugLog(), "====SymbolID: ", _userParams._symbolId);
  //_userParams._symbolId = GET_SYMBOL_ID_NEW(268084,API2::CONSTANTS::CMD_ExchangeId_SMART,API2::CONSTANTS::CMD_SourceId_IB);
  //    _userParams._symbolId = GET_SYMBOL_ID_NEW(2885,CMD::ExchangeId_ESMNSE,CMD::SourceId_ESMNSE);
  _userParams._priceType=1;
  _userParams._qty=1000;
  _userParams._side = API2::CONSTANTS::CMD_OrderMode_BUY;
  std::stringstream ss;
  _userParams.dump(ss, "Frontend Params:");
  DEBUG_MESSAGE(reqQryDebugLog(),ss.str().c_str());
  try{
    _Instrument = createNewInstrument(_userParams._symbolId,true,true);
    _orderWrapper = API2::COMMON::OrderWrapper(_Instrument,API2::DATA_TYPES::OrderMode(_userParams._side),API2::CONSTANTS::CMD_OrderType_LIMIT, this);
    return true;
  }
  catch(API2::MarketDataSubscriptionFailedException e)
  {
    DEBUG_VARSHOW(reqQryDebugLog(), "Exception occured", e.what());
    return false;
  }


}
コード例 #3
0
void API2::Test2::Context::onProcessOrderConfirmation(API2::OrderConfirmation &confirmation)
{
  DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__);
  DEBUG_MESSAGE(reqQryDebugLog(), getStrConfirmation(confirmation).c_str());
  _orderWrapper.processConfirmation(confirmation);

}
コード例 #4
0
void API2::Test2::Context::onFilled(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId *orderId)
{
  DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__ );

  DEBUG_MESSAGE(reqQryDebugLog(), "Order Filled, Terminating");
  reqAddStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_COMPLETED_SUCCESSFULLY);
  reqTerminateStrategy(false);
}
コード例 #5
0
 void TestContext::onFrozen(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId *orderId){
   if(orderId == _buyOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Buy Order Frozen-----");
     _buyOrderWrapper.processConfirmation(confirmation);
   }
   else if(orderId == _sellOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Sell Order Frozen-----");
     _sellOrderWrapper.processConfirmation(confirmation);
   }
 }
コード例 #6
0
 void TestContext::onReplaceRejected(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId* orderId){
   if(orderId == _buyOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Buy Order Replace Rejected-----");
     _buyOrderWrapper.processConfirmation(confirmation);
   }
   else if(orderId == _sellOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Sell Order Replace Rejected-----");
     _sellOrderWrapper.processConfirmation(confirmation);
   }
   processStrategyState();
 }
コード例 #7
0
 void TestContext::onPartialFill(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId* orderId){
   if(orderId == _buyOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Buy Order Partial Filled-----");
     _buyOrderWrapper.processConfirmation(confirmation);
     _buyTotalTradedLots += confirmation.getLastFillQuantity() / _biddingInstrument->getStaticData()->marketLot;
   }
   else if(orderId == _sellOrderWrapper._orderId)
   {
     DEBUG_MESSAGE(reqQryDebugLog(),"-----Sell Order Partial Filled-----");
     _sellOrderWrapper.processConfirmation(confirmation);
     _sellTotalTradedLots += confirmation.getLastFillQuantity() / _biddingInstrument->getStaticData()->marketLot;
   }
 }
コード例 #8
0
 void TestContext::terminateStrategy()
 {
   DEBUG_MESSAGE(reqQryDebugLog(),"Terminated From Front End");
   reqAddStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_COMPLETED_SUCCESSFULLY);
   reqTerminateStrategy();
   return;
 }
コード例 #9
0
 /**
  * Request from front end to terminate strategy
  */
 void TestContext::onCMDTerminateStartegy()
 {
   DEBUG_METHOD(reqQryDebugLog());
   _terminate = true;
   if(_terminate && !isAnyOrderPending())
     terminateStrategy();
   return;
 }
コード例 #10
0
 void TestContext::placeCancelOrder(API2::COMMON::OrderWrapper &wrapper)
 {
   // if order stands , then only we should go for its cancelation
   if( wrapper.getLastQuantity() )
   {
     // canceling order
     if( !wrapper.cancelOrder( _riskStatus ) )
     {
       // if risk failure comes
       DEBUG_MESSAGE( reqQryDebugLog(),"Order Cancel Failed" );
       wrapper._isPendingCancel = false;
       terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_RMS_FAILURE);
       return;
     }
     DEBUG_MESSAGE( reqQryDebugLog(),"Order Canceled" );
   }    
 }
コード例 #11
0
 void TestContext::dump(){
   /**
    * Params Dump
    */
   DEBUG_VARSHOW(reqQryDebugLog(),"Symbol Id : ",_userParams._symbolIdBidding);
   DEBUG_VARSHOW(reqQryDebugLog(),"Buy Order Lots : ",_userParams._buyOrderLots);
   DEBUG_VARSHOW(reqQryDebugLog(),"Buy Total Lots : ",_userParams._buyTotalLots);
   DEBUG_VARSHOW(reqQryDebugLog(),"Sell Order Lots : ",_userParams._sellOrderLots);
   DEBUG_VARSHOW(reqQryDebugLog(),"Sell Total Lots : ",_userParams._sellTotalLots);
   DEBUG_VARSHOW(reqQryDebugLog(),"Buy Price : ",_userParams._buyPrice);
   DEBUG_VARSHOW(reqQryDebugLog(),"Sell Price : ",_userParams._sellPrice);
   DEBUG_VARSHOW(reqQryDebugLog(),"Max Diff : ",_userParams._maxDiff);
 }
コード例 #12
0
  void TestContext::mapFrontEndValues(){
    DEBUG_METHOD(reqQryDebugLog());
    /**
     * Copying the modifiedParams structure to original structure
     */
    _userParams._buyOrderLots = _modUserParams._buyOrderLots;
    _userParams._sellOrderLots = _modUserParams._sellOrderLots;
    _userParams._buyTotalLots = _modUserParams._buyTotalLots;
    _userParams._sellTotalLots = _modUserParams._sellTotalLots;
    _userParams._buyPrice = _modUserParams._buyPrice;
    _userParams._sellPrice = _modUserParams._sellPrice;
    _userParams._maxDiff = _modUserParams._maxDiff;

  }
コード例 #13
0
void API2::Test2::Context::onMarketDataEvent(UNSIGNED_LONG symbolId)
{
  API2::DATA_TYPES::RiskStatus risk;

  //    DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__ );
  //    DEBUG_FLUSH(reqQryDebugLog());

  //    reqQryMarketData(symbolId)->dump();
  //    return;





  if(_orderWrapper._isReset)
  {
    DEBUG_MESSAGE(reqQryDebugLog(), "Sending New Order");

    if(!_orderWrapper.newOrder(risk,getPrice(),_userParams._qty))
    {
      DEBUG_VARSHOW(reqQryDebugLog(), "Failed Sending New Order, Reason:", risk);
      DEBUG_FLUSH(reqQryDebugLog());

      reqAddStrategyComment(API2::CONSTANTS::RSP_StrategyComment_RMS_FAILURE);
      reqTerminateStrategy();
    }
  }
  else
  {
    switch(reqQryOrderStatus(_orderWrapper._orderId))
    {
      case API2::CONSTANTS::RSP_OrderStatus_PENDING:
        return;
      case API2::CONSTANTS::RSP_OrderStatus_FILLED:
      case API2::CONSTANTS::RSP_OrderStatus_CANCELED:
        _orderWrapper.reset();
        onMarketDataEvent(symbolId);
        return;
      case API2::CONSTANTS::RSP_OrderStatus_CONFIRMED:
      case API2::CONSTANTS::RSP_OrderStatus_PARTIALLY_FILLED:
      case API2::CONSTANTS::RSP_OrderStatus_REPLACED:
        if(_orderWrapper.replaceOrder(risk,getPrice(),_userParams._qty)){
          DEBUG_MESSAGE(reqQryDebugLog(), "Sent Replace Order");
        }
        else{
          DEBUG_VARSHOW(reqQryDebugLog(), "Failed Replace Order, reason",risk);
        }


    }

  }

  DEBUG_FLUSH(reqQryDebugLog());

}
コード例 #14
0
ファイル: sample.cpp プロジェクト: IanMadlenya/muTradeApi2
    void SampleStrategy::sendReplaceOrder(DATA_TYPES::PRICE price, DATA_TYPES::QTY qty)
    {
//      DEBUG_METHOD(reqQryDebugLog());
      HFT_Start_Timer_Define;
      API2::DATA_TYPES::RiskStatus risk;
      if(_orderWrapper->replaceOrder(risk,price,qty))
        {
          HFT_Record_Timer(_LNReplaceOrder);
        }
      else
        {
          HFT_Record_Timer(_LNReplaceOrderReject);
          DEBUG_VARSHOW(reqQryDebugLog(), "Replace Order Rejected Internally, Exiting Strategy. Reject Reason:", risk);
//          reqTerminateStrategy(false);
        }
    }
コード例 #15
0
API2::Test2::Context::Context(API2::StrategyParameters *params):
  API2::SGContext(params, "CustomTest2"),
  _Instrument(NULL),
  _userParams()
{
  API2::UserParams *customOMMParams = (API2::UserParams *)params->getInfo();
  DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__ );

  customOMMParams->dump();
  if(!setInternalParameters(customOMMParams))
  {
    reqAddStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
    reqTerminateStrategy();
  }



}
コード例 #16
0
bool API2::Test2::Context::setInternalParameters(API2::UserParams *params)
{
#ifndef TESTING
  if(params->getValue("SYMBOL LEG1",_userParams._symbolId) != API2::UserParamsError_OK)
  {
    DEBUG_MESSAGE(reqQryDebugLog(), "Issue in SYMBOL LEG1");

    return false;
  }
  if(params->getValue("Order Mode 1",_userParams._side) != API2::UserParamsError_OK)
  {
    DEBUG_MESSAGE(reqQryDebugLog(), "Order Mode 1");

    return false;
  }
  if(params->getValue("Price Type",_userParams._priceType) != API2::UserParamsError_OK)
  {
    DEBUG_MESSAGE(reqQryDebugLog(), "issue in Price Type");

    return false;
  }
  if(params->getValue("Order Qty",_userParams._qty) != API2::UserParamsError_OK)
  {
    DEBUG_MESSAGE(reqQryDebugLog(), "issue in Qty");

    return false;
  }
#else
  setTestParameters();
#endif
  std::stringstream ss;
  _userParams.dump(ss, "Frontend Params:");
  DEBUG_MESSAGE(reqQryDebugLog(),ss.str().c_str());
  try{
    _Instrument = createNewInstrument(_userParams._symbolId,true,true);
    _orderWrapper = API2::COMMON::OrderWrapper(_Instrument,API2::DATA_TYPES::OrderMode(_userParams._side),API2::CONSTANTS::CMD_OrderType_LIMIT, this);
    return true;
  }
  catch(API2::MarketDataSubscriptionFailedException e)
  {
    DEBUG_VARSHOW(reqQryDebugLog(), "Exception occured", e.what());
    return false;
  }
  DEBUG_FLUSH(reqQryDebugLog());

}
コード例 #17
0
ファイル: sample.cpp プロジェクト: IanMadlenya/muTradeApi2
    void SampleStrategy::sendNewOrder(DATA_TYPES::PRICE price, DATA_TYPES::QTY qty)
    {
      API2::DATA_TYPES::RiskStatus risk;
      HFT_Start_Timer_Define;
      if(_orderWrapper->newOrder(risk,price,qty))
        {
          HFT_Record_Timer(_LNNewOrder);
        }
      else
        {
          HFT_Record_Timer(_LNNewOrderReject);
          DEBUG_VARSHOW(reqQryDebugLog(), "New Order Rejected Internally, Exiting Strategy. Reject Reason:", risk);
          //          _LNNewOrderReject.dumpDataSet();
          HFT_Start_Timer
              _orderWrapper->reset();
          HFT_Record_Timer(_LNResetOrder);
          //          reqTerminateStrategy(false);
        }

    }
コード例 #18
0
  void TestContext::setOrderWrapper()
  {
    /*
     * Creating instances of OrderWrapper here , to place or cancel orders through this instance
     */
    DEBUG_METHOD(reqQryDebugLog());
    API2::AccountDetail account;

    _buyOrderWrapper = API2::COMMON::OrderWrapper(
        _biddingInstrument,
        _buyOrder,
        this,
        account
        );

    _sellOrderWrapper = API2::COMMON::OrderWrapper(
        _biddingInstrument,
        _sellOrder,
        this,
        account
        );
  }
コード例 #19
0
  void TestContext::registerSymbols()
  {
    /*
     * Creating Instrument for Leg
     */
    DEBUG_METHOD(reqQryDebugLog());

    if((GET_EXCHANGE_ID(_userParams._symbolIdBidding) != API2::CONSTANTS::CMD_ExchangeId_NSECM ) &&
        (GET_EXCHANGE_ID(_userParams._symbolIdBidding) != API2::CONSTANTS::CMD_ExchangeId_NSEFO ) &&
        ( GET_EXCHANGE_ID(_userParams._symbolIdBidding)!= API2::CONSTANTS::CMD_ExchangeId_NSECDS))

      _biddingInstrument = createNewInstrument(_userParams._symbolIdBidding,true,true,false); 

    else
    {
      /** 
       * If Snapshot feed required for this instrument , pass third argument as true
       * false in case of TBT
       */
      _biddingInstrument = createNewInstrument(_userParams._symbolIdBidding,true,!_isTbtEnabled);
    }
  }
コード例 #20
0
 /**
  * Map the modified front end params to front end params
  */
 void TestContext::modifyStrategy(){
   DEBUG_METHOD(reqQryDebugLog());
   _modify = false;
   mapFrontEndValues();
   dump();
 }
コード例 #21
0
  /**
   * Places Orders
   */
  void TestContext::placeOrder(const API2::DATA_TYPES::OrderMode &orderMode)
  {
    DEBUG_METHOD(reqQryDebugLog());

    /**
     * If strategy has been requested for termination or modification,
     * need to return from here
     */
    if(_terminate || _modify)
      return;
    /**
     * If any order is pending
     * we need to return from here
     */
    if(isAnyOrderPending())
      return;
    /**
     * Buy Case
     */
    if(orderMode == API2::CONSTANTS::CMD_OrderMode_BUY)
    {
      API2::DATA_TYPES::QTY qty = std::min(_userParams._buyOrderLots,_userParams._buyTotalLots - _buyTotalTradedLots);
      API2::DATA_TYPES::PRICE price = _userParams._buyPrice;

      // price in terms of tick size
      // e.g if price is 200.07
      // converting it to 200.05
      price = price - (price % _buyOrderWrapper._instrument->getStaticData()->tickSize);

      qty *= _biddingInstrument->getStaticData()->marketLot;

      if( qty != 0 )
      qty += _buyOrderWrapper.getLastFilledQuantity();

      if(qty <= 0 || price <= 0)
      {
        placeCancelOrder( _buyOrderWrapper );
        return;
      }
      /**
       * getLastQuantity() returns the last quantity of which order was placed
       *
       * getLastQuotedPrice() returns the last price on which order was placed
       */

      if(qty == _buyOrderWrapper.getLastQuantity() &&
          price == _buyOrderWrapper.getLastQuotedPrice())
        return;

      /**
       * If getLastQuantity() returns a non zero ,
       * that means an order is already standing 
       * we can replace it
       */
      if(_buyOrderWrapper.getLastQuantity())
      {
        /**
         *replaces the existing order
         */
        if(!_buyOrderWrapper.replaceOrder(_riskStatus,price,qty))
        {
          /**
           * If replaceOrder returns false
           * RMS checks have been failed
           * Terminating strategy here
           */
          _buyOrderWrapper._isPendingReplace = false;
          DEBUG_MESSAGE(reqQryDebugLog()," Buy Could not be Replaced");
          terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
          return;
        }
        DEBUG_MESSAGE(reqQryDebugLog()," Buy Replaced");
      }
      else
      {
        /**
         *If getLastQuantity() returns 0
         * we need to reset orderWrapper(generate an new order structure and new common orderId)
         *
         */
        _buyOrderWrapper.reset();
        /**
         * places a new order
         */
        if(!_buyOrderWrapper.newOrder(_riskStatus,price,qty))
        {
          /**
           * If placeOrder returns false
           * RMS checks have been failed
           * Terminating strategy here
           */
          _buyOrderWrapper._isPendingNew = false;
          DEBUG_MESSAGE(reqQryDebugLog()," Buy Could not be Placed")
            terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
          return;
        }
        DEBUG_MESSAGE(reqQryDebugLog()," Buy Placed");
      }
    }
    /**
     * Sell Case
     */
    else if(orderMode == API2::CONSTANTS::CMD_OrderMode_SELL)
    {
      API2::DATA_TYPES::QTY qty = std::min(_userParams._sellOrderLots,_userParams._sellTotalLots - _sellTotalTradedLots);
      API2::DATA_TYPES::PRICE price = _userParams._sellPrice;

      // price in terms of tick size
      // e.g. if price is 300.02 , then converting it to 300.05
      SIGNED_LONG rem = price % _sellOrderWrapper._instrument->getStaticData()->tickSize;
      if(rem)
      {
        price = price + (_sellOrderWrapper._instrument->getStaticData()->tickSize - rem);
      }
      qty *= _biddingInstrument->getStaticData()->marketLot;
      
      if( qty != 0 )
      qty += _sellOrderWrapper.getLastFilledQuantity();

      if(qty <= 0 || price <= 0)
      {
        placeCancelOrder( _sellOrderWrapper );
        return;
      }

      if(qty == _sellOrderWrapper.getLastQuantity() &&
          price == _sellOrderWrapper.getLastQuotedPrice())
        return;

      if(_sellOrderWrapper.getLastQuantity())
      {
        if(!_sellOrderWrapper.replaceOrder(_riskStatus,price,qty))
        {
          _sellOrderWrapper._isPendingReplace = false;
          DEBUG_MESSAGE(reqQryDebugLog()," Sell Could not be Replaced");
          terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
          return;
        }
        DEBUG_MESSAGE(reqQryDebugLog()," Sell Replaced");
      }
      else
      {
        _sellOrderWrapper.reset();
        if(!_sellOrderWrapper.newOrder(_riskStatus,price,qty))
        {
          _buyOrderWrapper._isPendingNew = false;
          DEBUG_MESSAGE(reqQryDebugLog()," Sell Could not be Placed")
            terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
          return;
        }
        DEBUG_MESSAGE(reqQryDebugLog()," Sell Placed");
      }
    }
  }
コード例 #22
0
void API2::Test2::Context::onReplaced(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId *orderId)
{
  DEBUG_MESSAGE(reqQryDebugLog(), __PRETTY_FUNCTION__ );

}
コード例 #23
0
  TestContext::TestContext(API2::StrategyParameters *params):
    API2::SGContext(params,"Test_Strategy"),
    _riskStatus(API2::CONSTANTS::RSP_RiskStatus_MAX),
    _buyOrder(API2::CONSTANTS::CMD_OrderMode_BUY),
    _sellOrder(API2::CONSTANTS::CMD_OrderMode_SELL),
    _modify(false),
    _terminate(false),
    _isTbtEnabled(false),
    _buyTotalTradedLots(0),
    _sellTotalTradedLots(0)
  {
    /**
     * convert api paramaters into your own data structure
     */
    API2::UserParams* customParams = (API2::UserParams*) params->getInfo();
    if(!setInternalParameters(customParams))
    {
      DEBUG_MESSAGE(reqQryDebugLog(), "Front End Parameters Failed");
      terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_STRATEGY_ERROR_STATE);
      return;
    }
    /*
     *
     * register symbolids
     *          
     */
    try
    {
      registerSymbols();
    }
    catch(API2::MarketDataSubscriptionFailedException &e)
    {
      std::cout<<e.what()<<
        std::endl;
      DEBUG_MESSAGE(reqQryDebugLog(), "TBT Subscription Failed");
      terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_TBT_SUBSCRIPTION_FAILED);
      return;
    }
      catch(API2::InstrumentNotFoundException& e)
      {
        std::cout<<e.what()
          <<std::endl;
        std::cout << "TBT Subscription Failed, terminating strategy\n";
        DEBUG_MESSAGE(reqQryDebugLog(), "TBT Subscription Failed");
        terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_TBT_SUBSCRIPTION_FAILED);
        return;
      }
      catch(std::exception &e)
      {
        std::cout<<e.what()
          <<std::endl;
        std::cout << "TBT Subscription Failed, terminating strategy\n";
        DEBUG_MESSAGE(reqQryDebugLog(), "TBT Subscription Failed");
        terminateStrategyComment(API2::CONSTANTS::RSP_StrategyComment_TBT_SUBSCRIPTION_FAILED);
        return;
      }
    if(_terminate)
      return;

    setOrderWrapper();
    dump();
    reqTimerEvent(10000);
    DEBUG_FLUSH(reqQryDebugLog());
  }