deploy_api_service.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 iFunFactory Inc. All Rights Reserved.
//
// This work is confidential and proprietary to iFunFactory Inc. and
// must not be used, disclosed, copied, or distributed without the prior
// consent of iFunFactory Inc.

#ifndef INCLUDE_FUNAPI_MANAGEMENT_DEPLOY_API_SERVICE_H_
#define INCLUDE_FUNAPI_MANAGEMENT_DEPLOY_API_SERVICE_H_


#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/regex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>

#include <funapi/network/http_util.h>
#include <funapi/time/wall_clock.h>
#include <funapi/types.h>

#include <string>
#include <vector>

namespace fun {

class Json;

// HTTP response writers
struct FUNAPI_DLL_VISIBILITY ResponseWriter : private boost::noncopyable {
  virtual ~ResponseWriter();
};


struct FUNAPI_DLL_VISIBILITY VoidResponseWriter : public ResponseWriter {
  // Writes HTTP response with given status code
  virtual void Write(const fun::http::StatusCode code) = 0;
};


template<typename T>
struct ResponseWriterT : public ResponseWriter {
  // Writes HTTP status code and result of type `T' to HTTP response
  virtual void Write(const fun::http::StatusCode code, T *result) = 0;
};


typedef ResponseWriterT<fun::Json> JsonResponseWriter;
typedef ResponseWriterT<bool> BoolResponseWriter;
typedef ResponseWriterT<std::vector<std::string> > StringVectorResponseWriter;
typedef ResponseWriterT<std::vector<fun::Json> > JsonVectorResponseWriter;


class FUNAPI_DLL_VISIBILITY DeployApiService : public boost::noncopyable {
 // Interface class for iFunDeploy APIs
 // 아이펀 디플로이를 위한 인터페이스 클래스
 // https://docs.ifun-deploy.com/
 public:
  enum MissionPeriod {
    kMissionPeriodDaily = 0,
    kMissionPeriodWeekly = 1,
    kMissionPeriodMonthly = 2,
  };

  enum MissionType {
    kMissionTypeNormal = 0,
    kMissionTypeAchievement = 1,
  };

  struct FUNAPI_DLL_VISIBILITY PageInfo {
    // NOTE: {0, 0} means that paging is disabled.
    uint32_t page_no;  // page number; starts from 1
    uint32_t page_size;  // number of entries for a single page

    PageInfo();
  };

