GroupFilter.h

/*
     Copyright © CloudBackend AB 2020 - 2022..
*/
 
#ifndef INCLUDE_CBE_GROUPFILTER_H_
#define INCLUDE_CBE_GROUPFILTER_H_
 
#include <string>
#include <map>
 
#include "CBE/Types.h"
#include <vector>
 
 
namespace CBE {
 
  class GroupFilter {
 
    public:
      
      std::string getQuery() const;
      std::string getFilter() const;
      
      bool getAscending() const;
      bool getDeleted() const;
      bool getPublicFirst() const;
      
      uint32_t getOffset() const;
      
      uint32_t getCount() const;
      
      std::string getOrder() const;
      
      CBE::FilterOrder getGroupOrder() const;
      
      void setQuery(std::string);
      
      void setFilter(std::string);
 
      void setAscending(bool);
 
      void setDeleted(bool);
      
      void setOffset(uint32_t);
      
      void setCount(uint32_t);
      
      void setGroupOrder(FilterOrder o);
 
 
      
      // Used Internally, do not use or change.
      bool matchesGroupId(uint64_t id);
      bool matchesQuery(uint64_t parentId, CBE::application_t type, bool isDeleted);
      bool matchesQuery(CBE::GroupPtr group);
      bool equals(GroupFilter filter);
      void updateCompareValue();
      std::string order() const;
      void order(std::string o);
 
    protected:
 
      static std::vector<std::string> _approvedOrder;
      std::map<FilterOrder, std::string> orderStrings = {
                              { FilterOrder::Title, "title"},
                              { FilterOrder::Published, "published"},
                              { FilterOrder::Updated, "updated"},
                              { FilterOrder::Length, "length"},
                              { FilterOrder::S1, "s1"},
                              { FilterOrder::S2, "s2"},
                              { FilterOrder::S3, "s3"},
                              { FilterOrder::S4, "s4"}
                              };
      uint32_t offset;
      uint32_t count;
      bool ascending;
      bool deleted;
      bool publicFirst;
      std::string query;
      std::string _order;
      std::string _compareValue{""};
      std::string filter{""};
      bool bypassCache{false};
      void parseQueryString();
      CBE::application_t applicationType{CBE::ApplicationType::Open};
 
      struct Term {
      std::string modifier{""};
      std::string prefix{""};
      std::string str{""};
      };
      
      std::vector<Term> _parsedQueryString = {};
      std::vector<CBE::group_id_t> _groupIds = {};
    
    
  };
}
 
#endif // INCLUDE_CBE_GROUPFILTER_H_