eansearch.cpp

/*
 * A C++ class for EAN and ISBN name lookup and validation using the API on ean-search.org
 * https://www.ean-search.org/ean-database-api.html
 * 
 * (c) 2025 Relaxed Communications GmBH, <info@relaxedcommunications.com>
 * 
 * License: MIT https://opensource.org/license/mit
*/

#include "eansearch.hpp"
#include <iostream>
#include <thread>
#include <chrono>
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/json/src.hpp>
#include <boost/json.hpp>

using namespace std;

namespace beast = boost::beast; // from <boost/beast.hpp>
namespace http = beast::http;   // from <boost/beast/http.hpp>
namespace net = boost::asio;    // from <boost/asio.hpp>
namespace json = boost::json;   // from <boost/json.hpp>
namespace ssl = net::ssl;       // from <boost/asio/ssl.hpp>
using tcp = net::ip::tcp;       // from <boost/asio/ip/tcp.hpp>

void DeleteProductList(ProductList * pl) {
    if (pl) {
        for (auto p : *pl) {
            delete p;
        }
        delete pl;
    }
}

static Product * ProductFromJSON(const json::value & api_result) {
    Product * p = nullptr;
    auto json_product = api_result.if_object();
    if (json_product) {
        if (json_product->if_contains("googleCategoryId")) {
            p = new ProductFull();
            auto * pf = static_cast<ProductFull *>(p);
            pf->googleCategoryId = stoi(json_product->at("googleCategoryId").as_string().c_str());
        } else {
            p = new Product();
        }
        p->ean = json_product->at("ean").as_string();
        p->name = json_product->at("name").as_string();
        p->categoryId = stoi(json_product->at("categoryId").as_string().c_str());
        p->categoryName = json_product->at("categoryName").as_string();
        p->issuingCountry = json_product->at("issuingCountry").as_string();
    }
    return p;
}

EANSearch::EANSearch(const string & token) {
    this->token = token;
	this->remaining = -1;
}

ProductFull * EANSearch::BarcodeLookup(const string & ean, int language)
{
    string result;
    if (APICall("op=barcode-lookup&ean=" + ean + "&language=" + to_string(language), result)) {
        auto api_result = json::parse(result);
        ProductFull * p = dynamic_cast<ProductFull *>(ProductFromJSON(api_result.at(0)));
        return p;
    } else {
        return nullptr;
    }
}

ProductFull * EANSearch::IsbnLookup(const string & isbn)
{
    string result;
    if (APICall("op=barcode-lookup&isbn=" + isbn, result)) {
        auto api_result = json::parse(result);
        ProductFull * p = dynamic_cast<ProductFull *>(ProductFromJSON(api_result.at(0)));
        return p;
    } else {
        return nullptr;
    }
}

bool EANSearch::VerifyChecksum(const string & ean)
{
    string result;
    if (APICall("op=verify-checksum&ean=" + ean, result)) {
        auto api_result = json::parse(result);
        return (api_result.at(0).at("valid").as_string() == "1");
    } else {
        return false;
    }
}

ProductList * EANSearch::ProductSearch(const string & name, int only_language, int page)
{
    string result;
    if (APICall("op=product-search&name=" + urlencode(name) + "&language=" + to_string(only_language) + "&page=" + to_string(page), result)) {
        return ParseProductList(result);
    }
    return nullptr;
}

ProductList * EANSearch::SimilarProductSearch(const string & name, int only_language, int page)
{
    string result;
    if (APICall("op=similar-product-search&name=" + urlencode(name) + "&language=" + to_string(only_language) + "&page=" + to_string(page), result)) {
        return ParseProductList(result);
    }
    return nullptr;
}

ProductList * EANSearch::CategorySearch(int category, const string & name, int only_language, int page)
{
    string result;
    if (APICall("op=category-search&category=" + to_string(category) + "&name=" + urlencode(name)
                + "&language=" + to_string(only_language) + "&page=" + to_string(page), result)) {
        return ParseProductList(result);
    }
    return nullptr;
}

ProductList * EANSearch::BarcodePrefixSearch(const string & prefix, int language, int page)
{
    string result;
    if (APICall("op=barcode-prefix-search&prefix=" + prefix
                + "&language=" + to_string(language) + "&page=" + to_string(page), result)) {
        return ParseProductList(result);
    }
    return nullptr;
}