  struct FUNAPI_DLL_VISIBILITY DeployApiHandlerBase
      : private boost::noncopyable {
    struct BanUserErrorInfo;
    struct UnbanUserErrorInfo;
    struct NoticeMessage;

    typedef ResponseWriterT<std::vector<BanUserErrorInfo> >
        BanUsersResponseWriter;
    typedef ResponseWriterT<std::vector<UnbanUserErrorInfo> >
        UnbanUsersResponseWriter;

    virtual ~DeployApiHandlerBase();

    // Should return searchable condition list for accounts
    virtual void GetUserSearchConditions(
        const Ptr<StringVectorResponseWriter> &writer) const;

    // Searches account for a given condition
    virtual void SearchUsers(
        const std::string &condition_name,
        const std::string &condition_value,
        const PageInfo &page_info,
        const Ptr<JsonVectorResponseWriter> &writer) const;

    // Returns user data as JSON for user identified by "id".
    // In case of failure, should pass appropritate HTTP status code.
    virtual void GetUser(
        const std::string &id,
        const Ptr<JsonResponseWriter> &writer) const;

    // PUT /v1/cs-api/account/<id>/<field>/<value>
    virtual void UpdateUser(
        const std::string &id,
        const std::string &field,
        const std::string &value,
        const Ptr<VoidResponseWriter> &writer) const;

    // Returns connection status for the account as string
    virtual void IsLoggedIn(
        const std::string &key,
        const Ptr<BoolResponseWriter> &writer) const;

    // Forces user to be logged-out
    virtual void ForceLogout(
        const std::string &id,
        const Ptr<VoidResponseWriter> &writer) const;

    // User ban
    // {
    struct FUNAPI_DLL_VISIBILITY BanUserErrorInfo {
      std::string id;
      std::string description;
    };

    struct FUNAPI_DLL_VISIBILITY UnbanUserErrorInfo {
      std::string id;
      std::string description;
    };

    virtual void GetUserBanned(
        const std::string &key,
        const Ptr<BoolResponseWriter> &writer) const;

    DEPRECATED(virtual void BanUser(
        const std::string &key, const Ptr<VoidResponseWriter> &writer) const);

    virtual void BanUsers(
        const std::vector<std::string> &user_ids,
        const Ptr<BanUsersResponseWriter> &writer) const;

    DEPRECATED(virtual void UnbanUser(
        const std::string &key, const Ptr<VoidResponseWriter> &writer) const);

    virtual void UnbanUsers(
        const std::vector<std::string> &user_ids,
        const Ptr<UnbanUsersResponseWriter> &writer) const;
    // }

    // Characters API
    // {
    virtual void GetCharacters(
        const std::string &user_id,
        const Ptr<JsonVectorResponseWriter> &writer) const;

    virtual void GetCharacter(
        const std::string &character_id,
        const Ptr<JsonResponseWriter> &writer) const;

    virtual void UpdateCharacter(
        const std::string &character_id,
        const std::string &field,
        const std::string &value,
        const Ptr<VoidResponseWriter> &writer) const;

    // vector of (inventory type, vector of inventory id)
    typedef std::vector<std::pair<std::string, std::vector<std::string> > >
        InventoryInfo;
    virtual void GetCharacterInventoryInfo(
        const std::string &character_id,
        const Ptr<ResponseWriterT<InventoryInfo> > &writer) const;

    // result should be JSON array, which holds item data
    virtual void GetInventory(
        const std::string &type,
        const std::string &inventory_id,
        const PageInfo &page_info,
        const Ptr<JsonVectorResponseWriter> &writer) const;

    // iFunDeploy expects there are `expected_item_quantity` items for item_id.
    // In this function, one should decrease the quantity of item
    // by `quantity_to_reclaim`.
    virtual void DeleteInventoryItem(
        const std::string &inventory_type,
        const std::string &inventory_id,
        const std::string &item_id,
        const int64_t expected_item_quantity,
        const int64_t quantity_to_reclaim,
        const Ptr<VoidResponseWriter> &writer) const;

    struct FUNAPI_DLL_VISIBILITY ReclaimInfo {
      struct FUNAPI_DLL_VISIBILITY ReclaimedItem {
        std::string item_id;
        int64_t expected_item_quantity;  // expected quantity of the item
        int64_t quantity_to_reclaim;  // # of items to be decreased
      };

      std::string inventory_type;
      std::string inventory_id;
      std::vector<ReclaimedItem> reclaimed;
    };

    virtual void DeleteMultipleInventoryItems(
        const std::vector<ReclaimInfo> &reclaimed,
        const Ptr<VoidResponseWriter> &writer) const;

    // send gift to specific users
    virtual void GiveGift(
        const std::string &target_type,  // target type; (account or character)
        const std::string &title,  // title of the gift message
        const std::string &content,  // body of the gift message
        const fun::WallClock::Value &expires,  // expiration time for the gift
        const std::vector<std::pair<std::string, uint64_t> > &items,
        const std::vector<std::string> &users,  // recipients
        const Ptr<VoidResponseWriter> &writer) const;

    // send gift to all the users
    virtual void GiveGiftToAll(
        const std::string &target_type,  // target type; (account or character)
        const std::string &title,  // title of the gift message
        const std::string &content,  // body of the gift message
        const fun::WallClock::Value &expires,  // expiration time for the gift
        const std::vector<std::pair<std::string, uint64_t> > &items,
        const Ptr<VoidResponseWriter> &writer) const;
    // }

    // 2019-04
    // refund the payment.
    // See https://docs.ifun-deploy.com/api.html#api-basic-payment
    virtual void Refund(
        const std::string &receipt_id,
        const fun::Json &purchase_log,
        const Ptr<VoidResponseWriter> &writer) const;

    // realtime notice
    struct FUNAPI_DLL_VISIBILITY NoticeMessage {
      std::string language_code;
      std::string message;
    };
    virtual void SendRealtimeNotice(
        const std::string &category,
        const std::string &color,
        const std::vector<NoticeMessage> &messages,
        const Ptr<VoidResponseWriter> &writer) const;

    // {
    // mission API
    virtual void GetCharacterPeriodicMissionStatus(
        const std::string &character_id,
        MissionPeriod period,
        const fun::WallClock::Value &start_date,
        const PageInfo &page_info,
        const Ptr<JsonVectorResponseWriter> &writer) const;

    // category, search condition/keyword는 빈 값일 수 있으며 이 경우는
    // 해당 값으로 필터링 하지 말아야 한다.
    //
    // category, search_condition and/or search_keyword can be empty.
    // In that case, you shall not filter mission list by that criterion.
    virtual void GetCharacterMissionStatus(
        const std::string &character_id,
        MissionType mission_type,  // normal or achievement
        const std::string &category,  // can be empty
        const std::string &search_condition,  // can be empty
        const std::string &search_keryword,   // can be empty
        bool is_completed,  // completed && rewarded
        const PageInfo &page_info,
        const Ptr<JsonVectorResponseWriter> &writer) const;
    // }
   protected:
    DeployApiHandlerBase();  // Never instantiate DeployApiHandlerBase
  };

