pcm.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2021 Andrew Lutsenko, anlutsenko at gmail dot com
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef PCM_H_
#define PCM_H_
 
#include "core/wx_stl_compat.h"
#include "pcm_data.h"
#include <json_schema_validator.h>
#include "widgets/wx_progress_reporters.h"
#include <functional>
#include <iostream>
#include <map>
 
#include <thread>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <wx/wx.h>
 

const std::unordered_set<wxString> PCM_PACKAGE_DIRECTORIES( {
        "plugins",
        "footprints",
        "3dmodels",
        "symbols",
        "resources",
        "colors",
        "templates",
        "scripts",
        "design_blocks"
} );
 

enum PCM_PACKAGE_STATE
{
    PPS_AVAILABLE = 0,
    PPS_UNAVAILABLE = 1,
    PPS_INSTALLED = 2,
    PPS_PENDING_INSTALL = 3,
    PPS_PENDING_UNINSTALL = 4,
    PPS_UPDATE_AVAILABLE = 5,
    PPS_PENDING_UPDATE = 6,
};
 

enum PCM_PACKAGE_ACTION
{
    PPA_INSTALL = 0,
    PPA_UNINSTALL = 1,
    PPA_UPDATE = 2,
};
 
 
typedef std::vector<std::pair<wxString, wxString>>            STRING_PAIR_LIST;
typedef std::vector<std::tuple<wxString, wxString, wxString>> STRING_TUPLE_LIST;
 
 
struct BACKGROUND_JOB;
class DIALOG_PCM;
 

class PLUGIN_CONTENT_MANAGER
{
public:
    PLUGIN_CONTENT_MANAGER( std::function<void( int )> aAvailableUpdateCallbac );
    ~PLUGIN_CONTENT_MANAGER();

    void SaveInstalledPackages();

    bool FetchRepository( const wxString& aUrl, PCM_REPOSITORY& aRepository,
                          PROGRESS_REPORTER* aReporter );

    void ValidateJson( const nlohmann::json&     aJson,
                       const nlohmann::json_uri& aUri = nlohmann::json_uri( "#" ) ) const;

    void ValidateJson( const nlohmann::json&          aJson,
                       const JSON_SCHEMA_VALIDATOR&    aValidator,
                       const nlohmann::json_uri&       aUri ) const;

    bool VerifyHash( std::istream& aStream, const wxString& aHash ) const;

    void SetRepositoryList( const STRING_PAIR_LIST& aRepositories );

    void DiscardRepositoryCache( const wxString& aRepositoryId );
    void DiscardAllRepositoryCaches();

    void MarkInstalled( const PCM_PACKAGE& aPackage, const wxString& aVersion,
                        const wxString& aRepositoryId );

    void MarkUninstalled( const PCM_PACKAGE& aPackage );

    const STRING_TUPLE_LIST& GetRepositoryList() const { return m_repository_list; }

    bool CacheRepository( const wxString& aRepositoryId );

    const std::vector<PCM_PACKAGE>& GetRepositoryPackages( const wxString& aRepositoryId ) const;

    const std::vector<PCM_INSTALLATION_ENTRY> GetInstalledPackages() const;

    const wxString& GetInstalledPackageVersion( const wxString& aPackageId ) const;

    const wxString& Get3rdPartyPath() const { return m_3rdparty_path; };

    PCM_PACKAGE_STATE GetPackageState( const wxString& aRepositoryId, const wxString& aPackageId );

    static wxString ResolveRepositoryId( const wxString& aPackageId, const wxString& aRecordedName,
                                         const STRING_TUPLE_LIST& aRepositoryList,
                                         const std::unordered_map<wxString, PCM_REPOSITORY>& aCache );

    void ResolveInstalledPackageRepositories();

    static bool UsesSWIGRuntime( const PCM_PACKAGE& aPackage, const wxString& aVersion );

    bool IsPackagePinned( const wxString& aPackageId ) const;

    void SetPinned( const wxString& aPackageId, const bool aPinned );

    const wxString GetPackageUpdateVersion( const PCM_PACKAGE& aPackage );

    bool DownloadToStream( const wxString& aUrl, std::ostream* aOutput,
                           PROGRESS_REPORTER* aReporter,
                           const size_t       aSizeLimit = DEFAULT_DOWNLOAD_MEM_LIMIT,
                           const std::string& aAccept = "" );

    int GetPackageSearchRank( const PCM_PACKAGE& aPackage, const wxString& aSearchTerm );

    std::unordered_map<wxString, wxBitmap>
    GetRepositoryPackageBitmaps( const wxString& aRepositoryId );

    std::unordered_map<wxString, wxBitmap> GetInstalledPackageBitmaps();

    void SetDialogWindow( DIALOG_PCM* aDialog ) { m_dialog = aDialog; };

    void RunBackgroundUpdate();

    void StopBackgroundUpdate();

    void ReadEnvVar();

    static void PreparePackage( PCM_PACKAGE& aPackage );
 
    void ShowApiEnablePromptIfNeeded();
 
private:
    static constexpr size_t DEFAULT_DOWNLOAD_MEM_LIMIT = 10 * 1024 * 1024;

    bool fetchPackages( const wxString& aUrl, const std::optional<wxString>& aHash,
                        std::vector<PCM_PACKAGE>& aPackages, PROGRESS_REPORTER* aReporter,
                        int aSchemaVersion = 1 );

    STRING_TUPLE_LIST::const_iterator findRepository( const wxString& aRepositoryId ) const;

    const PCM_REPOSITORY& getCachedRepository( const wxString& aRepositoryId ) const;

    bool resolveInstalledPackageRepository( PCM_INSTALLATION_ENTRY& aEntry );

    void updateInstalledPackagesMetadata( const wxString& aRepositoryId );

    time_t getCurrentTimestamp() const;
 
    DIALOG_PCM*                                  m_dialog;
    std::unique_ptr<JSON_SCHEMA_VALIDATOR>       m_schema_v1_validator;
    std::unique_ptr<JSON_SCHEMA_VALIDATOR>       m_schema_v2_validator;
    wxString                                     m_3rdparty_path;
    wxString                                     m_cache_path;
    std::unordered_map<wxString, PCM_REPOSITORY> m_repository_cache;
    STRING_TUPLE_LIST                            m_repository_list; // (id, name, url) tuples
 
    // Using sorted map to keep order of entries in installed list stable
    std::map<wxString, PCM_INSTALLATION_ENTRY> m_installed;
    const static std::tuple<int, int, int>     m_kicad_version;
    std::function<void( int )>                 m_availableUpdateCallback;
    std::thread                                m_updateThread;
 
    std::shared_ptr<BACKGROUND_JOB>              m_updateBackgroundJob;
    bool                                         m_apiEnablePromptNeeded;
};
 
#endif // PCM_H_