http_lib_connection.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2023 Andre F. K. Iwers <[email protected]>
 * 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/>.
 */
 
#pragma once
 
#include <any>
#include <boost/algorithm/string.hpp>
#include <functional>
#include <json_common.h>
#include <mutex>
 
#include "http_lib/http_lib_settings.h"
#include <kicad_curl/kicad_curl_easy.h>
 
extern const char* const traceHTTPLib;
 

bool setPartExtendedData( const nlohmann::json& aPartJson, HTTP_LIB_PART& aPart );
 
 
class HTTP_LIB_CONNECTION
{
public:
    using RETRIEVER = std::function<bool( const std::string& aUrl, int& aStatusCode,
                                          std::string& aBody, std::string& aError )>;
 
    HTTP_LIB_CONNECTION( const HTTP_LIB_SOURCE& aSource, bool aTestConnectionNow );
 
    HTTP_LIB_CONNECTION( const HTTP_LIB_SOURCE& aSource, bool aTestConnectionNow, RETRIEVER aRetriever );
 
    virtual ~HTTP_LIB_CONNECTION() = default;
 
    bool IsValidEndpoint() const { return m_endpointValid; }

    bool SelectOne( const std::string& aPartID, HTTP_LIB_PART& aFetchedPart );

    bool SelectAll( const HTTP_LIB_CATEGORY& aCategory, std::vector<HTTP_LIB_PART>& aParts );
 
    std::string GetLastError() const
    {
        std::lock_guard lock( m_queryMutex );
        return m_lastError;
    }
 
    std::vector<HTTP_LIB_CATEGORY> getCategories() const
    {
        std::lock_guard lock( m_queryMutex );
        return m_categories;
    }
 
    std::string getCategoryDescription( const std::string& aCategoryName ) const
    {
        std::lock_guard lock( m_queryMutex );
 
        if( m_categoryDescriptions.contains( aCategoryName ) )
            return m_categoryDescriptions.at( aCategoryName );
 
        return "";
    }
 
    bool HasCachedParts() const
    {
        std::lock_guard lock( m_queryMutex );
        return !m_cache.empty();
    }

    bool GetCachedPartRelation( const std::string& aPartName, std::string& aPartId, std::string& aCategoryId ) const
    {
        std::lock_guard lock( m_queryMutex );
 
        auto it = m_cache.find( aPartName );
 
        if( it == m_cache.end() )
            return false;
 
        aPartId = std::get<0>( it->second );
        aCategoryId = std::get<1>( it->second );
        return true;
    }
 
    void ClearPartCache()
    {
        std::lock_guard lock( m_queryMutex );
        m_cachedParts.clear();
        m_cache.clear();
    }
 
private:
    bool validateHttpLibraryEndpoints();
 
    bool syncCategories();

    bool retrieve( const std::string& aUrl, int& aStatusCode, std::string& aBody );
 
    bool checkServerResponse( int aStatusCode );

    wxString httpErrorCodeDescription( uint16_t aHttpCode );
 
private:
    mutable std::mutex m_queryMutex;
 
    HTTP_LIB_SOURCE m_source;
    RETRIEVER       m_retriever;
    bool            m_endpointValid = false;
    std::string     m_lastError;
 
    std::vector<HTTP_LIB_CATEGORY>     m_categories;
    std::map<std::string, std::string> m_categoryDescriptions;
    std::map<std::string, std::string> m_parts;
 
    //          part.id     part
    std::map<std::string, HTTP_LIB_PART> m_cachedParts;
 
    //        part.name               part.id     category.id
    std::map<std::string, std::tuple<std::string, std::string>> m_cache;
};