  // Restrict editable fields for user, character
  static bool SetEditableFieldsForUser(
      const std::vector<std::string> &field_list);
  static bool SetEditableFieldsForCharacter(
      const std::vector<std::string> &field_list);

  // Restrict items which could be sent to user as a gift.
  // item_list should be vector of (item-id, item-name) pairs.
  static bool SetGiftableItems(
      const std::vector<std::pair<std::string, std::string> > &item_list);

  // Specify additional realtime notice categories.
  // NOTE: By default, "chat" and "screen" are included.
  static bool SetRealtimeNoticeCategory(
      const std::vector<std::string> &category);

  // Mission
  static bool SetMissionCategory(
      const std::vector<std::string> &normal_mission_category,
      const std::vector<std::string> &achievement_mission_category);

  // Event API
  // {
  struct FUNAPI_DLL_VISIBILITY CampaignRewardSchema {
    enum ValueType {
      //int, float, string
      VT_INT = 0,  // int64_t
      VT_FLOAT = 1,  // double
      VT_STRING = 2,  // std::string
    };

    std::string id;  // identifier to distinguish rewards in single campaign
    std::string name;  // display name; can be empty string.
    ValueType value_type;
  };

  struct FUNAPI_DLL_VISIBILITY Campaign {
    std::string name;
    std::vector<CampaignRewardSchema> reward_schemas;
  };

  // Arguments passed from iFun Deploy to campaign.
  // 아이펀 디플로이에서 캠페인 콜백에게 전달하는 인자.
  struct FUNAPI_DLL_VISIBILITY CampaignArgument {
    std::string name;
    std::string description;

    // Arguments will be parsed as specified in CampaignRewardSchema.
    // 각 인자는 CampaignRewardSchema 에 지정한 타입으로 파싱합니다.
    //    VT_INT: int64_t
    //    VT_DOUBLE: double
    //    VT_STRING: string
    typedef boost::variant<int64_t, double, std::string> Value;

    // list of named pairs. (reward)
    // 보상에 해당하는 이름, 값 쌍 목록.
    std::vector<std::pair<std::string, Value> > values;

    fun::WallClock::Value begin_ts;
    fun::WallClock::Value end_ts;

