AddonDatabase.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "XBDateTime.h"
#include "addons/AddonVersion.h"
#include "dbwrappers/Database.h"

#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>

class CVariant;

namespace ADDON
{

enum class AddonDisabledReason;
enum class AddonUpdateRule;

class CAddonExtensions;
class CAddonInfoBuilderFromDB;

class CAddonInfo;
using AddonInfoPtr = std::shared_ptr<CAddonInfo>;

class IAddon;
using AddonPtr = std::shared_ptr<IAddon>;
using VECADDONS = std::vector<AddonPtr>;

class CAddonDatabaseSerializer
{
  CAddonDatabaseSerializer() = delete;

public:
  static std::string SerializeMetadata(const CAddonInfo& addon);
  static void DeserializeMetadata(const std::string& document, CAddonInfoBuilderFromDB& builder);

private:
  static CVariant SerializeExtensions(const CAddonExtensions& addonType);
  static void DeserializeExtensions(const CVariant& document, CAddonExtensions& addonType);
};

class CAddonDatabase : public CDatabase
{
public:
  CAddonDatabase();
  ~CAddonDatabase() override;
  bool Open() override;

  bool GetAddon(const std::string& addonID,
                const ADDON::CAddonVersion& version,
                const std::string& repoId,
                ADDON::AddonPtr& addon);

  bool GetDisabled(std::map<std::string, ADDON::AddonDisabledReason>& addons);

  bool FindByAddonId(const std::string& addonId, ADDON::VECADDONS& addons) const;

  bool UpdateRepositoryContent(const std::string& repositoryId,
                               const ADDON::CAddonVersion& version,
                               const std::string& checksum,
                               const std::vector<AddonInfoPtr>& addons);

  int GetRepoChecksum(const std::string& id, std::string& checksum);

  bool GetRepositoryContent(const std::string& id, ADDON::VECADDONS& addons) const;

  bool GetRepositoryContent(ADDON::VECADDONS& addons) const;

  struct RepoUpdateData
  {
    CDateTime lastCheckedAt;
    ADDON::CAddonVersion lastCheckedVersion{""};
    CDateTime nextCheckAt;

    RepoUpdateData() = default;

    RepoUpdateData(const CDateTime& lastCheckedAt,
                   const ADDON::CAddonVersion& lastCheckedVersion,
                   const CDateTime& nextCheckAt)
      : lastCheckedAt{lastCheckedAt},
        lastCheckedVersion{lastCheckedVersion},
        nextCheckAt{nextCheckAt}
    {
    }
  };

  int SetRepoUpdateData(const std::string& id, const RepoUpdateData& updateData);

  RepoUpdateData GetRepoUpdateData(const std::string& id);

  bool Search(const std::string& search, ADDON::VECADDONS& items);

  bool DisableAddon(const std::string& addonID, ADDON::AddonDisabledReason disabledReason);

  bool EnableAddon(const std::string& addonID);

  bool AddUpdateRuleForAddon(const std::string& addonID, ADDON::AddonUpdateRule updateRule);

  bool RemoveAllUpdateRulesForAddon(const std::string& addonID);

  bool RemoveUpdateRuleForAddon(const std::string& addonID, AddonUpdateRule updateRule);

  bool GetAddonUpdateRules(std::map<std::string, std::vector<AddonUpdateRule>>& rulesMap) const;

  bool AddPackage(const std::string& addonID,
                  const std::string& packageFileName,
                  const std::string& hash);
  bool GetPackageHash(const std::string& addonID,
                      const std::string& packageFileName,
                      std::string&       hash);
  bool RemovePackage(const std::string& packageFileName);

  void OnPostUnInstall(const std::string& addonId);

  void SyncInstalled(const std::set<std::string>& ids,
                     const std::set<std::string>& system,
                     const std::set<std::string>& optional);

  bool SetLastUpdated(const std::string& addonId, const CDateTime& dateTime);
  bool SetOrigin(const std::string& addonId, const std::string& origin);
  bool SetLastUsed(const std::string& addonId, const CDateTime& dateTime);

  void GetInstallData(const ADDON::AddonInfoPtr& addon);

  bool AddInstalledAddon(const std::shared_ptr<CAddonInfo>& addon, const std::string& origin);

protected:
  void CreateTables() override;
  void CreateAnalytics() override;
  void UpdateTables(int version) override;
  int GetMinSchemaVersion() const override;
  int GetSchemaVersion() const override;
  const char *GetBaseDBName() const override { return "Addons"; }

  bool GetAddon(int id, ADDON::AddonPtr& addon);
  void DeleteRepository(const std::string& id);
  void DeleteRepositoryContents(const std::string& id);
  int GetRepositoryId(const std::string& addonId);
};

}; // namespace ADDON