xbmc/playlists/SmartPlayList.h

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #pragma once
  10
  11 #include "dbwrappers/DatabaseQuery.h"
  12 #include "utils/SortUtils.h"
  13 #include "utils/XBMCTinyXML.h"
  14
  15 #include <set>
  16 #include <string>
  17 #include <vector>
  18
  19 class CGUIDialogSmartPlaylistEditor;
  20 class CGUIDialogMediaFilter;
  21 class CURL;
  22 class CVariant;
  23
  24 namespace KODI::PLAYLIST
  25 {
  26
  27 class CSmartPlaylistRule : public CDatabaseQueryRule
  28 {
  29 public:
  30   CSmartPlaylistRule();
  31   ~CSmartPlaylistRule() override = default;
  32
  33   std::string GetLocalizedRule() const;
  34
  35   static SortBy TranslateOrder(const char *order);
  36   static std::string TranslateOrder(SortBy order);
  37   static Field TranslateGroup(const char *group);
  38   static std::string TranslateGroup(Field group);
  39
  40   static std::string GetLocalizedField(int field);
  41   static std::string GetLocalizedGroup(Field group);
  42   static bool CanGroupMix(Field group);
  43
  44   static std::vector<Field> GetFields(const std::string &type);
  45   static std::vector<SortBy> GetOrders(const std::string &type);
  46   static std::vector<Field> GetGroups(const std::string &type);
  47   FIELD_TYPE GetFieldType(int field) const override;
  48   static bool IsFieldBrowseable(int field);
  49
  50   static bool Validate(const std::string &input, void *data);
  51   static bool ValidateRating(const std::string &input, void *data);
  52   static bool ValidateMyRating(const std::string &input, void *data);
  53
  54 protected:
  55   std::string GetField(int field, const std::string& type) const override;
  56   int TranslateField(const char *field) const override;
  57   std::string TranslateField(int field) const override;
  58   std::string FormatParameter(const std::string &negate,
  59                               const std::string &oper,
  60                               const CDatabase &db,
  61                               const std::string &type) const override;
  62   std::string FormatWhereClause(const std::string &negate,
  63                                 const std::string& oper,
  64                                 const std::string &param,
  65                                 const CDatabase &db,
  66                                 const std::string &type) const override;
  67   SEARCH_OPERATOR GetOperator(const std::string &type) const override;
  68   std::string GetBooleanQuery(const std::string &negate,
  69                               const std::string &strType) const override;
  70
  71 private:
  72   std::string GetVideoResolutionQuery(const std::string &parameter) const;
  73   static std::string FormatLinkQuery(const char* field,
  74                                      const char* table,
  75                                      const MediaType& mediaType,
  76                                      const std::string& mediaField,
  77                                      const std::string& parameter);
  78   std::string FormatYearQuery(const std::string& field,
  79                               const std::string& param,
  80                               const std::string& parameter) const;
  81 };
  82
  83 class CSmartPlaylistRuleCombination : public CDatabaseQueryRuleCombination
  84 {
  85 public:
  86   CSmartPlaylistRuleCombination() = default;
  87   ~CSmartPlaylistRuleCombination() override = default;
  88
  89   std::string GetWhereClause(const CDatabase &db,
  90                              const std::string& strType,
  91                              std::set<std::string> &referencedPlaylists) const;
  92   void GetVirtualFolders(const std::string& strType,
  93                          std::vector<std::string> &virtualFolders) const;
  94
  95   void AddRule(const CSmartPlaylistRule &rule);
  96 };
  97
  98 class CSmartPlaylist : public IDatabaseQueryRuleFactory
  99 {
 100 public:
 101   CSmartPlaylist();
 102   ~CSmartPlaylist() override = default;
 103
 104   bool Load(const CURL& url);
 105   bool Load(const std::string &path);
 106   bool Load(const CVariant &obj);
 107   bool LoadFromXml(const std::string &xml);
 108   bool LoadFromJson(const std::string &json);
 109   bool Save(const std::string &path) const;
 110   bool Save(CVariant &obj, bool full = true) const;
 111   bool SaveAsJson(std::string &json, bool full = true) const;
 112
 113   bool OpenAndReadName(const CURL &url);
 114   bool LoadFromXML(const TiXmlNode *root, const std::string &encoding = "UTF-8");
 115
 116   void Reset();
 117
 118   void SetName(const std::string &name);
 119   void SetType(const std::string &type); // music, video, mixed
 120   const std::string& GetName() const { return m_playlistName; }
 121   const std::string& GetType() const { return m_playlistType; }
 122   bool IsVideoType() const;
 123   bool IsMusicType() const;
 124
 125   void SetMatchAllRules(bool matchAll)
 126   {
 127     m_ruleCombination.SetType(matchAll ? CSmartPlaylistRuleCombination::CombinationAnd
 128                                        : CSmartPlaylistRuleCombination::CombinationOr);
 129   }
 130
 131   bool GetMatchAllRules() const
 132   {
 133     return m_ruleCombination.GetType() == CSmartPlaylistRuleCombination::CombinationAnd;
 134   }
 135
 136   void SetLimit(unsigned int limit) { m_limit = limit; }
 137   unsigned int GetLimit() const { return m_limit; }
 138
 139   void SetOrder(SortBy order) { m_orderField = order; }
 140   SortBy GetOrder() const { return m_orderField; }
 141   void SetOrderAscending(bool orderAscending)
 142   {
 143     m_orderDirection = orderAscending ? SortOrderAscending : SortOrderDescending;
 144   }
 145   bool GetOrderAscending() const { return m_orderDirection != SortOrderDescending; }
 146   SortOrder GetOrderDirection() const { return m_orderDirection; }
 147   void SetOrderAttributes(SortAttribute attributes) { m_orderAttributes = attributes; }
 148   SortAttribute GetOrderAttributes() const { return m_orderAttributes; }
 149
 150   void SetGroup(const std::string &group) { m_group = group; }
 151   const std::string& GetGroup() const { return m_group; }
 152   void SetGroupMixed(bool mixed) { m_groupMixed = mixed; }
 153   bool IsGroupMixed() const { return m_groupMixed; }
 154
 155   /*! \brief get the where clause for a playlist
 156    We handle playlists inside playlists separately in order to ensure we don't introduce infinite loops
 157    by playlist A including playlist B which also (perhaps via other playlists) then includes playlistA.
 158
 159    \param db the database to use to format up results
 160    \param referencedPlaylists a set of playlists to know when we reach a cycle
 161    \param needWhere whether we need to prepend the where clause with "WHERE "
 162    */
 163   std::string GetWhereClause(const CDatabase &db, std::set<std::string> &referencedPlaylists) const;
 164   void GetVirtualFolders(std::vector<std::string> &virtualFolders) const;
 165
 166   std::string GetSaveLocation() const;
 167
 168   static void GetAvailableFields(const std::string &type, std::vector<std::string> &fieldList);
 169
 170   static bool IsVideoType(const std::string &type);
 171   static bool IsMusicType(const std::string &type);
 172   static bool CheckTypeCompatibility(const std::string &typeLeft, const std::string &typeRight);
 173
 174   bool IsEmpty(bool ignoreSortAndLimit = true) const;
 175
 176   // rule creation
 177   CDatabaseQueryRule *CreateRule() const override;
 178   CDatabaseQueryRuleCombination *CreateCombination() const override;
 179
 180 private:
 181   friend class ::CGUIDialogSmartPlaylistEditor;
 182   friend class ::CGUIDialogMediaFilter;
 183
 184   const TiXmlNode* readName(const TiXmlNode *root);
 185   const TiXmlNode* readNameFromPath(const CURL &url);
 186   const TiXmlNode* readNameFromXml(const std::string &xml);
 187   bool load(const TiXmlNode *root);
 188
 189   CSmartPlaylistRuleCombination m_ruleCombination;
 190   std::string m_playlistName;
 191   std::string m_playlistType;
 192
 193   // order information
 194   unsigned int m_limit;
 195   SortBy m_orderField;
 196   SortOrder m_orderDirection;
 197   SortAttribute m_orderAttributes;
 198   std::string m_group;
 199   bool m_groupMixed;
 200
 201   CXBMCTinyXML m_xmlDoc;
 202 };
 203
 204 } // namespace KODI::PLAYLIST