    bool is_recurring;  // is recurring event (or not).  반복 이벤트인지 여부.

    // For recurring campaign (반복 이벤트)
    struct FUNAPI_DLL_VISIBILITY RecurringSchedule {
      // day of week for the campaign (0 = Sun, 1 = Mon, ...)
      // 이벤트에 해당하는 요일 (0 = 일, 1 = 월, ...)
      std::vector<boost::date_time::weekdays> days_of_the_week;

      int32_t begin_ts_of_day;  // 0 .. 86400 (in timezone)
      int32_t end_ts_of_day;  // 0 .. 86400 (in timezone)

      std::string timezone;  // timezone in tz database (eg. Asia/Seoul)
    } recurring_schedule;
  };

  typedef boost::function<bool (const Campaign & /*data*/,
      const std::string & /*type*/, const std::string & /*id*/,
      const CampaignArgument & /*arg*/)> BeginCampaignCallback;

  typedef boost::function<bool (const Campaign & /*campaign_type*/,
      const std::string & /*type*/, const std::string & /*id*/)>
    EndCampaignCallback;

  typedef boost::function<bool (const Campaign &campaign_type,
      const std::string &type, const std::string &id)>
    CancelCampaignCallback;

  static bool RegisterCampaignType(const std::string &campaign_id,
                                   const Campaign &campaign);
  // called when the campaign begins
  static void RegisterBeginCampaignCallback(const BeginCampaignCallback &cb);

  // called when the campaign ends
  static void RegisterEndCampaignCallback(const EndCampaignCallback &cb);

  // called when the campaign is canceled
  static void RegisterCancelCampaignCallback(const CancelCampaignCallback &cb);
  // }

  // You should pass handler as subclass of DeployApiHandlerBase.
  // If you pass DeployApiHandlerBase as handler, it will terminate execution.
  template <typename T>
  static void RegisterDeployApiHandler(boost::shared_ptr<T> handler);

  struct FUNAPI_DLL_VISIBILITY ExtraData : boost::noncopyable {
    static Ptr<ExtraData> Create();
    virtual ~ExtraData();

    // Export as JSON, which can be passed as `extra_data` argument
    // for RegisterCustomQueryHandler.
    virtual fun::Json Export() const = 0;

    // Create dropdown list for parameter `name`.
    // It would make iFunDeploy UI to use select box.
    virtual bool SetDropdownList(
        const std::string &name, const std::vector<std::string> &values) = 0;

   protected:
    ExtraData();
  };

  // Takes second JSON object as argument (which should be passed in HTTP
  // request body), then write response to writer function.
  // Handler may write non-200 status code to indicate the error.
  //    (If the json body is not set, iFuEngine will set the JSON body as
  //     {"error": "error string for http status code"}.)
  // The first argument is used to indicate paging.
  typedef boost::function<void (
        const PageInfo & /*page_info*/,
        const fun::Json & /*request*/,
        Ptr<JsonResponseWriter> & /*response writer*/)> CustomApiHandler;

  // Register a handler for iFunDeploy custom query
  static void RegisterCustomQueryHandler(
      const std::string &name,  // display name
      const http::Method &method,  // HTTP verb
      const std::string &uri,  // URI (MUST NOT include regex)
      // JSON attributes which should be provided by JSON request body
      const std::vector<std::string> &request_fields,
      // JSON attributes which should be placed in JSON response
      // (for successful response)
      const std::vector<std::string> &response_fields,
      const CustomApiHandler &handler,
      // Optional data which can be used by iFunDeploy to provide
      // addtional UI component or functionality.
      const Ptr<ExtraData> &extra_data);

