search.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "basejob.hpp"
#include "csapi/definitions/room_event_filter.hpp"
 
namespace Kazv::Api {
 
class SearchJob : public BaseJob {
public:
  // Inner data structures
 
    struct IncludeEventContext
        {
          std::optional<int> beforeLimit;
          std::optional<int> afterLimit;
          std::optional<bool> includeProfile;
        
        };
 
    struct Group
        {
          std::optional<std::string> key;
        
        };
 
    struct Groupings
        {
          immer::array<Group> groupBy;
        
        };
 
    struct RoomEventsCriteria
        {
          std::string searchTerm;
          immer::array<std::string> keys;
          RoomEventFilter filter;
          std::optional<std::string> orderBy;
          std::optional<IncludeEventContext> eventContext;
          std::optional<bool> includeState;
          std::optional<Groupings> groupings;
        
        };
 
    struct Categories
        {
          std::optional<RoomEventsCriteria> roomEvents;
        
        };
 
    struct UserProfile
        {
          std::optional<std::string> displayname;
          std::optional<std::string> avatarUrl;
        
        };
 
    struct EventContext
        {
          std::optional<std::string> start;
          std::optional<std::string> end;
          immer::map<std::string, UserProfile> profileInfo;
          EventList eventsBefore;
          EventList eventsAfter;
        
        };
 
    struct Result
        {
          std::optional<double> rank;
          JsonWrap result;
          std::optional<EventContext> context;
        
        };
 
    struct GroupValue
        {
          std::optional<std::string> nextBatch;
          std::optional<int> order;
          immer::array<std::string> results;
        
        };
 
    struct ResultRoomEvents
        {
          std::optional<int> count;
          immer::array<std::string> highlights;
          immer::array<Result> results;
          immer::map<std::string, EventList> state;
          immer::map<std::string, immer::map<std::string, GroupValue>> groups;
          std::optional<std::string> nextBatch;
        
        };
 
    struct ResultCategories
        {
          std::optional<ResultRoomEvents> roomEvents;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
ResultCategories searchCategories() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit SearchJob(std::string serverUrl
    , std::string _accessToken
      ,
        Categories searchCategories , std::optional<std::string> nextBatch  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    std::optional<std::string> nextBatch);
 
      static BaseJob::Body buildBody(Categories searchCategories, std::optional<std::string> nextBatch);
 
        
 
        
 
      SearchJob withData(JsonWrap j) &&;
      SearchJob withData(JsonWrap j) const &;
      };
      using SearchResponse = SearchJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<SearchJob::IncludeEventContext> {
 
  static void to_json(json& jo, const SearchJob::IncludeEventContext &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "before_limit"s, pod.beforeLimit);
    
    addToJsonIfNeeded(jo, "after_limit"s, pod.afterLimit);
    
    addToJsonIfNeeded(jo, "include_profile"s, pod.includeProfile);
  }
 