string EANSearch::IssuingCountryLookup(const string & ean)
{
    string result;
    if (APICall("op=issuing-country&ean=" + ean, result)) {
        error_code ec;
        auto api_result = json::parse(result, ec);
        return api_result.at(0).at("issuingCountry").as_string().c_str();
    } else {
        return "";
    }
}

string EANSearch::BarcodeImage(const string & ean, int width, int height)
{
    string result;
    if (APICall("op=barcode-image&ean=" + ean + "&width=" + to_string(width) + "&height=" + to_string(height), result)) {
        auto api_result = json::parse(result);
        return api_result.at(0).at("barcode").as_string().c_str();
    } else {
        return "";
    }
}

int EANSearch::CreditsRemaining()
{
    string result;
	if (remaining < 0) {
		if (!APICall("op=account-status", result)) {
			return -1;
		}
	}
	return remaining;
}

/**
 * @brief Perform a synchronous HTTPS GET request to the API.
 * @param params Query parameters (without token/format).
 * @param result Output parameter that receives the raw JSON response body.
 * @return true on success, false on network/SSL/parse error.
 */
bool EANSearch::APICall(const string & params, string & output, int tries)
{
    auto const host = "api.ean-search.org";
    auto const port = "443";
    auto const version = 11;
    string target = "/api?" + params + "&token=" + this->token + "&format=json";

    try {
        net::io_context ioc;
        ssl::context ctx(ssl::context::tlsv12_client);
        tcp::resolver resolver(ioc);
        ssl::stream<beast::tcp_stream> stream(ioc, ctx);
        if (!SSL_set_tlsext_host_name(stream.native_handle(), host)) { // set SNI
            boost::system::error_code ec{static_cast<int>(::ERR_get_error()), boost::asio::error::get_ssl_category()};
            throw boost::system::system_error{ec};
        }
        stream.set_verify_callback(ssl::host_name_verification(host));
        auto const results = resolver.resolve(host, port);
        beast::get_lowest_layer(stream).connect(results);
        stream.handshake(ssl::stream_base::client);
        http::request<http::string_body> req{http::verb::get, target, version};
        req.set(http::field::host, host);
        req.set(http::field::user_agent, "cpp-eansearch/1.0");
        http::write(stream, req);
        beast::flat_buffer buffer;
        http::response<http::string_body> res;
        auto len = http::read(stream, buffer, res);
        output = res.body();
        beast::error_code ec;
        stream.shutdown(ec);
        if (ec == boost::asio::error::eof) {
            ec.assign(0, ec.category());
        }
        if (ec) {
            throw boost::system::system_error{ec};
        }
		if (res.result_int() == 429 && tries <= MAX_API_TRIES) {
			this_thread::sleep_for(chrono::milliseconds(1000));
			return APICall(params, output, tries+1);
		}
		if (res.result_int() != 200) {
			return false;
		} else {
			remaining = stoi(res.base()["X-Credits-Remaining"]);
		}
    }
    catch(std::exception const & e) {
        cerr << "Error: " << e.what() << std::endl;
        return false;
    }
    return true;
}

/**
 * @brief Percent-encode a string for use in URL query components (RFC 3986).
 * @param str Input string to encode.
 * @return Encoded string where non-unreserved characters are percent-encoded.
 */
string EANSearch::urlencode(const string & str) {
    // RFC 3986 percent-encoding for query components: unreserved characters remain unencoded
    // unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    static const char * hex = "0123456789ABCDEF";
    string out;
    out.reserve(str.size() * 3);

    for (unsigned char c : str) {
        if ( (c >= 'A' && c <= 'Z') ||
             (c >= 'a' && c <= 'z') ||
             (c >= '0' && c <= '9') ||
             c == '-' || c == '_' || c == '.' || c == '~' ) {
            out.push_back(static_cast<char>(c));
        } else {
            out.push_back('%');
            out.push_back(hex[(c >> 4) & 0xF]);
            out.push_back(hex[c & 0xF]);
        }
    }
    return out;
}

ProductList * EANSearch::ParseProductList(const string & str) {
    error_code ec;
    auto api_result = json::parse(str, ec);
    json::array * arr = nullptr;
    if (!ec) {
        arr = api_result.at("productlist").if_array();
    }
    if (ec || !arr) {
        return nullptr;
    }
    ProductList * pl = new ProductList();
    for (auto o : *arr) {
        auto * p = ProductFromJSON(o);
        if (p) {
            pl->push_back(p);
        }
    }
    return pl;
}