GncImportPrice Struct Reference

Public Member Functions
	GncImportPrice (int date_format, int currency_format)
void	set (GncPricePropType prop_type, const std::string &value, bool enable_test_empty)
void	set_date_format (int date_format)
void	set_currency_format (int currency_format)
void	reset (GncPricePropType prop_type)
std::string	verify_essentials (void)
Result	create_price (QofBook *book, GNCPriceDB *pdb, bool over)
gnc_commodity *	get_from_commodity ()
void	set_from_commodity (gnc_commodity *comm)
gnc_commodity *	get_to_currency ()
void	set_to_currency (gnc_commodity *curr)
std::string	errors ()

Detailed Description

Definition at line 83 of file gnc-imp-props-price.hpp.

Constructor & Destructor Documentation

GncImportPrice()

GncImportPrice::GncImportPrice ( int  date_format, int  currency_format  )

inline

Definition at line 86 of file gnc-imp-props-price.hpp.

                                                          : m_date_format{date_format},
        m_currency_format{currency_format}{};

Member Function Documentation

create_price()

Result GncImportPrice::create_price	(	QofBook *	book,
		GNCPriceDB *	pdb,
		bool	over
	)

Definition at line 295 of file gnc-imp-props-price.cpp.

{
    /* Gently refuse to create the price if the basics are not set correctly
     * This should have been tested before calling this function though!
     */
    auto check = verify_essentials();
    if (!check.empty())
    {
        PWARN ("Refusing to create price because essentials not set properly: %s", check.c_str());
        return FAILED;
    }
 
    auto date = static_cast<time64>(GncDateTime(*m_date, DayPart::neutral));
 
    auto amount = *m_amount;
    Result ret_val = ADDED;
 
    GNCPrice *old_price = gnc_pricedb_lookup_day_t64 (pdb, *m_from_commodity,
                                                      *m_to_currency, date);
 
    // Should old price be over written
    if ((old_price != nullptr) && (over == true))
    {
        DEBUG("Over write");
        gnc_pricedb_remove_price (pdb, old_price);
        gnc_price_unref (old_price);
        old_price = nullptr;
        ret_val = REPLACED;
    }
 
    char date_str [MAX_DATE_LENGTH + 1];
    memset (date_str, 0, sizeof(date_str));
    qof_print_date_buff (date_str, MAX_DATE_LENGTH, date);
    DEBUG("Date is %s, Commodity from is '%s', Currency is '%s', "
          "Amount is %s", date_str,
          gnc_commodity_get_fullname (*m_from_commodity),
          gnc_commodity_get_fullname (*m_to_currency),
          amount.to_string().c_str());
    // Create the new price
    if (old_price == nullptr)
    {
        DEBUG("Create");
        GNCPrice *price = gnc_price_create (book);
        gnc_price_begin_edit (price);
 
        gnc_price_set_commodity (price, *m_from_commodity);
        gnc_price_set_currency (price, *m_to_currency);
 
        int scu = gnc_commodity_get_fraction (*m_to_currency);
        auto amount_conv = amount.convert<RoundType::half_up>(scu * COMMODITY_DENOM_MULT);
 
        gnc_price_set_value (price, static_cast<gnc_numeric>(amount_conv));
 
        gnc_price_set_time64 (price, date);
        gnc_price_set_source (price, PRICE_SOURCE_USER_PRICE);
        gnc_price_set_typestr (price, PRICE_TYPE_LAST);
        gnc_price_commit_edit (price);
 
        bool perr = gnc_pricedb_add_price (pdb, price);
 
        gnc_price_unref (price);
 
        if (perr == false)
            throw std::invalid_argument (_("Failed to create price from selected columns."));
    }
    else
    {
        gnc_price_unref (old_price);
        ret_val = DUPLICATED;
    }
    return ret_val;
}

errors()

std::string GncImportPrice::errors

(

)

Definition at line 378 of file gnc-imp-props-price.cpp.

{
    return gen_err_str (m_errors);
}

get_from_commodity()

gnc_commodity * GncImportPrice::get_from_commodity ( )

inline

Definition at line 96 of file gnc-imp-props-price.hpp.

{ if (m_from_commodity) return *m_from_commodity; else return nullptr; }

get_to_currency()

gnc_commodity * GncImportPrice::get_to_currency ( )

inline

Definition at line 99 of file gnc-imp-props-price.hpp.

{ if (m_to_currency) return *m_to_currency; else return nullptr; }

reset()

void GncImportPrice::reset

(

GncPricePropType

prop_type

)

Definition at line 256 of file gnc-imp-props-price.cpp.

{
    try
    {
        if ((prop_type == GncPricePropType::FROM_NAMESPACE) ||
            (prop_type == GncPricePropType::FROM_SYMBOL))
             set_from_commodity (nullptr);
 
        if (prop_type == GncPricePropType::TO_CURRENCY)
             set_to_currency (nullptr);
 
        // set enable_test_empty to false to allow empty values
        set (prop_type, std::string(), false);
    }
    catch (...)
    {
        // Set with an empty string will effectively clear the property
        // but can also set an error for the property. Clear that error here.
        m_errors.erase(prop_type);
    }
}

set()