  static void from_json(const json &jo, SearchJob::IncludeEventContext& result)
  {
  
    if (jo.contains("before_limit"s)) {
      result.beforeLimit = jo.at("before_limit"s);
    }
    if (jo.contains("after_limit"s)) {
      result.afterLimit = jo.at("after_limit"s);
    }
    if (jo.contains("include_profile"s)) {
      result.includeProfile = jo.at("include_profile"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::Group> {
 
  static void to_json(json& jo, const SearchJob::Group &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "key"s, pod.key);
  }
 
  static void from_json(const json &jo, SearchJob::Group& result)
  {
  
    if (jo.contains("key"s)) {
      result.key = jo.at("key"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::Groupings> {
 
  static void to_json(json& jo, const SearchJob::Groupings &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "group_by"s, pod.groupBy);
  }
 
  static void from_json(const json &jo, SearchJob::Groupings& result)
  {
  
    if (jo.contains("group_by"s)) {
      result.groupBy = jo.at("group_by"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::RoomEventsCriteria> {
 
  static void to_json(json& jo, const SearchJob::RoomEventsCriteria &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["search_term"s] = pod.searchTerm;
    
    
    addToJsonIfNeeded(jo, "keys"s, pod.keys);
    
    addToJsonIfNeeded(jo, "filter"s, pod.filter);
    
    addToJsonIfNeeded(jo, "order_by"s, pod.orderBy);
    
    addToJsonIfNeeded(jo, "event_context"s, pod.eventContext);
    
    addToJsonIfNeeded(jo, "include_state"s, pod.includeState);
    
    addToJsonIfNeeded(jo, "groupings"s, pod.groupings);
  }
 
  static void from_json(const json &jo, SearchJob::RoomEventsCriteria& result)
  {
  
    if (jo.contains("search_term"s)) {
      result.searchTerm = jo.at("search_term"s);
    }
    if (jo.contains("keys"s)) {
      result.keys = jo.at("keys"s);
    }
    if (jo.contains("filter"s)) {
      result.filter = jo.at("filter"s);
    }
    if (jo.contains("order_by"s)) {
      result.orderBy = jo.at("order_by"s);
    }
    if (jo.contains("event_context"s)) {
      result.eventContext = jo.at("event_context"s);
    }
    if (jo.contains("include_state"s)) {
      result.includeState = jo.at("include_state"s);
    }
    if (jo.contains("groupings"s)) {
      result.groupings = jo.at("groupings"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::Categories> {
 
  static void to_json(json& jo, const SearchJob::Categories &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "room_events"s, pod.roomEvents);
  }
 
  static void from_json(const json &jo, SearchJob::Categories& result)
  {
  
    if (jo.contains("room_events"s)) {
      result.roomEvents = jo.at("room_events"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::UserProfile> {
 
  static void to_json(json& jo, const SearchJob::UserProfile &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "displayname"s, pod.displayname);
    
    addToJsonIfNeeded(jo, "avatar_url"s, pod.avatarUrl);
  }
 
  static void from_json(const json &jo, SearchJob::UserProfile& result)
  {
  
    if (jo.contains("displayname"s)) {
      result.displayname = jo.at("displayname"s);
    }
    if (jo.contains("avatar_url"s)) {
      result.avatarUrl = jo.at("avatar_url"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::EventContext> {
 
  static void to_json(json& jo, const SearchJob::EventContext &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "start"s, pod.start);
    
    addToJsonIfNeeded(jo, "end"s, pod.end);
    
    addToJsonIfNeeded(jo, "profile_info"s, pod.profileInfo);
    
    addToJsonIfNeeded(jo, "events_before"s, pod.eventsBefore);
    
    addToJsonIfNeeded(jo, "events_after"s, pod.eventsAfter);
  }
 
  static void from_json(const json &jo, SearchJob::EventContext& result)
  {
  
    if (jo.contains("start"s)) {
      result.start = jo.at("start"s);
    }
    if (jo.contains("end"s)) {
      result.end = jo.at("end"s);
    }
    if (jo.contains("profile_info"s)) {
      result.profileInfo = jo.at("profile_info"s);
    }
    if (jo.contains("events_before"s)) {
      result.eventsBefore = jo.at("events_before"s);
    }
    if (jo.contains("events_after"s)) {
      result.eventsAfter = jo.at("events_after"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::Result> {
 
  static void to_json(json& jo, const SearchJob::Result &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "rank"s, pod.rank);
    
    addToJsonIfNeeded(jo, "result"s, pod.result);
    
    addToJsonIfNeeded(jo, "context"s, pod.context);
  }
 
  static void from_json(const json &jo, SearchJob::Result& result)
  {
  
    if (jo.contains("rank"s)) {
      result.rank = jo.at("rank"s);
    }
    if (jo.contains("result"s)) {
      result.result = jo.at("result"s);
    }
    if (jo.contains("context"s)) {
      result.context = jo.at("context"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::GroupValue> {
 
  static void to_json(json& jo, const SearchJob::GroupValue &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "next_batch"s, pod.nextBatch);
    
    addToJsonIfNeeded(jo, "order"s, pod.order);
    
    addToJsonIfNeeded(jo, "results"s, pod.results);
  }
 
  static void from_json(const json &jo, SearchJob::GroupValue& result)
  {
  
    if (jo.contains("next_batch"s)) {
      result.nextBatch = jo.at("next_batch"s);
    }
    if (jo.contains("order"s)) {
      result.order = jo.at("order"s);
    }
    if (jo.contains("results"s)) {
      result.results = jo.at("results"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::ResultRoomEvents> {
 
  static void to_json(json& jo, const SearchJob::ResultRoomEvents &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "count"s, pod.count);
    
    addToJsonIfNeeded(jo, "highlights"s, pod.highlights);
    
    addToJsonIfNeeded(jo, "results"s, pod.results);
    
    addToJsonIfNeeded(jo, "state"s, pod.state);
    
    addToJsonIfNeeded(jo, "groups"s, pod.groups);
    
    addToJsonIfNeeded(jo, "next_batch"s, pod.nextBatch);
  }
 
  static void from_json(const json &jo, SearchJob::ResultRoomEvents& result)
  {
  
    if (jo.contains("count"s)) {
      result.count = jo.at("count"s);
    }
    if (jo.contains("highlights"s)) {
      result.highlights = jo.at("highlights"s);
    }
    if (jo.contains("results"s)) {
      result.results = jo.at("results"s);
    }
    if (jo.contains("state"s)) {
      result.state = jo.at("state"s);
    }
    if (jo.contains("groups"s)) {
      result.groups = jo.at("groups"s);
    }
    if (jo.contains("next_batch"s)) {
      result.nextBatch = jo.at("next_batch"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SearchJob::ResultCategories> {
 
  static void to_json(json& jo, const SearchJob::ResultCategories &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "room_events"s, pod.roomEvents);
  }
 
  static void from_json(const json &jo, SearchJob::ResultCategories& result)
  {
  
    if (jo.contains("room_events"s)) {
      result.roomEvents = jo.at("room_events"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api