kite.hpp

/*
 *  Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 *  SPDX-License-Identifier: MIT
 *
 *  Copyright (c) 2020-2022 Bhumit Attarde
 *
 *  Permission is hereby  granted, free of charge, to any  person obtaining a
 * copy of this software and associated  documentation files (the "Software"),
 * to deal in the Software  without restriction, including without  limitation
 * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
 * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom the
 * Software  is furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
 * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
 * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
 * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
 * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "cpp-httplib/httplib.h"
 
#include "responses/responses.hpp"
#include "utils.hpp"
 
namespace kiteconnect {
 
using std::string;
namespace kc = kiteconnect;
namespace utils = kc::internal::utils;
 
class kite {
 
  public:
    explicit kite(string apikey);
 
    // api
 
    void setApiKey(const string& arg);
 
    string getApiKey() const;
 
    string loginURL() const;
 
    void setAccessToken(const string& arg);
 
    string getAccessToken() const;
 
    userSession generateSession(
        const string& requestToken, const string& apiSecret);
 
    bool invalidateSession();
 
    // user
 
    userProfile profile();
 
    allMargins getMargins();
 
    margins getMargins(const string& segment);
 
    // orders
 
    string placeOrder(const placeOrderParams& params);
 
    string modifyOrder(const modifyOrderParams& params);
 
    string cancelOrder(const string& variety, const string& orderId,
        const string& parentOrderId = "");
 
    std::vector<order> orders();
 
    std::vector<order> orderHistory(const string& orderId);
 
    std::vector<trade> trades();
 
    std::vector<trade> orderTrades(const string& orderId);
 
    // gtt
 
    int placeGtt(const placeGttParams& params);
 
    std::vector<GTT> triggers();
 
    GTT getGtt(int triggerId);
 
    int modifyGtt(const kc::modifyGttParams& params);
 
    int deleteGtt(int triggerId);
 
    // portfolio
 
    std::vector<holding> holdings();
 
    positions getPositions();
 
    bool convertPosition(const convertPositionParams& params);
 
    // market
 
    std::vector<instrument> getInstruments(const string& exchange = "");
 
    std::unordered_map<string, quote> getQuote(
        const std::vector<string>& symbols);
 
    std::unordered_map<string, ohlcQuote> getOhlc(
        const std::vector<string>& symbols);
 
    std::unordered_map<string, ltpQuote> getLtp(
        const std::vector<string>& symbols);
 
    std::vector<historicalData> getHistoricalData(
        const historicalDataParams& params);
 
    // MF
 
    string placeMfOrder(const placeMfOrderParams& params);
 
    string cancelMfOrder(const string& orderId);
 
    std::vector<mfOrder> getMfOrders();
 
    mfOrder getMfOrder(const string& orderId);
 
    std::vector<mfHolding> getMfHoldings();
 
    placeMfSipResponse placeMfSip(const placeMfSipParams& params);
 
    string modifyMfSip(const modifyMfSipParams& params);
 
    string cancelMfSip(const string& sipId);
 
    std::vector<mfSip> getSips();
 
    mfSip getSip(const string& sipId);
 
    std::vector<mfInstrument> getMfInstruments();
 
    // margins
 
    std::vector<orderMargins> getOrderMargins(
        const std::vector<marginsParams>& params);
 
    basketMargins getBasketMargins(
        const std::vector<marginsParams>& params, bool considerPositions);
 
  private:
    static string encodeSymbolsList(const std::vector<string>& symbols);
 
    string getAuth() const;
 
    template <class Res, class Data, bool UseCustomParser = false>
    inline Res callApi(const string& service,
        const utils::http::Params& body = {},
        const utils::FmtArgs& fmtArgs = {},
        utils::json::CustomParser<Res, Data, UseCustomParser>
            customParser = {});
 
    const string version = "3";
    const string root = "https://api.kite.trade";
    const string loginUrlFmt =
        "https://kite.zerodha.com/connect/login?v=3&api_key={api_key}";
    const std::unordered_map<string, utils::http::endpoint> endpoints {
        // api
        { "api.token", { utils::http::METHOD::POST, "/session/token" } },
        { "api.token.invalidate",
            { utils::http::METHOD::DEL,
                "/session/token?api_key={0}&access_token={1}" } },
        // user
        { "user.profile", { utils::http::METHOD::GET, "/user/profile" } },
        { "user.margins", { utils::http::METHOD::GET, "/user/margins" } },
        { "user.margins.segment",
            { utils::http::METHOD::GET, "/user/margins/{0}" } },
        // order
        { "order.info", { utils::http::METHOD::GET, "/orders/{0}" } },
        { "order.place", { utils::http::METHOD::POST, "/orders/{0}" } },
        { "order.modify", { utils::http::METHOD::PUT, "/orders/{0}/{1}" } },
        { "order.cancel", { utils::http::METHOD::DEL, "/orders/{0}/{1}" } },
        { "order.cancel.bo", { utils::http::METHOD::DEL,
                                 "/orders/{0}/{1}?parent_order_id={1}" } },
        { "order.trades", { utils::http::METHOD::GET, "/orders/{0}/trades" } },
        { "orders", { utils::http::METHOD::GET, "/orders" } },
        { "trades", { utils::http::METHOD::GET, "/trades" } },
        // gtt
        { "gtt", { utils::http::METHOD::GET, "/gtt/triggers" } },
        { "gtt.place", { utils::http::METHOD::POST, "/gtt/triggers" } },
        { "gtt.info", { utils::http::METHOD::GET, "/gtt/triggers/{0}" } },
        { "gtt.modify", { utils::http::METHOD::PUT, "/gtt/triggers/{0}" } },
        { "gtt.delete", { utils::http::METHOD::DEL, "/gtt/triggers/{0}" } },
        // mf
        { "mf.orders", { utils::http::METHOD::GET, "/mf/orders" } },
        { "mf.order.info", { utils::http::METHOD::GET, "/mf/orders/{0}" } },
        { "mf.order.place", { utils::http::METHOD::POST, "/mf/orders" } },
        { "mf.order.cancel", { utils::http::METHOD::DEL, "/mf/orders/{0}" } },
        { "mf.holdings", { utils::http::METHOD::GET, "/mf/holdings" } },
        { "mf.instruments", { utils::http::METHOD::GET, "/mf/instruments",
                                utils::http::CONTENT_TYPE::NON_JSON,
                                utils::http::CONTENT_TYPE::NON_JSON } },
        { "mf.sips", { utils::http::METHOD::GET, "/mf/sips" } },
        { "mf.sip.info", { utils::http::METHOD::GET, "/mf/sips/{0}" } },
        { "mf.sip.place", { utils::http::METHOD::POST, "/mf/sips" } },
        { "mf.sip.modify", { utils::http::METHOD::PUT, "/mf/sips/{0}" } },
        { "mf.sip.cancel", { utils::http::METHOD::DEL, "/mf/sips/{0}" } },
        // portfolio
        { "portfolio.holdings",
            { utils::http::METHOD::GET, "/portfolio/holdings" } },
        { "portfolio.positions",
            { utils::http::METHOD::GET, "/portfolio/positions" } },
        { "portfolio.positions.convert",
            { utils::http::METHOD::PUT, "/portfolio/positions" } },
        // market
        { "market.instruments.all", { utils::http::METHOD::GET, "/instruments",
                                        utils::http::CONTENT_TYPE::NON_JSON,
                                        utils::http::CONTENT_TYPE::NON_JSON } },
        { "market.instruments", { utils::http::METHOD::GET, "/instruments/{0}",
                                    utils::http::CONTENT_TYPE::NON_JSON,
                                    utils::http::CONTENT_TYPE::NON_JSON } },
        { "market.margins", { utils::http::METHOD::GET, "/margins/{0}" } },
        { "market.historical",
            { utils::http::METHOD::GET,
                "/instruments/historical/{0}/"
                "{1}?from={2}&to={3}&continuous={4}&oi={5}" } },
        { "market.trigger_range",
            { utils::http::METHOD::GET, "/instruments/trigger_range/{9}" } },
        { "market.quote", { utils::http::METHOD::GET, "/quote?{0}" } },
        { "market.quote.ohlc",
            { utils::http::METHOD::GET, "/quote/ohlc?{0}" } },
        { "market.quote.ltp", { utils::http::METHOD::GET, "/quote/ltp?{0}" } },
        // margins
        { "margins.orders", { utils::http::METHOD::POST, "/margins/orders",
                                utils::http::CONTENT_TYPE::JSON } },
        { "margins.basket", { utils::http::METHOD::POST,
                                "/margins/basket?consider_positions={0}",
                                utils::http::CONTENT_TYPE::JSON } },
    };
    string key;
    string token;
    string authorization;
    httplib::Client client;
 
  protected:
#ifdef KITE_UNIT_TEST
    virtual utils::http::response sendReq(const utils::http::endpoint& endpoint,
        const utils::http::Params& body, const utils::FmtArgs& fmtArgs);
#else
    utils::http::response sendReq(const utils::http::endpoint& endpoint,
        const utils::http::Params& body, const utils::FmtArgs& fmtArgs);
#endif
};
 
} // namespace kiteconnect