void GncImportPrice::set	(	GncPricePropType	prop_type,
		const std::string &	value,
		bool	enable_test_empty
	)

Definition at line 152 of file gnc-imp-props-price.cpp.

{
    try
    {
        // Drop any existing error for the prop_type we're about to set
        m_errors.erase(prop_type);
 
        // conditional test for empty values
        if (value.empty() && enable_test_empty)
            throw std::invalid_argument (_("Column value can not be empty."));
 
        gnc_commodity *comm = nullptr;
        switch (prop_type)
        {
            case GncPricePropType::DATE:
                m_date.reset();
                m_date = GncDate(value, GncDate::c_formats[m_date_format].m_fmt); // Throws if parsing fails
                break;
 
            case GncPricePropType::AMOUNT:
                m_amount.reset();
                m_amount = parse_amount_price (value, m_currency_format); // Throws if parsing fails
                break;
 
            case GncPricePropType::FROM_SYMBOL:
                m_from_symbol.reset();
 
                if (value.empty())
                    throw std::invalid_argument (_("'From Symbol' can not be empty."));
                else
                    m_from_symbol = value;
 
                if (m_from_namespace)
                {
                    comm = parse_commodity_price_comm (value, *m_from_namespace); // Throws if parsing fails
                    if (comm)
                    {
                        if (m_to_currency == comm)
                                throw std::invalid_argument (_("'Commodity From' can not be the same as 'Currency To'."));
                        m_from_commodity = comm;
                    }
                }
                break;
 
            case GncPricePropType::FROM_NAMESPACE:
                m_from_namespace.reset();
 
                if (value.empty())
                    throw std::invalid_argument (_("'From Namespace' can not be empty."));
 
                if (parse_namespace (value)) // Throws if parsing fails
                {
                    m_from_namespace = value;
 
                    if (m_from_symbol)
                    {
                        comm = parse_commodity_price_comm (*m_from_symbol, *m_from_namespace); // Throws if parsing fails
                        if (comm)
                        {
                            if (m_to_currency == comm)
                                throw std::invalid_argument (_("'Commodity From' can not be the same as 'Currency To'."));
                            m_from_commodity = comm;
                        }
                    }
                }
                break;
 
            case GncPricePropType::TO_CURRENCY:
                m_to_currency.reset();
                comm = parse_commodity_price_comm (value, GNC_COMMODITY_NS_CURRENCY); // Throws if parsing fails
                if (comm)
                {
                    if (m_from_commodity == comm)
                        throw std::invalid_argument (_("'Currency To' can not be the same as 'Commodity From'."));
                    if (gnc_commodity_is_currency (comm) != true)
                        throw std::invalid_argument (_("Value parsed into an invalid currency for a currency column type."));
                    m_to_currency = comm;
                }
                break;
 
            default:
                /* Issue a warning for all other prop_types. */
                PWARN ("%d is an invalid property for a Price", static_cast<int>(prop_type));
                break;
        }
    }
    catch (const std::invalid_argument& e)
    {
        auto err_str = (bl::format (std::string{_("{1}: {2}")}) %
                        std::string{_(gnc_price_col_type_strs[prop_type])} %
                        e.what()).str();
        m_errors.emplace(prop_type, err_str);
        throw std::invalid_argument (err_str);
    }
    catch (const std::out_of_range& e)
    {
        auto err_str = (bl::format (std::string{_("{1}: {2}")}) %
                        std::string{_(gnc_price_col_type_strs[prop_type])} %
                        e.what()).str();
        m_errors.emplace(prop_type, err_str);
        throw std::invalid_argument (err_str);
    }
}

set_currency_format()

void GncImportPrice::set_currency_format ( int  currency_format )

inline

Definition at line 91 of file gnc-imp-props-price.hpp.

{ m_currency_format = currency_format ;}

set_date_format()

void GncImportPrice::set_date_format ( int  date_format )

inline

Definition at line 90 of file gnc-imp-props-price.hpp.

{ m_date_format = date_format ;}

set_from_commodity()

void GncImportPrice::set_from_commodity ( gnc_commodity *  comm )

inline

Definition at line 97 of file gnc-imp-props-price.hpp.

{ if (comm) m_from_commodity = comm; else m_from_commodity.reset(); }

set_to_currency()

void GncImportPrice::set_to_currency ( gnc_commodity *  curr )

inline

Definition at line 100 of file gnc-imp-props-price.hpp.

{ if (curr) m_to_currency = curr; else m_to_currency.reset(); }

verify_essentials()

std::string GncImportPrice::verify_essentials

(

void

)

Definition at line 278 of file gnc-imp-props-price.cpp.

{
    /* Make sure this price has the minimum required set of properties defined */
    if (!m_date)
        return _("No date column.");
    else if (!m_amount)
        return _("No amount column.");
    else if (!m_to_currency)
        return _("No 'Currency to'.");
    else if (!m_from_commodity)
        return _("No 'Commodity from'.");
    else if (gnc_commodity_equal (*m_from_commodity, *m_to_currency))
        return _("'Commodity From' can not be the same as 'Currency To'.");
    else
        return std::string();
}

---

The documentation for this struct was generated from the following files:

• gnc-imp-props-price.hpp
• gnc-imp-props-price.cpp