  static void RegisterCustomQueryHandler(
      const std::string &name,  // display name
      const http::Method &method,  // HTTP verb
      const std::string &uri,  // URI (MUST NOT include regex)
      // JSON attributes which should be provided by JSON request body
      const std::vector<std::string> &request_fields,
      // JSON attributes which should be placed in JSON response
      // (for successful response)
      const std::vector<std::string> &response_fields,
      const CustomApiHandler &handler,
      // Optional data which can be used by iFunDeploy to provide
      // addtional UI component or functionality.
      // You may use alternative RegisterCustomQueryHandler
      // with ExtraData API.
      const fun::Json &extra_data=fun::Json());

 private:
  static void _AddImplementedHandler(const std::string &account_handler_name);
  static void _DoRegister(boost::shared_ptr<DeployApiHandlerBase> handler);
};


typedef DeployApiService::DeployApiHandlerBase::BanUsersResponseWriter
    BanUsersResponseWriter;

typedef DeployApiService::DeployApiHandlerBase::UnbanUsersResponseWriter
    UnbanUsersResponseWriter;


namespace detail {

#define HAS_MEMBER_FUNCTION(NAME, ARGS) \
template <typename T> \
class Has ## NAME { \
private: \
  typedef char Yes; \
  typedef Yes No[2]; \
\
  template <typename U, U> struct Same; \
  template <typename C> static Yes& Test(Same< \
      void (C::*)ARGS const, &C:: NAME>*); \
  template <typename> static No& Test(...); \
\
public: \
    static bool const value = sizeof(Test<T>(0)) == sizeof(Yes); \
}


#define CHECK_MEMBER_FUNCTION(NAME) \
  if (detail::Has ## NAME<T>::value) { _AddImplementedHandler(#NAME); }


HAS_MEMBER_FUNCTION(GetUserSearchConditions,
    (const Ptr<StringVectorResponseWriter>&));
HAS_MEMBER_FUNCTION(SearchUsers,
    (const std::string&, const std::string&, const DeployApiService::PageInfo&,
     const Ptr<JsonVectorResponseWriter>&));
HAS_MEMBER_FUNCTION(GetUser,
    (const std::string&, const Ptr<JsonResponseWriter>&));
HAS_MEMBER_FUNCTION(UpdateUser,
    (const std::string&, const std::string&, const std::string&,
     const Ptr<VoidResponseWriter>&));
HAS_MEMBER_FUNCTION(IsLoggedIn,
    (const std::string&, const Ptr<BoolResponseWriter>&));
HAS_MEMBER_FUNCTION(ForceLogout,
    (const std::string&, const Ptr<VoidResponseWriter>&));

HAS_MEMBER_FUNCTION(GetUserBanned,
    (const std::string&, const Ptr<BoolResponseWriter>&));
HAS_MEMBER_FUNCTION(BanUser,
    (const std::string&, const Ptr<VoidResponseWriter>&));
HAS_MEMBER_FUNCTION(BanUsers,
    (const std::vector<std::string>&,
     const Ptr<BanUsersResponseWriter>&));
HAS_MEMBER_FUNCTION(UnbanUser,
    (const std::string&, const Ptr<VoidResponseWriter>&));
HAS_MEMBER_FUNCTION(UnbanUsers,
    (const std::vector<std::string>&,
     const Ptr<UnbanUsersResponseWriter>&));

HAS_MEMBER_FUNCTION(GetCharacters,
    (const std::string &, const Ptr<JsonVectorResponseWriter>&));
HAS_MEMBER_FUNCTION(GetCharacter,
    (const std::string &, const Ptr<JsonResponseWriter>&));
HAS_MEMBER_FUNCTION(UpdateCharacter,
    (const std::string&, const std::string&, const std::string&,
     const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(GiveGift,
    (const std::string&, const std::string&, const std::string&,
     const fun::WallClock::Value&,
     const std::vector<std::pair<std::string, uint64_t> >&,
     const std::vector<std::string>&,
     const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(GiveGiftToAll,
    (const std::string&, const std::string&,
     const fun::WallClock::Value&,
     const std::vector<std::pair<std::string, uint64_t> >&,
     const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(GetCharacterInventoryInfo,
    (const std::string &,
     const Ptr<ResponseWriterT<
        DeployApiService::DeployApiHandlerBase::InventoryInfo> >&));
HAS_MEMBER_FUNCTION(GetInventory,
    (const std::string&, const std::string &,
     const DeployApiService::PageInfo&,
     const Ptr<JsonVectorResponseWriter>&));
HAS_MEMBER_FUNCTION(DeleteInventoryItem,
    (const std::string&, const std::string&, const std::string &,
     const int64_t, const int64_t, const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(DeleteMultipleInventoryItems,
    (const std::vector<DeployApiService::DeployApiHandlerBase::ReclaimInfo> &,
     const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(Refund,
    (const std::string &, const fun::Json &, const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(SendRealtimeNotice,
    (const std::string &,
     const std::string &,
     const std::vector<DeployApiService::DeployApiHandlerBase::NoticeMessage>&,
     const Ptr<VoidResponseWriter> &));
HAS_MEMBER_FUNCTION(GetCharacterPeriodicMissionStatus,
    (const std::string &, DeployApiService::MissionPeriod,
     const fun::WallClock::Value &, const DeployApiService::PageInfo &,
     const Ptr<JsonVectorResponseWriter> &));
HAS_MEMBER_FUNCTION(GetCharacterMissionStatus,
    (const std::string &, DeployApiService::MissionType, const std::string &,
     const std::string &, const std::string &, bool,
     const DeployApiService::PageInfo &,
     const Ptr<JsonVectorResponseWriter> &));

}  // namespace detail

// NOTE: You MUST NOT call this specialized function.
template <>
void DeployApiService::RegisterDeployApiHandler<
    DeployApiService::DeployApiHandlerBase>(
        boost::shared_ptr<DeployApiService::DeployApiHandlerBase> handler);


template <typename T>
void DeployApiService::RegisterDeployApiHandler(boost::shared_ptr<T> handler) {
  CHECK_MEMBER_FUNCTION(GetUserSearchConditions);
  CHECK_MEMBER_FUNCTION(SearchUsers);

  CHECK_MEMBER_FUNCTION(GetUser);
  CHECK_MEMBER_FUNCTION(UpdateUser);
  CHECK_MEMBER_FUNCTION(IsLoggedIn);
  CHECK_MEMBER_FUNCTION(ForceLogout);

  CHECK_MEMBER_FUNCTION(GetUserBanned);
  CHECK_MEMBER_FUNCTION(BanUser);
  CHECK_MEMBER_FUNCTION(BanUsers);
  CHECK_MEMBER_FUNCTION(UnbanUser);
  CHECK_MEMBER_FUNCTION(UnbanUsers);

  CHECK_MEMBER_FUNCTION(GetCharacters);
  CHECK_MEMBER_FUNCTION(GetCharacter);
  CHECK_MEMBER_FUNCTION(UpdateCharacter);
  CHECK_MEMBER_FUNCTION(GiveGift);
  if (not detail::HasGiveGift<T>::value) {
    CHECK_MEMBER_FUNCTION(GiveGiftToAll);
  }
  CHECK_MEMBER_FUNCTION(GetCharacterInventoryInfo);
  CHECK_MEMBER_FUNCTION(GetInventory);
  CHECK_MEMBER_FUNCTION(DeleteInventoryItem);
  CHECK_MEMBER_FUNCTION(DeleteMultipleInventoryItems);

  CHECK_MEMBER_FUNCTION(Refund);
  CHECK_MEMBER_FUNCTION(SendRealtimeNotice);

  CHECK_MEMBER_FUNCTION(GetCharacterPeriodicMissionStatus);
  CHECK_MEMBER_FUNCTION(GetCharacterMissionStatus);

  _DoRegister(static_cast<boost::shared_ptr<DeployApiHandlerBase> >(handler));
}

}  // namespace fun

#endif  // INCLUDE_FUNAPI_MANAGEMENT_DEPLOY_API_SERVICE_H_