IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2024-11-25 18:30:23 -06:00
Code Issues Packages Projects Releases Wiki Activity
ab3ba9918b
gnucash/libgnucash/app-utils/gnc-quotes.cpp
John Ralls 2f471e65a7 Bug 798802 - Online Price quote - Stocks not working GNU 5.0 Windows Bis 
The previous change of the delimiter between namespace and symbol
is needed in both overloads of GncQuoteImpl::query_fq.

Also log the query json string to ease future troubleshooting.
2023-04-09 15:24:53 -07:00

1093 lines
34 KiB
C++
Raw Blame History

/********************************************************************\
* gnc-quotes.hpp -- proxy for Finance::Quote *
* Copyright (C) 2021 Geert Janssens <geert@kobaltwit.be> *
* *
* 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 2 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, contact: *
* *
* Free Software Foundation Voice: +1-617-542-5942 *
* 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
* Boston, MA 02110-1301, USA gnu@gnu.org *
\ *******************************************************************/
#include <config.h>
#include <qoflog.h>
#include <algorithm>
#include <stdexcept>
#include <vector>
#include <string>
#include <iostream>
#include <boost/version.hpp>
#if BOOST_VERSION < 107600
// json_parser uses a deprecated version of bind.hpp
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#endif
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/process.hpp>
#include <boost/regex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream_buffer.hpp>
#include <boost/locale.hpp>
#include <boost/asio.hpp>
#include <glib.h>
#include "gnc-commodity.hpp"
#include <gnc-datetime.hpp>
#include <gnc-numeric.hpp>
#include "gnc-quotes.hpp"
#include <gnc-commodity.h>
#include <gnc-path.h>
#include "gnc-ui-util.h"
#include <gnc-prefs.h>
#include <gnc-session.h>
#include <regex.h>
#include <qofbook.h>
static const QofLogModule log_module = "gnc.price-quotes";
namespace bl = boost::locale;
namespace bp = boost::process;
namespace bfs = boost::filesystem;
namespace bpt = boost::property_tree;
namespace bio = boost::iostreams;
using QuoteResult = std::tuple<int, StrVec, StrVec>;
struct GncQuoteSourceError : public std::runtime_error
{
GncQuoteSourceError(const std::string& err) : std::runtime_error(err) {}
};
CommVec
gnc_quotes_get_quotable_commodities(const gnc_commodity_table * table);
class GncQuoteSource
{
public:
virtual ~GncQuoteSource() = default;
virtual const StrVec& get_sources() const noexcept = 0;
virtual const std::string & get_version() const noexcept = 0;
virtual QuoteResult get_quotes(const std::string& json_str) const = 0;
};
class GncQuotesImpl
{
public:
// Constructor - checks for presence of Finance::Quote and import version and quote sources
GncQuotesImpl ();
explicit GncQuotesImpl (QofBook *book);
GncQuotesImpl(QofBook*, std::unique_ptr<GncQuoteSource>);
void fetch (QofBook *book);
void fetch (CommVec& commodities);
void fetch (gnc_commodity *comm);
void report (const char* source, const StrVec& commodities, bool verbose);
const std::string& version() noexcept { return m_quotesource->get_version(); }
const QuoteSources& sources() noexcept { return m_sources; }
GList* sources_as_glist ();
bool had_failures() noexcept { return !m_failures.empty(); }
const QFVec& failures() noexcept;
std::string report_failures() noexcept;
private:
std::string query_fq (const char* source, const StrVec& commoditites);
std::string query_fq (const CommVec&);
bpt::ptree parse_quotes (const std::string& quote_str);
void create_quotes(const bpt::ptree& pt, const CommVec& comm_vec);
std::string comm_vec_to_json_string(const CommVec&) const;
GNCPrice* parse_one_quote(const bpt::ptree&, gnc_commodity*);
std::unique_ptr<GncQuoteSource> m_quotesource;
QuoteSources m_sources;
QFVec m_failures;
QofBook *m_book;
gnc_commodity *m_dflt_curr;
};
class GncFQQuoteSource final : public GncQuoteSource
{
const bfs::path c_cmd;
const std::string c_fq_wrapper;
std::string m_version;
StrVec m_sources;
std::string m_api_key;
public:
GncFQQuoteSource();
~GncFQQuoteSource() = default;
const std::string& get_version() const noexcept override { return m_version; }
const StrVec& get_sources() const noexcept override { return m_sources; }
QuoteResult get_quotes(const std::string&) const override;
private:
QuoteResult run_cmd (const StrVec& args, const std::string& json_string) const;
};
static void show_quotes(const bpt::ptree& pt, const StrVec& commodities, bool verbose);
static void show_currency_quotes(const bpt::ptree& pt, const StrVec& commodities, bool verbose);
static std::string parse_quotesource_error(const std::string& line);
static const std::string empty_string{};
GncFQQuoteSource::GncFQQuoteSource() :
c_cmd{bp::search_path("perl")},
c_fq_wrapper{std::string(gnc_path_get_bindir()) + "/finance-quote-wrapper"},
m_version{}, m_sources{}, m_api_key{}
{
StrVec args{"-w", c_fq_wrapper, "-v"};
const std::string empty_string;
auto [rv, sources, errors] = run_cmd(args, empty_string);
if (rv)
{
std::string err{bl::translate("Failed to initialize Finance::Quote: ")};
for (const auto& err_line : errors)
err += err_line.empty() ? "" : err_line + "\n";
throw(GncQuoteSourceError(err));
}
if (!errors.empty())
{
std::string err{bl::translate("Finance::Quote check returned error ")};
for(const auto& err_line : errors)
err += err.empty() ? "" : err_line + "\n";
throw(GncQuoteSourceError(err));
}
auto version{sources.front()};
if (version.empty())
{
std::string err{bl::translate("No Finance::Quote Version")};
throw(GncQuoteSourceError(err));
}
m_version = std::move(version);
sources.erase(sources.begin());
m_sources = std::move(sources);
std::sort (m_sources.begin(), m_sources.end());
auto av_key = gnc_prefs_get_string ("general.finance-quote", "alphavantage-api-key");
if (!(av_key && *av_key))
{
g_free (av_key);
av_key = g_strdup(getenv("ALPHAVANTAGE_API_KEY"));
}
if (av_key)
{
m_api_key = std::string(av_key);
g_free (av_key);
}
else
PWARN("No Alpha Vantage API key set, currency quotes and other AlphaVantage based quotes won't work.");
}
QuoteResult
GncFQQuoteSource::get_quotes(const std::string& json_str) const
{
StrVec args{"-w", c_fq_wrapper, "-f" };
return run_cmd(args, json_str);
}
QuoteResult
GncFQQuoteSource::run_cmd (const StrVec& args, const std::string& json_string) const
{
StrVec out_vec, err_vec;
int cmd_result;
try
{
std::future<std::vector<char> > out_buf, err_buf;
boost::asio::io_service svc;
auto input_buf = bp::buffer (json_string);
bp::child process;
if (m_api_key.empty())
process = bp::child(c_cmd, args,
bp::std_out > out_buf,
bp::std_err > err_buf,
bp::std_in < input_buf,
svc);
else
process = bp::child(c_cmd, args,
bp::std_out > out_buf,
bp::std_err > err_buf,
bp::std_in < input_buf,
bp::env["ALPHAVANTAGE_API_KEY"] = m_api_key,
svc);
svc.run();
process.wait();
{
auto raw = out_buf.get();
std::vector<std::string> data;
std::string line;
bio::stream_buffer<bio::array_source> sb(raw.data(), raw.size());
std::istream is(&sb);
while (std::getline(is, line) && !line.empty())
{
#ifdef __WIN32
if (line.back() == '\r')
line.pop_back();
#endif
out_vec.push_back (std::move(line));
}
raw = err_buf.get();
bio::stream_buffer<bio::array_source> eb(raw.data(), raw.size());
std::istream es(&eb);
while (std::getline(es, line) && !line.empty())
err_vec.push_back (std::move(line));
}
cmd_result = process.exit_code();
}
catch (std::exception &e)
{
cmd_result = -1;
err_vec.push_back(e.what());
};
return QuoteResult (cmd_result, std::move(out_vec), std::move(err_vec));
}
/* GncQuotes implementation */
GncQuotesImpl::GncQuotesImpl() : m_quotesource{new GncFQQuoteSource},
m_sources{}, m_failures{},
m_book{qof_session_get_book(gnc_get_current_session())},
m_dflt_curr{gnc_default_currency()}
{
m_sources = m_quotesource->get_sources();
}
GncQuotesImpl::GncQuotesImpl(QofBook* book) : m_quotesource{new GncFQQuoteSource},
m_sources{}, m_book{book},
m_dflt_curr{gnc_default_currency()}
{
m_sources = m_quotesource->get_sources();
}
GncQuotesImpl::GncQuotesImpl(QofBook* book, std::unique_ptr<GncQuoteSource> quote_source) :
m_quotesource{std::move(quote_source)},
m_sources{}, m_book{book}, m_dflt_curr{gnc_default_currency()}
{
m_sources = m_quotesource->get_sources();
}
GList*
GncQuotesImpl::sources_as_glist()
{
GList* slist = nullptr;
std::for_each (m_sources.rbegin(), m_sources.rend(),
[&slist](const std::string& source) { slist = g_list_prepend (slist, g_strdup(source.c_str())); });
return slist;
}
void
GncQuotesImpl::fetch (QofBook *book)
{
if (!book)
throw (GncQuoteException(bl::translate("GncQuotes::Fetch called with no book.")));
auto commodities = gnc_quotes_get_quotable_commodities (
gnc_commodity_table_get_table (book));
fetch (commodities);
}
void
GncQuotesImpl::fetch (gnc_commodity *comm)
{
auto commodities = CommVec {comm};
fetch (commodities);
}
void
GncQuotesImpl::fetch (CommVec& commodities)
{
m_failures.clear();
if (commodities.empty())
throw (GncQuoteException(bl::translate("GncQuotes::Fetch called with no commodities.")));
auto quote_str{query_fq (commodities)};
auto ptree{parse_quotes (quote_str)};
create_quotes(ptree, commodities);
}
void
GncQuotesImpl::report (const char* source, const StrVec& commodities,
bool verbose)
{
bool is_currency{source && strcmp(source, "currency") == 0};
m_failures.clear();
if (commodities.empty())
{
std::cerr << _("There were no commodities for which to retrieve quotes.") << std::endl;
return;
}
try
{
auto quote_str{query_fq (source, commodities)};
auto ptree{parse_quotes (quote_str)};
if (is_currency)
show_currency_quotes(ptree, commodities, verbose);
else
show_quotes(ptree, commodities, verbose);
}
catch (const GncQuoteException& err)
{
std::cerr << _("Finance::Quote retrieval failed with error ") << err.what() << std::endl;
}
}
const QFVec&
GncQuotesImpl::failures() noexcept
{
return m_failures;
}
static std::string
explain(GncQuoteError err, const std::string& errmsg)
{
std::string retval;
switch (err)
{
case GncQuoteError::NO_RESULT:
if (errmsg.empty())
retval += _("Finance::Quote returned no data and set no error.");
else
retval += _("Finance::Quote returned an error: ") + errmsg;
break;
case GncQuoteError::QUOTE_FAILED:
if (errmsg.empty())
retval += _("Finance::Quote reported failure set no error.");
else
retval += _("Finance::Quote reported failure with error: ") + errmsg;
break;
case GncQuoteError::NO_CURRENCY:
retval += _("Finance::Quote returned a quote with no currency.");
break;
case GncQuoteError::UNKNOWN_CURRENCY:
retval += _("Finance::Quote returned a quote with a currency GnuCash doesn't know about.");
break;
case GncQuoteError::NO_PRICE:
retval += _("Finance::Quote returned a quote with no price element.");
break;
case GncQuoteError::PRICE_PARSE_FAILURE:
retval += _("Finance::Quote returned a quote with a price that GnuCash was unable to covert to a number.");
break;
case GncQuoteError::SUCCESS:
default:
retval += _("The quote has no error set.");
break;
}
return retval;
}
std::string
GncQuotesImpl::report_failures() noexcept
{
std::string retval{_("Quotes for the following commodities were unavailable or unusable:\n")};
std::for_each(m_failures.begin(), m_failures.end(),
[&retval](auto failure)
{
auto [ns, sym, reason, err] = failure;
retval += "* " + ns + ":" + sym + " " +
explain(reason, err) + "\n";
});
return retval;
}
/* **** Private function implementations ****/
using Path = bpt::ptree::path_type;
static inline Path make_quote_path(const std::string &name_space,
const std::string &symbol)
{
using Path = bpt::ptree::path_type;
Path key{name_space, '|'};
key /= Path{symbol, '|'};
return key;
};
std::string
GncQuotesImpl::comm_vec_to_json_string(const CommVec &comm_vec) const
{
bpt::ptree pt, pt_child;
pt.put("defaultcurrency", gnc_commodity_get_mnemonic(m_dflt_curr));
std::for_each (comm_vec.cbegin(), comm_vec.cend(),
[this, &pt] (auto comm)
{
auto comm_mnemonic = gnc_commodity_get_mnemonic (comm);
auto comm_ns = std::string("currency");
if (gnc_commodity_is_currency (comm))
{
if (gnc_commodity_equiv(comm, m_dflt_curr) ||
(!comm_mnemonic || (strcmp(comm_mnemonic, "XXX") == 0)))
return;
}
else
comm_ns = gnc_quote_source_get_internal_name(gnc_commodity_get_quote_source(comm));
pt.put (make_quote_path(comm_ns, comm_mnemonic), "");
}
);
std::ostringstream result;
bpt::write_json(result, pt);
return result.str();
}
static inline std::string
get_quotes(const std::string& json_str, const std::unique_ptr<GncQuoteSource>& qs)
{
auto [rv, quotes, errors] = qs->get_quotes(json_str);
std::string answer;
if (rv == 0)
{
for (const auto& line : quotes)
answer.append(line + "\n");
}
else
{
std::string err_str;
for (const auto& line: errors)
{
if (line == "invalid_json\n")
PERR("Finanace Quote Wrapper was unable to parse %s",
json_str.c_str());
err_str += parse_quotesource_error(line);
}
throw(GncQuoteException(err_str));
}
return answer;
}
std::string
GncQuotesImpl::query_fq (const char* source, const StrVec& commodities)
{
bpt::ptree pt;
auto is_currency{strcmp(source, "currency") == 0};
if (is_currency && commodities.size() < 2)
throw(GncQuoteException(_("Currency quotes requires at least two currencies")));
if (is_currency)
pt.put("defaultcurrency", commodities[0].c_str());
else
pt.put("defaultcurrency", gnc_commodity_get_mnemonic(m_dflt_curr));
std::for_each(is_currency ? ++commodities.cbegin() : commodities.cbegin(),
commodities.cend(),
[source, &pt](auto sym)
{
pt.put(make_quote_path(source, sym), "");
});
std::ostringstream result;
bpt::write_json(result, pt);
auto result_str{result.str()};
PINFO("Query JSON: %s\n", result_str.c_str());
return get_quotes(result.str(), m_quotesource);
}
std::string
GncQuotesImpl::query_fq (const CommVec& comm_vec)
{
auto json_str{comm_vec_to_json_string(comm_vec)};
PINFO("Query JSON: %s\n", json_str.c_str());
return get_quotes(json_str, m_quotesource);
}
struct PriceParams
{
const char* ns;
const char* mnemonic;
bool success;
std::string type;
boost::optional<std::string> price;
bool inverted;
boost::optional<std::string> date;
boost::optional<std::string> time;
boost::optional<std::string> currency;
boost::optional<std::string> errormsg;
};
static void
get_price_and_type(PriceParams& p, const bpt::ptree& comm_pt)
{
p.type = "last";
p.price = comm_pt.get_optional<std::string> (p.type);
if (!p.price)
{
p.type = "nav";
p.price = comm_pt.get_optional<std::string> (p.type);
}
if (!p.price)
{
p.type = "price";
p.price = comm_pt.get_optional<std::string> (p.type);
/* guile wrapper used "unknown" as price type when "price" was found,
* reproducing here to keep same result for users in the pricedb */
p.type = p.price ? "unknown" : "missing";
}
}
static void
parse_quote_json(PriceParams& p, const bpt::ptree& comm_pt)
{
auto success = comm_pt.get_optional<bool> ("success");
p.success = success && *success;
if (!p.success)
p.errormsg = comm_pt.get_optional<std::string> ("errormsg");
get_price_and_type(p, comm_pt);
auto inverted = comm_pt.get_optional<bool> ("inverted");
p.inverted = inverted && *inverted;
p.date = comm_pt.get_optional<std::string> ("date");
p.time = comm_pt.get_optional<std::string> ("time");
p.currency = comm_pt.get_optional<std::string> ("currency");
PINFO("Commodity: %s", p.mnemonic);
PINFO(" Success: %s", (inverted ? "yes" : "no"));
PINFO(" Date: %s", (p.date ? p.date->c_str() : "missing"));
PINFO(" Time: %s", (p.time ? p.time->c_str() : "missing"));
PINFO(" Currency: %s", (p.currency ? p.currency->c_str() : "missing"));
PINFO(" Price: %s", (p.price ? p.price->c_str() : "missing"));
PINFO(" Inverted: %s\n", (inverted ? "yes" : "no"));
}
static time64
calc_price_time(const PriceParams& p)
{
/* Note that as of F::Q v. 1.52 the only sources that provide
* quote times are ftfunds (aka ukfunds), morningstarch, and
* mstaruk_fund, but it's faked with a comment "Set a dummy time
* as gnucash insists on having a valid format". It's also wrong,
* as it lacks seconds. Best ignored.
*/
if (p.date)
{
/* Returned date is always in MM/DD/YYYY format according to
* F::Q man page, transform it to simplify conversion to
* GncDateTime.
*/
auto date_tmp = *p.date;
auto iso_date_str = date_tmp.substr (6, 4) + "-" + date_tmp.substr (0, 2) +
"-" + date_tmp.substr (3, 2);
try
{
auto close_time{GncDateTime(iso_date_str + " 16:00:00")};
PINFO("Quote date included, using %s for %s:%s",
close_time.format("%Y-%m-%d %H:%M:%S").c_str(), p.ns, p.mnemonic);
return static_cast<time64>(close_time);
}
catch (...)
{
auto now{GncDateTime()};
PWARN("Warning: failed to parse quote date '%s' for %s:%s - will use %s",
iso_date_str.c_str(), p.ns, p.mnemonic, now.format("%Y-%m-%d %H:%M%S").c_str());
return static_cast<time64>(now);
}
}
auto now{GncDateTime()};
PINFO("No date was returned for %s:%s - will use %s",
p.ns, p.mnemonic, now.format("%Y-%m-%d %H:%M%S").c_str());
return static_cast<time64>(now);
}
static boost::optional<GncNumeric>
get_price(const PriceParams& p)
{
boost::optional<GncNumeric> price;
try
{
price = GncNumeric { *p.price };
}
catch (...)
{
PWARN("Skipped %s:%s - failed to parse returned price '%s'",
p.ns, p.mnemonic, p.price->c_str());
}
if (price && p.inverted)
*price = price->inv();
return price;
}
static gnc_commodity*
get_currency(const PriceParams& p, QofBook* book, QFVec& failures)
{
if (!p.currency)
{
failures.emplace_back(p.ns, p.mnemonic, GncQuoteError::NO_CURRENCY,
empty_string);
PWARN("Skipped %s:%s - Finance::Quote returned a quote with no currency",
p.ns, p.mnemonic);
return nullptr;
}
std::string curr_str = *p.currency;
boost::to_upper (curr_str);
auto commodity_table = gnc_commodity_table_get_table (book);
auto currency = gnc_commodity_table_lookup (commodity_table, "ISO4217", curr_str.c_str());
if (!currency)
{
failures.emplace_back(p.ns, p.mnemonic,
GncQuoteError::UNKNOWN_CURRENCY, empty_string);
PWARN("Skipped %s:%s - failed to parse returned currency '%s'",
p.ns, p.mnemonic, p.currency->c_str());
return nullptr;
}
return currency;
}
GNCPrice*
GncQuotesImpl::parse_one_quote(const bpt::ptree& pt, gnc_commodity* comm)
{
PriceParams p;
p.ns = gnc_commodity_get_namespace (comm);
p.mnemonic = gnc_commodity_get_mnemonic (comm);
if (gnc_commodity_equiv(comm, m_dflt_curr) ||
(!p.mnemonic || (strcmp (p.mnemonic, "XXX") == 0)))
return nullptr;
auto comm_pt_ai{pt.find(p.mnemonic)};
if (comm_pt_ai == pt.not_found())
{
m_failures.emplace_back(p.ns, p.mnemonic, GncQuoteError::NO_RESULT,
empty_string);
PINFO("Skipped %s:%s - Finance::Quote didn't return any data.",
p.ns, p.mnemonic);
return nullptr;
}
auto comm_pt{comm_pt_ai->second};
parse_quote_json(p, comm_pt);
if (!p.success)
{
m_failures.emplace_back(p.ns, p.mnemonic, GncQuoteError::QUOTE_FAILED,
p.errormsg ? *p.errormsg : empty_string);
PWARN("Skipped %s:%s - Finance::Quote returned fetch failure.\nReason %s",
p.ns, p.mnemonic,
(p.errormsg ? p.errormsg->c_str() : "unknown"));
return nullptr;
}
if (!p.price)
{
m_failures.emplace_back(p.ns, p.mnemonic,
GncQuoteError::NO_PRICE, empty_string);
PWARN("Skipped %s:%s - Finance::Quote didn't return a valid price",
p.ns, p.mnemonic);
return nullptr;
}
auto price{get_price(p)};
if (!price)
{
m_failures.emplace_back(p.ns, p.mnemonic,
GncQuoteError::PRICE_PARSE_FAILURE,
empty_string);
return nullptr;
}
auto currency{get_currency(p, m_book, m_failures)};
if (!currency)
return nullptr;
auto quotedt{calc_price_time(p)};
auto gnc_price = gnc_price_create (m_book);
gnc_price_begin_edit (gnc_price);
gnc_price_set_commodity (gnc_price, comm);
gnc_price_set_currency (gnc_price, currency);
gnc_price_set_time64 (gnc_price, static_cast<time64> (quotedt));
gnc_price_set_source (gnc_price, PRICE_SOURCE_FQ);
gnc_price_set_typestr (gnc_price, p.type.c_str());
gnc_price_set_value (gnc_price, *price);
gnc_price_commit_edit (gnc_price);
return gnc_price;
}
bpt::ptree
GncQuotesImpl::parse_quotes (const std::string& quote_str)
{
bpt::ptree pt;
std::istringstream ss {quote_str};
const char* what = nullptr;
try
{
bpt::read_json (ss, pt);
}
catch (bpt::json_parser_error &e) {
what = e.what();
}
catch (const std::runtime_error& e)
{
what = e.what();
}
catch (const std::logic_error& e)
{
what = e.what();
}
catch (...) {
std::string error_msg{_("Failed to parse result returned by Finance::Quote.")};
throw(GncQuoteException(error_msg));
}
if (what)
{
std::string error_msg{_("Failed to parse result returned by Finance::Quote.")};
error_msg += "\n";
error_msg += _("Error message:");
error_msg += "\n";
error_msg += what;
throw(GncQuoteException(error_msg));
}
return pt;
}
void
GncQuotesImpl::create_quotes (const bpt::ptree& pt, const CommVec& comm_vec)
{
auto pricedb{gnc_pricedb_get_db(m_book)};
for (auto comm : comm_vec)
{
auto price{parse_one_quote(pt, comm)};
if (!price)
continue;
gnc_price_begin_edit (price);
gnc_pricedb_add_price(pricedb, price);
gnc_price_commit_edit(price);
gnc_price_unref (price);
}
}
static void
show_verbose_quote(const bpt::ptree& comm_pt)
{
std::for_each(comm_pt.begin(), comm_pt.end(),
[](auto elem) {
std::cout << std::setw(12) << std::right << elem.first << " => " <<
std::left << elem.second.data() << "\n";
});
std::cout << std::endl;
}
static void
show_gnucash_quote(const bpt::ptree& comm_pt)
{
constexpr const char* ptr{"<=== "};
constexpr const char* dptr{"<=\\ "};
constexpr const char* uptr{"<=/ "};
//Translators: Means that the preceding element is required
const char* reqd{C_("Finance::Quote", "required")};
//Translators: Means that the quote will work best if the preceding element is provided
const char* rec{C_("Finance::Quote", "recommended")};
//Translators: Means that one of the indicated elements is required
const char* oot{C_("Finance::Quote", "one of these")};
//Translators: Means that a required element wasn't reported. The *s are for emphasis.
const char* miss{C_("Finance::Quote", "**missing**")};
const std::string miss_str{miss};
auto outline{[](const char* label, std::string value, const char* pointer, const char* req) {
std::cout << std::setw(12) << std::right << label << std::setw(16) << std::left <<
value << pointer << req << "\n";
}};
std::cout << _("Finance::Quote fields GnuCash uses:") << "\n";
//Translators: The stock or Mutual Fund symbol, ISIN, CUSIP, etc.
outline(C_("Finance::Quote", "symbol: "), comm_pt.get<char>("symbol", miss), ptr, reqd);
//Translators: The date of the quote.
outline(C_("Finance::Quote", "date: "), comm_pt.get<char>("date", miss), ptr, rec);
//Translators: The quote currency
outline(C_("Finance::Quote", "currency: "), comm_pt.get<char>("currency", miss), ptr, reqd);
auto last{comm_pt.get<char>("last", "")};
auto nav{comm_pt.get<char>("nav", "")};
auto price{comm_pt.get<char>("nav", "")};
auto no_price{last.empty() && nav.empty() && price.empty()};
//Translators: The quote is for the most recent trade on the exchange
outline(C_("Finance::Quote", "last: "), no_price ? miss_str : last, dptr, "");
//Translators: The quote is for an open-ended mutual fund and represents the net asset value of one unit of the fund at the previous close of trading.
outline(C_("Finance::Quote", "nav: "), no_price ? miss_str : nav, ptr, oot);
//Translators: The quote is neither a last trade nor an NAV.
outline(C_("Finance::Quote", "price: "), no_price ? miss_str : price, uptr, "");
std::cout << std::endl;
}
static const bpt::ptree empty_tree{};
static inline const bpt::ptree&
get_commodity_data(const bpt::ptree& pt, const std::string& comm)
{
auto commdata{pt.find(comm)};
if (commdata == pt.not_found())
{
std::cout << comm << " " << _("Finance::Quote returned no data and set no error.") << std::endl;
return empty_tree;
}
auto& comm_pt{commdata->second};
auto success = comm_pt.get_optional<bool> ("success");
if (!(success && *success))
{
auto errormsg = comm_pt.get_optional<std::string> ("errormsg");
if (errormsg && !errormsg->empty())
std::cout << _("Finance::Quote reported a failure for symbol ") <<
comm << ": " << *errormsg << std::endl;
else
std::cout << _("Finance::Quote failed silently to retrieve a quote for symbol ") <<
comm << std::endl;
return empty_tree;
}
return comm_pt;
}
static void
show_quotes(const bpt::ptree& pt, const StrVec& commodities, bool verbose)
{
for (const auto& comm : commodities)
{
auto comm_pt{get_commodity_data(pt, comm)};
if (comm_pt == empty_tree)
continue;
if (verbose)
{
std::cout << comm << ":\n";
show_verbose_quote(comm_pt);
}
else
{
show_gnucash_quote(comm_pt);
}
}
}
static void
show_currency_quotes(const bpt::ptree& pt, const StrVec& commodities, bool verbose)
{
auto to_cur{commodities.front()};
for (const auto& comm : commodities)
{
if (comm == to_cur)
continue;
auto comm_pt{get_commodity_data(pt, comm)};
if (comm_pt == empty_tree)
continue;
if (verbose)
{
std::cout << comm << ":\n";
show_verbose_quote(comm_pt);
}
else
{
std::cout << "1 " << comm << " = " <<
comm_pt.get<char>("last", "Not Found") << " " << to_cur << "\n";
}
std::cout << std::endl;
}
}
static std::string
parse_quotesource_error(const std::string& line)
{
std::string err_str;
if (line == "invalid_json\n")
{
err_str += _("GnuCash submitted invalid json to Finance::Quote. The details were logged.");
}
else if (line.substr(0, 15) == "missing_modules")
{
PERR("Missing Finance::Quote Dependencies: %s",
line.substr(17).c_str());
err_str += _("Perl is missing the following modules. Please see https://wiki.gnucash.org/wiki/Online_Quotes#Finance::Quote for detailed corrective action. ");
err_str += line.substr(17);
}
else
{
PERR("Unrecognized Finance::Quote Error %s", line.c_str());
err_str +=_("Unrecognized Finance::Quote Error: ");
err_str += line;
}
err_str += "\n";
return err_str;
}
/********************************************************************
* gnc_quotes_get_quotable_commodities
* list commodities in a given namespace that get price quotes
********************************************************************/
/* Helper function to be passed to g_list_for_each applied to the result
* of gnc_commodity_namespace_get_commodity_list.
*/
static void
get_quotables_helper1 (gpointer value, gpointer data)
{
auto l = static_cast<CommVec *> (data);
auto comm = static_cast<gnc_commodity *> (value);
auto quote_flag = gnc_commodity_get_quote_flag (comm);
auto quote_source = gnc_commodity_get_quote_source (comm);
auto quote_source_supported = gnc_quote_source_get_supported (quote_source);
if (!quote_flag ||
!quote_source || !quote_source_supported)
return;
l->push_back (comm);
}
// Helper function to be passed to gnc_commodity_table_for_each
static gboolean
get_quotables_helper2 (gnc_commodity *comm, gpointer data)
{
auto l = static_cast<CommVec *> (data);
auto quote_flag = gnc_commodity_get_quote_flag (comm);
auto quote_source = gnc_commodity_get_quote_source (comm);
auto quote_source_supported = gnc_quote_source_get_supported (quote_source);
if (!quote_flag ||
!quote_source || !quote_source_supported)
return TRUE;
l->push_back (comm);
return TRUE;
}
CommVec
gnc_quotes_get_quotable_commodities (const gnc_commodity_table * table)
{
gnc_commodity_namespace * ns = NULL;
const char *name_space;
GList * nslist, * tmp;
CommVec l;
regex_t pattern;
const char *expression = gnc_prefs_get_namespace_regexp ();
// ENTER("table=%p, expression=%s", table, expression);
if (!table)
return CommVec ();
if (expression && *expression)
{
if (regcomp (&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
{
// LEAVE ("Cannot compile regex");
return CommVec ();
}
nslist = gnc_commodity_table_get_namespaces (table);
for (tmp = nslist; tmp; tmp = tmp->next)
{
name_space = static_cast<const char *> (tmp->data);
if (regexec (&pattern, name_space, 0, NULL, 0) == 0)
{
// DEBUG ("Running list of %s commodities", name_space);
ns = gnc_commodity_table_find_namespace (table, name_space);
if (ns)
{
auto cm_list = gnc_commodity_namespace_get_commodity_list (ns);
g_list_foreach (cm_list, &get_quotables_helper1, (gpointer) &l);
}
}
}
g_list_free (nslist);
regfree (&pattern);
}
else
{
gnc_commodity_table_foreach_commodity (table, get_quotables_helper2,
(gpointer) &l);
}
//LEAVE ("list head %p", &l);
return l;
}
/* Public interface functions */
// Constructor - checks for presence of Finance::Quote and import version and quote sources
GncQuotes::GncQuotes ()
{
try
{
m_impl = std::make_unique<GncQuotesImpl>();
}
catch (const GncQuoteSourceError& err)
{
throw(GncQuoteException(err.what()));
}
}
void
GncQuotes::fetch (QofBook *book)
{
m_impl->fetch (book);
}
void GncQuotes::fetch (CommVec& commodities)
{
m_impl->fetch (commodities);
}
void GncQuotes::fetch (gnc_commodity *comm)
{
m_impl->fetch (comm);
}
void GncQuotes::report (const char* source, const StrVec& commodities,
bool verbose)
{
m_impl->report(source, commodities, verbose);
}
const std::string& GncQuotes::version() noexcept
{
return m_impl->version ();
}
const QuoteSources& GncQuotes::sources() noexcept
{
return m_impl->sources ();
}
GList* GncQuotes::sources_as_glist ()
{
return m_impl->sources_as_glist ();
}
GncQuotes::~GncQuotes() = default;
bool
GncQuotes::had_failures() noexcept
{
return m_impl->had_failures();
}
const QFVec&
GncQuotes::failures() noexcept
{
return m_impl->failures();
}
const std::string
GncQuotes::report_failures() noexcept
{
return m_impl->report_failures();
}
Reference in New Issue View Git Blame Copy Permalink