1482 lines
68 KiB
C++
1482 lines
68 KiB
C++
#include "calculate_price.h"
|
|
#include "configuration.h"
|
|
#include "calculator_functions.h"
|
|
#include "payment_option.h"
|
|
#include "utilities.h"
|
|
#include "tariff_global_defines.h"
|
|
#include "period_year.h"
|
|
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QDateTime>
|
|
#include <QDebug>
|
|
#include <QList>
|
|
|
|
QString const CalcState::SUCCESS = "SUCCESS";
|
|
QString const CalcState::ERROR_PARSING_ZONE_NR = "ERROR_PARSING_ZONE_NR";
|
|
QString const CalcState::ERROR_LOADING_TARIFF = "ERROR_LOADING_TARIFF";
|
|
QString const CalcState::ERROR_PARSING_TARIFF = "ERROR_PARSING_TARIFF";
|
|
QString const CalcState::NEGATIVE_PARKING_TIME = "NEGATIVE_PARKING_TIME";
|
|
QString const CalcState::INVALID_START_DATE = "INVALID_START_DATE";
|
|
QString const CalcState::WRONG_PARAM_VALUES = "WRONG_PARAM_VALUES";
|
|
QString const CalcState::WRONG_ISO_TIME_FORMAT = "WRONG_ISO_TIME_FORMAT";
|
|
QString const CalcState::ABOVE_MAX_PARKING_TIME = "ABOVE_MAX_PARKING_TIME";
|
|
QString const CalcState::BELOW_MIN_PARKING_TIME = "BELOW_MIN_PARKING_TIME";
|
|
QString const CalcState::BELOW_MIN_PARKING_PRICE = "BELOW_MIN_PARKING_PRICE";
|
|
QString const CalcState::ABOVE_MAX_PARKING_PRICE = "ABOVE_MAX_PARKING_PRICE";
|
|
QString const CalcState::OVERPAID = "OVERPAID";
|
|
QString const CalcState::OUTSIDE_ALLOWED_PARKING_TIME = "OUTSIDE_ALLOWED_PARKING_TIME";
|
|
QString const CalcState::SUCCESS_MAXPRICE = "SUCCESS_MAXPRICE";
|
|
|
|
QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg) {
|
|
return Calculator::GetInstance().GetTimeSteps(cfg);
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration const *cfg,
|
|
PERMIT_TYPE permitType,
|
|
int paymentOptionIndex) {
|
|
int minTime = 0;
|
|
|
|
paymentOptionIndex = getPaymentOptionIndex(*cfg);
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
qCritical() << __func__ << __LINE__ << "paymentOptionIndex" << paymentOptionIndex;
|
|
qCritical() << __func__ << __LINE__ << "permit" << PermitType(permitType).toString();
|
|
|
|
switch(permitType) {
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
|
qCritical() << __LINE__ << Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
|
|
minTime = cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
|
|
qCritical() << __func__ << __LINE__ << minTime;
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_ADULT: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_TEEN: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_CHILD: {
|
|
} break;
|
|
default:
|
|
// for each new sell-procedure, recomute the timesteps. implicitly, set
|
|
// the minimal parking time.
|
|
Calculator::GetInstance().ResetTimeSteps(paymentOptionIndex);
|
|
qCritical() << __LINE__ << Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
|
|
minTime = qRound(cfg->getPaymentOptions(paymentOptionIndex).pop_min_time);
|
|
}
|
|
|
|
qCritical() << "minTime" << minTime;
|
|
return minTime;
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
|
|
PERMIT_TYPE permitType,
|
|
int paymentOptionIndex) {
|
|
|
|
paymentOptionIndex = getPaymentOptionIndex(*cfg);
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
int maxTime = 0;
|
|
|
|
switch(permitType) {
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
|
maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_ADULT: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_TEEN: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_CHILD: {
|
|
} break;
|
|
default: ;
|
|
maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
|
|
}
|
|
|
|
return maxTime;
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
|
|
PERMIT_TYPE permitType,
|
|
int paymentOptionIndex,
|
|
QDateTime const &start) {
|
|
int minPrice = -1;
|
|
|
|
if ((paymentOptionIndex = getPaymentOptionIndex(*cfg, start)) == -1) {
|
|
paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
int payment_method_id = cfg->getPaymentOptions(paymentOptionIndex).pop_payment_method_id;
|
|
|
|
if (payment_method_id == PaymentMethod::Degressive) {
|
|
// Degressive: new for Fuchs Technik (500), ValserAlm (Fane):
|
|
// the minimal price has to be calculated, in cannot be hard coded into
|
|
// the tariff file.
|
|
// The working times have a reference into the payment rates. Two special
|
|
// entries (with the numbers 1000/1001) point to the respective prices.
|
|
switch(permitType) {
|
|
default: {
|
|
// find the correct work time range
|
|
int weekDay = start.date().dayOfWeek();
|
|
std::optional<QVector<ATBWeekDaysWorktime>> const &wd = cfg->getAllWeekDayWorkTimes();
|
|
if (wd.has_value()) {
|
|
QVector<ATBWeekDaysWorktime> const &vec = wd.value();
|
|
for (int i = 0; i < vec.size(); ++i) {
|
|
ATBWeekDaysWorktime const &wt = vec[i];
|
|
if (wt.pwd_period_day_in_week_id == weekDay) {
|
|
if (start.time() >= QTime::fromString(QString::fromStdString(wt.pwd_time_from), Qt::ISODate)
|
|
&& start.time() <= QTime::fromString(QString::fromStdString(wt.pwd_time_to), Qt::ISODate)) {
|
|
// found worktime range
|
|
int pop_id = wt.pwd_pop_id; // 1000 or 1001
|
|
for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
|
|
i = vec.size(); // to leave outer loop
|
|
minPrice = itr->second.pra_price; // this is now the minimal price
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
switch(permitType) {
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
|
minPrice = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_ADULT: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_TEEN: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_CHILD: {
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET: {
|
|
minPrice = compute_product_price(cfg, permitType, start);
|
|
} break;
|
|
default:
|
|
minPrice = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
|
|
}
|
|
}
|
|
|
|
return minPrice;
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg,
|
|
PERMIT_TYPE permitType,
|
|
QDateTime const &start,
|
|
QDateTime *productStart,
|
|
QDateTime *productEnd) {
|
|
|
|
switch(permitType) {
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_CHILD:
|
|
// [[fallthrough]];
|
|
case PERMIT_TYPE::DAY_TICKET_TEEN:
|
|
// [[fallthrough]];
|
|
case PERMIT_TYPE::FOOD_STAMP:
|
|
// [[fallthrough]];
|
|
case PERMIT_TYPE::DAY_TICKET_ADULT: {
|
|
std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
|
|
if (products) {
|
|
QVector<ATBTariffProduct> product = products.value();
|
|
if (product.size() > 0) {
|
|
ATBTariffProduct const &p = product[0];
|
|
return p.m_tariff_product_price;
|
|
#if 0
|
|
// in case we do not have prepaid-option
|
|
QTime const ¤tTime = QDateTime::currentDateTime().time();
|
|
|
|
if (p.m_tariff_product_start <= currentTime && currentTime <= p.m_tariff_product_end) {
|
|
return p.m_tariff_product_price;
|
|
} else {
|
|
qCritical() << "(" << __func__ << ":" << __LINE__ << ")"
|
|
<< "ERROR currentTime"
|
|
<< currentTime.toString(Qt::ISODate)
|
|
<< "INVALID ("
|
|
<< p.m_tariff_product_start.toString(Qt::ISODate)
|
|
<< p.m_tariff_product_end.toString(Qt::ISODate) << ")";
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::INVALID:
|
|
// [[fallthrough]];
|
|
case PERMIT_TYPE::DAY_TICKET: {
|
|
std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
|
|
if (products) {
|
|
QVector<ATBTariffProduct> product = products.value();
|
|
int product_price = 0;
|
|
|
|
if (productStart && productEnd) {
|
|
*productStart = start;
|
|
*productEnd = start;
|
|
if (product.size() > 0) {
|
|
productStart->setTime(product[0].getTimeStart());
|
|
productEnd->setTime(product[0].getTimeEnd());
|
|
}
|
|
}
|
|
|
|
for (QVector<ATBTariffProduct>::size_type i=0; i<product.size(); ++i) {
|
|
ATBTariffProduct const &p = product[i];
|
|
QTime const &startTime = p.getTimeStart();
|
|
QTime const &endTime = p.getTimeEnd();
|
|
|
|
// qCritical() << __LINE__ << startTime.toString(Qt::ISODate);
|
|
// qCritical() << __LINE__ << endTime.toString(Qt::ISODate);
|
|
// qCritical() << __LINE__ << start.toString(Qt::ISODate);
|
|
|
|
if (start.time() >= startTime && start.time() < endTime) {
|
|
product_price = p.getProductPrice();
|
|
if (productStart && productEnd) {
|
|
productStart->setTime(startTime);
|
|
productEnd->setTime(endTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
return product_price;
|
|
} else {
|
|
// SZEGED
|
|
int const pop_daily_card_price = cfg->getPaymentOptions().pop_daily_card_price;
|
|
|
|
qDebug() << QString("(%1:%2) no products defined in tariff-file").arg(__func__).arg(__LINE__);
|
|
qDebug() << QString("(%1:%2) pop_daily_card_price=%3").arg(__func__).arg(__LINE__).arg(pop_daily_card_price);
|
|
|
|
// static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
|
|
// return Utilities::getDailyTicketCardPrice(cfg, paymentMethodId);
|
|
|
|
return pop_daily_card_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET: {
|
|
std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
|
|
if (products) {
|
|
int product_price = 0;
|
|
QVector<ATBTariffProduct> product = products.value();
|
|
|
|
if (product.size() > 0) {
|
|
if (productStart && productEnd) {
|
|
int pop_min_time = get_minimal_parkingtime(cfg, PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET); // in minutes
|
|
int pop_max_time = get_maximal_parkingtime(cfg, PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET); // in minutes
|
|
if (pop_max_time >= pop_min_time) {
|
|
*productStart = start;
|
|
*productEnd = start.addSecs(pop_max_time*60);
|
|
product_price = product[0].getProductPrice();
|
|
}
|
|
}
|
|
}
|
|
|
|
return product_price;
|
|
}
|
|
|
|
} break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_PKW: {
|
|
PermitType p(permitType);
|
|
std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
|
|
if (paymentOption.has_value()) {
|
|
ATBPaymentOption option = paymentOption.value();
|
|
int const pop_daily_card_price = option.pop_daily_card_price;
|
|
qCritical() << "SHORT_TERM_PARKING_PKW: daily ticket price" << pop_daily_card_price;
|
|
return pop_daily_card_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_BUS: {
|
|
qCritical() << "TODO: SHORT_TERM_PARKING_BUS";
|
|
} break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_CAMPER: {
|
|
qCritical() << "TODO: SHORT_TERM_PARKING_CAMPER";
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_PKW: {
|
|
PermitType p(permitType);
|
|
std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
|
|
if (paymentOption.has_value()) {
|
|
ATBPaymentOption option = paymentOption.value();
|
|
int const pop_daily_card_price = option.pop_daily_card_price;
|
|
qCritical() << "DAY_TICKET_PKW: daily ticket price" << pop_daily_card_price;
|
|
return pop_daily_card_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_BUS: {
|
|
PermitType p(permitType);
|
|
std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
|
|
if (paymentOption.has_value()) {
|
|
ATBPaymentOption option = paymentOption.value();
|
|
int const pop_daily_card_price = option.pop_daily_card_price;
|
|
qCritical() << "DAY_TICKET_BUS: daily ticket price" << pop_daily_card_price;
|
|
return pop_daily_card_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_CAMPER: {
|
|
PermitType p(permitType);
|
|
std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
|
|
if (paymentOption.has_value()) {
|
|
ATBPaymentOption option = paymentOption.value();
|
|
int const pop_daily_card_price = option.pop_daily_card_price;
|
|
qCritical() << "DAY_TICKET_CAMPER: daily ticket price" << pop_daily_card_price;
|
|
return pop_daily_card_price;
|
|
}
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg,
|
|
PERMIT_TYPE permitType,
|
|
int paymentOptionIndex) {
|
|
int maxPrice = -1;
|
|
static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
|
|
|
|
if ((paymentOptionIndex = getPaymentOptionIndex(*cfg)) == -1) {
|
|
paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
switch(permitType) {
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
|
if (paymentMethodId == PaymentMethod::Progressive
|
|
|| paymentMethodId == PaymentMethod::Steps
|
|
|| paymentMethodId == PaymentMethod::Unified) {
|
|
//maxPrice = Utilities::getMaximalParkingPrice(cfg, paymentMethodId);
|
|
ATBPaymentOption const &po = cfg->getPaymentOptions(paymentOptionIndex);
|
|
maxPrice = po.pop_max_price; // maxTime is given in minutes
|
|
} else { // PaymentMethod::Linear -> e.g. szeged
|
|
int const key = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
|
|
int const maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time; // maxTime is given in minutes
|
|
std::optional<QVector<ATBPaymentRate>> const &pv = cfg->getPaymentRateForKey(key);
|
|
if (pv) {
|
|
QVector<ATBPaymentRate> const &paymentRate = pv.value();
|
|
if (paymentRate.size() > 0) {
|
|
int const price = paymentRate.last().pra_price; // price is given per hour
|
|
maxPrice = qRound((maxTime * price) / 60.0f);
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::DAY_TICKET_ADULT:
|
|
break;
|
|
case PERMIT_TYPE::DAY_TICKET_TEEN:
|
|
break;
|
|
case PERMIT_TYPE::DAY_TICKET_CHILD:
|
|
break;
|
|
case PERMIT_TYPE::DAY_TICKET_BUS:
|
|
break;
|
|
case PERMIT_TYPE::DAY_TICKET_CAMPER:
|
|
break;
|
|
case PERMIT_TYPE::DAY_TICKET_PKW:
|
|
break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_BUS: {
|
|
std::optional<ATBPaymentOption> po = cfg->getPaymentOptionForKey(permitType);
|
|
if (po.has_value()) {
|
|
ATBPaymentOption option = po.value();
|
|
return option.pop_max_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_PKW: {
|
|
std::optional<ATBPaymentOption> po = cfg->getPaymentOptionForKey(permitType);
|
|
if (po.has_value()) {
|
|
ATBPaymentOption option = po.value();
|
|
return option.pop_max_price;
|
|
}
|
|
} break;
|
|
case PERMIT_TYPE::SHORT_TERM_PARKING_CAMPER:
|
|
break;
|
|
default: ;
|
|
}
|
|
|
|
return maxPrice;
|
|
}
|
|
|
|
int CALCULATE_LIBRARY_API get_zone_nr(int zone)
|
|
{
|
|
if(zone > -1) return zone;
|
|
else
|
|
{
|
|
QFile zone("/etc/zone_nr");
|
|
if (zone.exists()) {
|
|
QFileInfo finfo(zone);
|
|
if (finfo.size() <= 4) { // decimal 000\n
|
|
if (zone.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QTextStream in(&zone);
|
|
return in.readLine(100).toInt();
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
CalcState CALCULATE_LIBRARY_API init_tariff(parking_tariff_t **tariff, char const *config_file) {
|
|
*tariff = new Configuration();
|
|
|
|
CalcState calcState;
|
|
#if __linux__
|
|
|
|
int const zone = get_zone_nr();
|
|
|
|
// DEBUG
|
|
qCritical() << "init_tariff:";
|
|
qCritical() << " ... zone = " << zone;
|
|
|
|
if (zone <= 0) {
|
|
delete *tariff;
|
|
*tariff = nullptr;
|
|
return calcState.set(CalcState::State::ERROR_PARSING_ZONE_NR);
|
|
}
|
|
|
|
QString confFile(config_file);
|
|
if (!confFile.endsWith(QChar('/'))) {
|
|
confFile += "/";
|
|
}
|
|
|
|
char buffer[32];
|
|
memset(buffer, 0x00, sizeof(buffer));
|
|
snprintf(buffer, sizeof(buffer)-1, "tariff%02d.json", zone);
|
|
confFile += buffer;
|
|
#else // windows
|
|
QString confFile(config_file);
|
|
#endif
|
|
|
|
// DEBUG
|
|
qCritical() << " ... confFile = " << confFile;
|
|
|
|
QFile fname(confFile);
|
|
if (fname.exists() &&
|
|
fname.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
// DEBUG
|
|
qCritical() << " ... confFile is open";
|
|
|
|
QString json = fname.readAll();
|
|
if (! (*tariff)->ParseJson(*tariff, json.toStdString().c_str())) {
|
|
delete *tariff;
|
|
*tariff = nullptr;
|
|
qCritical() << " ... error parsing tariff";
|
|
return calcState.set(CalcState::State::ERROR_PARSING_TARIFF);
|
|
}
|
|
} else {
|
|
delete *tariff;
|
|
*tariff = nullptr;
|
|
qCritical() << " ... error loading tariff";
|
|
return calcState.set(CalcState::State::ERROR_LOADING_TARIFF);
|
|
}
|
|
|
|
qCritical() << "init_tariff: Parsing tariff config (" << confFile << ")";
|
|
|
|
return calcState;
|
|
}
|
|
|
|
void CALCULATE_LIBRARY_API free_tariff(parking_tariff_t *tariff) {
|
|
if (tariff != nullptr) {
|
|
delete tariff;
|
|
}
|
|
}
|
|
|
|
//
|
|
// UpDown 1 -> up; 0 -> down
|
|
int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int currentTimeMinutes,
|
|
int UpDown, PermitType const &permitType)
|
|
{
|
|
|
|
qCritical() << __LINE__ << "compute_next_timestep() currentTimeMinutes: " << currentTimeMinutes;
|
|
qCritical() << __LINE__ << "compute_next_timestep() up/down (1=up, 0=down): " << UpDown;
|
|
|
|
if (UpDown == 1) {
|
|
if (Calculator::GetInstance().timeLimitReached()) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() time limit reached";
|
|
Calculator::GetInstance().setTimeLimitReached(false);
|
|
Calculator::GetInstance().resetCostAtTimeLimit();
|
|
return currentTimeMinutes;
|
|
}
|
|
}
|
|
|
|
// FIXME
|
|
//std::optional<ATBPaymentOption> paymentOption = tariff->getPaymentOptionForKey(permitType.get());
|
|
//if (!paymentOption.has_value()) {
|
|
// qCritical() << " compute_next_timestep() ERROR";
|
|
// return currentTimeMinutes;
|
|
//}
|
|
|
|
int paymentOptionIndex = getPaymentOptionIndex(*tariff);
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
int const &pop_plus_steps = tariff->getPaymentOptions(paymentOptionIndex).pop_plus_steps;
|
|
int const &pop_minus_steps = tariff->getPaymentOptions(paymentOptionIndex).pop_minus_steps;
|
|
|
|
qCritical() << __LINE__ << "compute_next_timestep() payment option index: " << paymentOptionIndex;
|
|
qCritical() << __LINE__ << "compute_next_timestep() plus steps: " << pop_plus_steps;
|
|
qCritical() << __LINE__ << "compute_next_timestep() minus steps: " << pop_minus_steps;
|
|
|
|
Configuration const *cfg = tariff;
|
|
|
|
// compute payment method id (e.g. Linear=3, Steps=4)
|
|
PaymentMethod const paymentMethodId = Utilities::getPaymentMethodId(cfg);
|
|
switch (paymentMethodId) {
|
|
case PaymentMethod::Progressive:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Progressive";
|
|
break;
|
|
case PaymentMethod::Degressive:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Degressive";
|
|
break;
|
|
case PaymentMethod::Linear:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Linear";
|
|
break;
|
|
case PaymentMethod::Steps:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Steps";
|
|
break;
|
|
case PaymentMethod::Unified:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Unified";
|
|
break;
|
|
case PaymentMethod::Undefined:
|
|
qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Undefined";
|
|
break;
|
|
}
|
|
|
|
// use tariff with structure as for instance Schnau, Koenigsee:
|
|
// without given YearPeriod, SpecialDays and SpecialDaysWorktime
|
|
if ((paymentMethodId == PaymentMethod::Steps) ||
|
|
// progressive tariff: e.g. Neuhauser, Kirchdorf (743)
|
|
(paymentMethodId == PaymentMethod::Progressive) ||
|
|
// unified tariff: starting with Bad Neuenahr (249), Tariff for Zone5
|
|
(paymentMethodId == PaymentMethod::Unified) ||
|
|
// degressive tariff: e.g. Fuchs Technik (500)
|
|
(paymentMethodId == PaymentMethod::Degressive))
|
|
{
|
|
QList<int> &stepList = Calculator::GetInstance().GetTimeSteps(tariff, paymentOptionIndex);
|
|
|
|
int const size = stepList.size();
|
|
if (size == 0) {
|
|
qCritical() << "compute_next_timestep() *ERROR empty step-list*";
|
|
return currentTimeMinutes;
|
|
}
|
|
|
|
qCritical() << __LINE__ << "compute_next_timestep() first time step:" << stepList[0];
|
|
qCritical() << __LINE__ << "compute_next_timestep() timeSteps:" << stepList;
|
|
qCritical() << __LINE__ << "compute_next_timestep() currentTimeInMinutes:" << currentTimeMinutes;
|
|
|
|
// consider time shift: the step-list might have been computed at a
|
|
// slightly different time point
|
|
|
|
int currentStepIndex = stepList.indexOf(currentTimeMinutes);
|
|
if (currentStepIndex == -1) {
|
|
unsigned minimalDistance = ~0;
|
|
int j = -1;
|
|
for (int i = 0; i < stepList.size(); ++i) {
|
|
unsigned distance = std::abs(stepList[i] - currentTimeMinutes);
|
|
if (distance < minimalDistance) {
|
|
minimalDistance = distance;
|
|
j = i;
|
|
}
|
|
}
|
|
// max. tolerance set to 3 minutes
|
|
// unsigned const tolerance = std::min(minimalDistance, (unsigned)(3));
|
|
if (j != -1) {
|
|
stepList[j] = currentTimeMinutes;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
int maxStep = -1;
|
|
if (size >= 2) {
|
|
maxStep = stepList[1] - stepList[0];
|
|
}
|
|
// max. tolerance set to 5 minutes
|
|
int const tolerance = (maxStep == -1) ? 5 : std::min(maxStep, 5);
|
|
for (int i=0; i < stepList.size(); ++i) {
|
|
if (std::abs(stepList[i] - currentTimeMinutes) <= tolerance) {
|
|
qCritical().noquote()
|
|
<< __LINE__ << QString("compute_next_timestep() correction stepList[%1]=%2 -> %3:")
|
|
.arg(i).arg(stepList[0]).arg(currentTimeMinutes);
|
|
stepList[i] = currentTimeMinutes;
|
|
qCritical() << __LINE__ << "compute_next_timestep() NEW timeSteps:" << stepList;
|
|
}
|
|
}
|
|
|
|
int currentStepIndex = stepList.indexOf(currentTimeMinutes);
|
|
#endif
|
|
|
|
currentStepIndex = stepList.indexOf(currentTimeMinutes);
|
|
qCritical() << __LINE__ << "compute_next_timestep() currentStepIndex (" << currentStepIndex << ")";
|
|
|
|
if (currentStepIndex == -1) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() *NO STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
|
return currentTimeMinutes;
|
|
}
|
|
|
|
if (UpDown == 1) { // UP
|
|
if (stepList[currentStepIndex] == stepList.last()) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() *NO NEXT STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
|
return currentTimeMinutes;
|
|
}
|
|
else {
|
|
int const rest = currentStepIndex % pop_plus_steps;
|
|
|
|
if (rest) {
|
|
currentStepIndex -= rest;
|
|
}
|
|
|
|
qCritical() << __LINE__ << "compute_next_timestep() currentStepIndex (" << currentStepIndex << ")";
|
|
|
|
int const nextStepIndex = currentStepIndex + pop_plus_steps;
|
|
|
|
qCritical() << __LINE__ << "compute_next_timestep() next step index:" << nextStepIndex;
|
|
if (nextStepIndex >= 0 && nextStepIndex < stepList.size()) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() return next time step:" << stepList[nextStepIndex];
|
|
return stepList[nextStepIndex];
|
|
}
|
|
}
|
|
}
|
|
if (UpDown == 0) { // DOWN
|
|
if (stepList[currentStepIndex] == stepList.first()) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() *NO PREVIOUS STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
|
return currentTimeMinutes;
|
|
}
|
|
else {
|
|
int const nextStepIndex = currentStepIndex - pop_minus_steps;
|
|
qCritical() << __LINE__ << "compute_next_timestep() next step index:" << nextStepIndex;
|
|
if (nextStepIndex >= 0 && nextStepIndex < stepList.size()) {
|
|
qCritical() << __LINE__ << "compute_next_timestep() return next time step:" << stepList[nextStepIndex];
|
|
return stepList[nextStepIndex];
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
if (paymentMethodId == PaymentMethod::Linear) {
|
|
|
|
// currentTimeMinutes is the number of minutes actually used. This
|
|
// value is an offset from the start time and cannot be used as a
|
|
// QDateTime.
|
|
|
|
qCritical() << "compute_next_timestep() up/down (1=up, 0=down):" << UpDown;
|
|
|
|
// get minimal and maximal parking times
|
|
int const minParkingTime = Utilities::getMinimalParkingTime(cfg, paymentMethodId);
|
|
int const maxParkingTime = Utilities::getMaximalParkingTime(cfg, paymentMethodId);
|
|
|
|
qCritical() << " compute_next_timestep() maxParkingTime:" << maxParkingTime;
|
|
qCritical() << " compute_next_timestep() minParkingTime:" << minParkingTime;
|
|
|
|
// use the first (i.e. main duration step contained in the tariff json-file)
|
|
int firstDurationStep = Utilities::getFirstDurationStep(cfg, paymentMethodId);
|
|
firstDurationStep = ((UpDown == 1) ? firstDurationStep : -firstDurationStep);
|
|
|
|
qCritical() << " compute_next_timestep() firstDurationStep:" << firstDurationStep;
|
|
|
|
int const nextTimeStep = currentTimeMinutes + firstDurationStep;
|
|
|
|
if (nextTimeStep >= minParkingTime && nextTimeStep <= maxParkingTime) {
|
|
qCritical() << " compute_next_timestep() nextTimeStep:" << nextTimeStep;
|
|
return nextTimeStep;
|
|
}
|
|
}
|
|
|
|
qCritical() << "compute_next_timestep() *CAN NOT COMPUTE* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
|
return currentTimeMinutes;
|
|
}
|
|
|
|
// this is currently not used
|
|
CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
|
parking_tariff_t *tariff,
|
|
time_t start_parking_time, // in minutes
|
|
time_t end_parking_time, // netto time in minutes
|
|
struct price_t *price,
|
|
PermitType permitType) { // permitType maps to product
|
|
|
|
CalcState calcState;
|
|
|
|
QDate const d(1970, 1, 1);
|
|
QTime const t(0, 0, 0);
|
|
QDateTime start(d, t, Qt::UTC);
|
|
start = start.toLocalTime().addSecs(start_parking_time * 60);
|
|
QDateTime end(start);
|
|
|
|
int paymentOptionIndex = getPaymentOptionIndex(*tariff, start);
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = tariff->getPaymentOptionIndex(permitType.get());
|
|
}
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "pop_max_price" << tariff->getPaymentOptions(paymentOptionIndex).pop_max_price;
|
|
|
|
tariff->getPaymentOptions(paymentOptionIndex).pop_max_price
|
|
= tariff->getPaymentOptions(paymentOptionIndex).pop_max_price_save;
|
|
|
|
double minMin = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_min_time;
|
|
double maxMin = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_max_time;
|
|
|
|
if (minMin < 0 || maxMin < 0 || maxMin < minMin) {
|
|
calcState.setDesc(QString("minMin=%1, maxMin=%2").arg(minMin).arg(maxMin));
|
|
return calcState.set(CalcState::State::WRONG_PARAM_VALUES);
|
|
}
|
|
|
|
int const duration = end_parking_time - start_parking_time;
|
|
if (duration < 0) {
|
|
calcState.setDesc(QString("end=%1, start=%2")
|
|
.arg(end_parking_time, start_parking_time));
|
|
return calcState.set(CalcState::State::NEGATIVE_PARKING_TIME);
|
|
}
|
|
if (duration > maxMin) {
|
|
calcState.setDesc(QString("duration=%1, maxMin=%2").arg(duration).arg(maxMin));
|
|
return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
|
|
}
|
|
if (duration < minMin) {
|
|
calcState.setDesc(QString("duration=%1, minMin=%2").arg(duration).arg(minMin));
|
|
return calcState.set(CalcState::State::BELOW_MIN_PARKING_TIME);
|
|
}
|
|
if (duration == 0) {
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
//QDate const d(1970, 1, 1);
|
|
//QTime const t(0, 0, 0);
|
|
//QDateTime start(d, t, Qt::UTC);
|
|
//start = start.toLocalTime().addSecs(start_parking_time * 60);
|
|
//QDateTime end(start);
|
|
if (start.isValid()) {
|
|
double cost = Calculator::GetInstance().GetCostFromDuration(
|
|
tariff,
|
|
tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id,
|
|
start,
|
|
end,
|
|
duration, false, true);
|
|
double minCost = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_min_price;
|
|
if (cost < minCost) {
|
|
calcState.setDesc(QString("line=%1 minCost=%2, cost=%3").arg(__LINE__).arg(minCost).arg(cost));
|
|
return calcState.set(CalcState::State::BELOW_MIN_PARKING_PRICE);
|
|
}
|
|
price->units = cost;
|
|
price->netto = cost;
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
|
parking_tariff_t *tariff,
|
|
QDateTime &start_parking_time_,
|
|
int netto_parking_time,
|
|
QDateTime &end_parking_time,
|
|
struct price_t *price,
|
|
PermitType permitType,
|
|
bool prepaid)
|
|
{
|
|
CalcState calcState;
|
|
|
|
QDateTime start_parking_time(start_parking_time_);
|
|
|
|
int paymentOptionIndex = getPaymentOptionIndex(*tariff, start_parking_time);
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
tariff->getPaymentOptions(paymentOptionIndex).pop_max_price
|
|
= tariff->getPaymentOptions(paymentOptionIndex).pop_max_price_save;
|
|
|
|
double minMin = tariff->getPaymentOptions(paymentOptionIndex).pop_min_time;
|
|
double maxMin = tariff->getPaymentOptions(paymentOptionIndex).pop_max_time;
|
|
|
|
// DEBUG
|
|
qCritical() << "compute_price_for_parking_ticket() " << endl
|
|
<< " paymentOptionIndex: " << paymentOptionIndex << endl
|
|
<< " start_parking_time: " << start_parking_time << endl
|
|
<< " netto_parking_time: " << netto_parking_time << endl
|
|
<< " start + netto: " << start_parking_time.addSecs(netto_parking_time * 60) << endl
|
|
<< " minMin: " << minMin << endl
|
|
<< " maxMin: " << maxMin
|
|
<< " prepaid: " << prepaid
|
|
<< " permitType: " << permitType.toString();
|
|
|
|
if (netto_parking_time < 0) {
|
|
calcState.setDesc(QString("end=%1, start=%2")
|
|
.arg(end_parking_time.toString(Qt::ISODate),
|
|
start_parking_time.toString(Qt::ISODate)));
|
|
return calcState.set(CalcState::State::NEGATIVE_PARKING_TIME);
|
|
}
|
|
if (netto_parking_time > maxMin) {
|
|
calcState.setDesc(QString("duration=%1, maxMin=%2").arg(netto_parking_time).arg(maxMin));
|
|
return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
|
|
}
|
|
if (netto_parking_time < minMin) {
|
|
calcState.setDesc(QString("duration=%1, minMin=%2").arg(netto_parking_time).arg(minMin));
|
|
return calcState.set(CalcState::State::BELOW_MIN_PARKING_TIME);
|
|
}
|
|
if (netto_parking_time == 0) {
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
double cost = -1;
|
|
if (start_parking_time.isValid()) {
|
|
if (tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id == PaymentMethod::Steps ||
|
|
tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id == PaymentMethod::Degressive) {
|
|
// hier muesste man unterscheiden: uebertrag oder nicht?
|
|
calcState = Calculator::GetInstance().isParkingAllowed(tariff, start_parking_time,
|
|
netto_parking_time, paymentOptionIndex);
|
|
if (calcState.getStatus() == CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME) {
|
|
qCritical() << "(" << __func__ << ":" << __LINE__ << ")"
|
|
<< calcState.toString();
|
|
return calcState;
|
|
}
|
|
|
|
QList<int> tlist = Calculator::GetInstance().GetTimeSteps(tariff);
|
|
Q_UNUSED(tlist);
|
|
|
|
// compute cost (price)
|
|
cost = Calculator::GetInstance().GetCostFromDuration(tariff, start_parking_time, netto_parking_time, paymentOptionIndex);
|
|
|
|
int weekDay = start_parking_time.date().dayOfWeek();
|
|
int pop_carry_over_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over_option_id;
|
|
int pop_prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
|
|
|
|
std::optional<ATBPeriodYear> yperiod = Utilities::GetYearPeriodActive(tariff, start_parking_time);
|
|
int period_id = -1;
|
|
if (yperiod.has_value()) {
|
|
ATBPeriodYear const &period = yperiod.value();
|
|
period_id = period.pye_id;
|
|
pop_carry_over_option_id = period.pye_id;
|
|
pop_prepaid_option_id = period.pye_id;
|
|
qCritical() << __func__ << ":" << __LINE__ << "re-computed carry-over-id" << pop_carry_over_option_id;
|
|
qCritical() << __func__ << ":" << __LINE__ << " re-computed prepaid-id" << pop_prepaid_option_id;
|
|
}
|
|
|
|
QTime carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
|
|
int carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << " carryOverStart" << carryOverStart.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;
|
|
|
|
|
|
QDateTime effectiveStartTime(start_parking_time);
|
|
|
|
// handle special days
|
|
int const specialDayId = tariff->specialDayId(start_parking_time);
|
|
if (specialDayId > 0) { // found special day
|
|
for (auto[itr, rangeEnd] = tariff->SpecialDaysWorktime.equal_range(specialDayId); itr != rangeEnd; ++itr) {
|
|
ATBSpecialDaysWorktime const &wt = itr->second;
|
|
switch(period_id) {
|
|
case 1: // summer term
|
|
if ((wt.pedwt_paid & 1) == 0) {
|
|
// does not have to be paid, move to next midnight
|
|
|
|
// better: start of next day (falls kein vorkauf besteht)
|
|
effectiveStartTime = effectiveStartTime.addDays(1);
|
|
effectiveStartTime.setTime(QTime(0, 0, 0));
|
|
}
|
|
break;
|
|
case 2: // winter term
|
|
if ((wt.pedwt_paid & 2) == 0) {
|
|
// does not have to be paid, move to next midnight
|
|
|
|
// better: start of next day (falls kein vorkauf besteht)
|
|
effectiveStartTime = effectiveStartTime.addDays(1);
|
|
effectiveStartTime.setTime(QTime(0, 0, 0));
|
|
}
|
|
break;
|
|
default:;
|
|
}
|
|
}
|
|
}
|
|
|
|
// handle prepaid option
|
|
int const prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
|
|
std::optional<ATBPrepaid> prepaidOption = tariff->getPrepaidType(prepaid_option_id);
|
|
if (prepaidOption.has_value()) {
|
|
ATBPrepaid const &p = prepaidOption.value();
|
|
if (p.never) {
|
|
qCritical() << __func__ << ":" << __LINE__ << "prepaid: no";
|
|
} else {
|
|
qCritical() << __func__ << ":" << __LINE__ << " prepaidStart" << p.prepaid[weekDay].static_start.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << " prepaidEnd" << p.prepaid[weekDay].static_end.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "prepaid duration" << p.prepaid[weekDay].duration;
|
|
|
|
if (start_parking_time.time() < p.prepaid[weekDay].static_end) { // static_end: e.g. 08:00:00
|
|
effectiveStartTime.setTime(p.prepaid[weekDay].static_end);
|
|
} else
|
|
if (start_parking_time.time() > p.prepaid[weekDay].static_start) { // static_start: e.g. 22:00:00
|
|
effectiveStartTime.setTime(p.prepaid[weekDay].static_start);
|
|
}
|
|
}
|
|
}
|
|
|
|
effectiveStartTime.setTime(QTime(effectiveStartTime.time().hour(),
|
|
effectiveStartTime.time().minute(), 0));
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:" << effectiveStartTime.toString(Qt::ISODate);
|
|
|
|
int const carryOver = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << " carryOver flag" << carryOver;
|
|
|
|
if (carryOver == 1) {
|
|
QTime carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
|
|
int carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << " carryOverStart" << carryOverStart.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;
|
|
|
|
// handle carry over
|
|
int minutesUntilCarryOver = effectiveStartTime.time().secsTo(carryOverStart) / 60;
|
|
if ((minutesUntilCarryOver > 0) && (netto_parking_time > minutesUntilCarryOver)) {
|
|
int const rest = netto_parking_time - minutesUntilCarryOver;
|
|
QDateTime s(effectiveStartTime);
|
|
s = s.addSecs(minutesUntilCarryOver * 60);
|
|
s = s.addSecs(carryOverDuration * 60);
|
|
end_parking_time = s.addSecs(rest * 60);
|
|
} else {
|
|
end_parking_time = effectiveStartTime.addSecs(netto_parking_time*60);
|
|
}
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
|
|
|
|
weekDay = end_parking_time.date().dayOfWeek();
|
|
|
|
// musste man in einer schleife machen
|
|
carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
|
|
carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;
|
|
|
|
if (end_parking_time.time() > carryOverStart) {
|
|
end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
|
|
} else
|
|
if (end_parking_time.time() == carryOverStart) {
|
|
qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << " carryOverStart" << carryOverStart.toString(Qt::ISODate);
|
|
ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
|
|
if (po.pop_apply_carry_over_to_ticket_endtime) {
|
|
end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
|
|
qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
|
|
}
|
|
}
|
|
} else {
|
|
qCritical() << __func__ << ":" << __LINE__ << "NO carryOver configured";
|
|
end_parking_time = effectiveStartTime.addSecs(netto_parking_time*60);
|
|
}
|
|
|
|
end_parking_time.setTime(QTime(end_parking_time.time().hour(),
|
|
end_parking_time.time().minute(), 0));
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << " week-day:" << weekDay;
|
|
|
|
for (auto[itr, rangeEnd] = tariff->WeekDays.equal_range((Qt::DayOfWeek)weekDay); itr != rangeEnd; ++itr) {
|
|
ATBWeekDay const &wd = itr->second;
|
|
bool const parkTimeLimitViolated = wd.getTariffCarryOverSettings().parkingTimeLimitExceeded(effectiveStartTime,
|
|
end_parking_time,
|
|
paymentOptionIndex);
|
|
if (parkTimeLimitViolated) {
|
|
//QTime const &tlimit = wd.getTariffCarryOverSettings().parkingTimeLimit();
|
|
//end_parking_time.setTime(tlimit);
|
|
|
|
// max_price neu berechnen
|
|
|
|
calcState.setDesc(QString("line=%1 endTime=%2: park-time-limit violated").arg(__LINE__)
|
|
.arg(end_parking_time.time().toString(Qt::ISODate)));
|
|
return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
|
|
}
|
|
}
|
|
} else
|
|
if (tariff->getPaymentOptions(0).pop_payment_method_id == PaymentMethod::Unified) {
|
|
std::pair<CalcState, std::optional<int>> p =
|
|
Calculator::GetInstance().ComputeCostFromDuration(tariff, start_parking_time, end_parking_time, netto_parking_time);
|
|
CalcState const cs = p.first;
|
|
|
|
if ((cs.getStatus() == CalcState::State::SUCCESS ||
|
|
cs.getStatus() == CalcState::State::SUCCESS_MAXPRICE ||
|
|
cs.getStatus() == CalcState::State::OVERPAID)) {
|
|
if (p.second.has_value()) {
|
|
cost = p.second.value();
|
|
}
|
|
} else {
|
|
return cs;
|
|
}
|
|
} else {
|
|
cost = Calculator::GetInstance().GetCostFromDuration(
|
|
tariff,
|
|
tariff->getPaymentOptions().pop_payment_method_id,
|
|
start_parking_time, // starting time
|
|
end_parking_time, // return value: end time
|
|
netto_parking_time, // minutes, netto
|
|
false, prepaid);
|
|
}
|
|
|
|
double minCost = tariff->getPaymentOptions(paymentOptionIndex).pop_min_price;
|
|
if (cost < minCost) {
|
|
calcState.setDesc(QString("line=%1 minCost=%2, cost=%3").arg(__LINE__).arg(minCost).arg(cost));
|
|
return calcState.set(CalcState::State::BELOW_MIN_PARKING_PRICE);
|
|
}
|
|
|
|
// DEBUG
|
|
//qCritical() << __LINE__ << " end_parking_time: " << end_parking_time;
|
|
//qCritical() << __LINE__ << " -> calculated cost (netto): " << cost;
|
|
|
|
price->brutto = price->vat = price->vat_percentage = 0;
|
|
price->units = cost;
|
|
price->netto = cost;
|
|
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
|
|
if (end_parking_time.time().hour() == 0 && end_parking_time.time().minute() == 0) {
|
|
end_parking_time = end_parking_time.addDays(-1);
|
|
end_parking_time.setTime(QTime(23, 59, 0));
|
|
}
|
|
qCritical() << __func__ << __LINE__ << "end_parking_time" << end_parking_time.toString(Qt::ISODate);
|
|
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
|
parking_tariff_t *tariff,
|
|
time_t start_parking_time,
|
|
double price,
|
|
QString &duration,
|
|
PermitType permitType) {
|
|
|
|
tariff->getPaymentOptions(0).pop_max_price
|
|
= tariff->getPaymentOptions(0).pop_max_price_save;
|
|
|
|
CalcState calcState;
|
|
QDate const d(1970, 1, 1);
|
|
QTime const t(0, 0, 0);
|
|
QDateTime start(d, t, Qt::UTC);
|
|
start = start.toLocalTime().addSecs(start_parking_time * 60);
|
|
if (start.isValid()) {
|
|
QString cs = start.toString(Qt::ISODate);
|
|
|
|
bool prepaid = true;
|
|
int paymentOptionIndex = getPaymentOptionIndex(*tariff, start);
|
|
qCritical() << " payment option index: " << paymentOptionIndex;
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
int prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
|
|
if (prepaid_option_id == 2) { // see tariff03.json for 502: 2 means no prepaid-option
|
|
prepaid = false;
|
|
}
|
|
bool const nextDay = false;
|
|
|
|
// DEBUG
|
|
qCritical() << "compute_duration_for_parking_ticket(1): ";
|
|
qCritical() << " payment option index: " << paymentOptionIndex;
|
|
qCritical() << " prepaid: " << prepaid;
|
|
qCritical() << " start (cs): " << cs;
|
|
qCritical() << " price: " << price;
|
|
|
|
std::pair<std::string, QDateTime> p_duration
|
|
= Calculator::GetInstance().GetDurationFromCost(tariff,
|
|
tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id,
|
|
cs.toLocal8Bit().constData(),
|
|
price, permitType, nextDay, prepaid);
|
|
duration = p_duration.first.c_str();
|
|
|
|
|
|
QDateTime d = QDateTime::fromString(duration, Qt::ISODate);
|
|
if (!d.isValid()) {
|
|
calcState.setDesc(QString("ticketEndTime=%1").arg(duration));
|
|
return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
|
|
}
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
|
parking_tariff_t *tariff,
|
|
QDateTime const &start_parking_time,
|
|
double price,
|
|
QDateTime &ticketEndTime,
|
|
PermitType permitType)
|
|
{
|
|
tariff->getPaymentOptions(0).pop_max_price
|
|
= tariff->getPaymentOptions(0).pop_max_price_save;
|
|
|
|
CalcState calcState;
|
|
|
|
bool prepaid = true;
|
|
|
|
int paymentOptionIndex = getPaymentOptionIndex(*tariff, start_parking_time);
|
|
qCritical() << __func__ << ":" << __LINE__ << "payment option index: " << paymentOptionIndex;
|
|
if (paymentOptionIndex == -1) {
|
|
paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
|
|
}
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << " payment option index: " << paymentOptionIndex;
|
|
|
|
int prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
|
|
|
|
if (prepaid_option_id == 2) {
|
|
prepaid = false;
|
|
}
|
|
bool const nextDay = false;
|
|
|
|
// DEBUG
|
|
if (DBG_LEVEL >= DBG_DEBUG) {
|
|
qCritical() << "compute_duration_for_parking_ticket(2): ";
|
|
qCritical() << " payment option index: " << paymentOptionIndex;
|
|
qCritical() << " prepaid: " << prepaid;
|
|
qCritical() << " price: " << price;
|
|
}
|
|
|
|
if (start_parking_time.isValid()) {
|
|
|
|
int const pop_time_step_config = tariff->getPaymentOptions(paymentOptionIndex).pop_time_step_config;
|
|
if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::STATIC) {
|
|
// handle prepaid option
|
|
QDateTime effectiveStartTime(start_parking_time);
|
|
|
|
effectiveStartTime.setTime(QTime(effectiveStartTime.time().hour(),
|
|
effectiveStartTime.time().minute(), 0));
|
|
|
|
int const prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
|
|
std::optional<ATBPrepaid> prepaidOption = tariff->getPrepaidType(prepaid_option_id);
|
|
if (prepaidOption.has_value()) {
|
|
ATBPrepaid const &p = prepaidOption.value();
|
|
if (p.never) {
|
|
qCritical() << __func__ << __LINE__ << "prepaid: no";
|
|
} else {
|
|
if (start_parking_time.time() < p.static_end) { // static_end: e.g. 08:00:00
|
|
effectiveStartTime.setTime(p.static_end);
|
|
} else
|
|
if (start_parking_time.time() > p.static_start) { // static_start: e.g. 22:00:00
|
|
effectiveStartTime.setTime(p.static_start);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
QDateTime start(start_parking_time);
|
|
start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
|
|
QString cs = start.toString(Qt::ISODate);
|
|
|
|
std::pair<std::string, QDateTime> p_endTime
|
|
= Calculator::GetInstance().GetDurationFromCost(
|
|
tariff,
|
|
tariff->getPaymentOptions().pop_payment_method_id,
|
|
cs.toLocal8Bit().constData(),
|
|
price, permitType, nextDay, prepaid);
|
|
|
|
QString endTime = p_endTime.first.c_str();
|
|
ticketEndTime = p_endTime.second;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << endTime;
|
|
qCritical() << __func__ << ":" << __LINE__ << ticketEndTime.toString(Qt::ISODate);
|
|
|
|
if (endTime == CalcState::SUCCESS) {
|
|
calcState.setDesc(QString("SUCCESS"));
|
|
calcState.setStatus(endTime);
|
|
qCritical() << __func__ << ":" << __LINE__ << "SUCCESS";
|
|
} else
|
|
if (endTime == CalcState::SUCCESS_MAXPRICE) {
|
|
calcState.setDesc(QString("SUCCESS_MAXPRICE"));
|
|
calcState.setStatus(endTime);
|
|
qCritical() << __func__ << ":" << __LINE__ << "SUCCESS_MAXPRICE";
|
|
} else
|
|
if (endTime == CalcState::ERROR_PARSING_ZONE_NR) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::ERROR_LOADING_TARIFF) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::ERROR_PARSING_TARIFF) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::NEGATIVE_PARKING_TIME) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::INVALID_START_DATE) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::WRONG_PARAM_VALUES) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::WRONG_ISO_TIME_FORMAT) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::ABOVE_MAX_PARKING_TIME) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::BELOW_MIN_PARKING_TIME) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::BELOW_MIN_PARKING_PRICE) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::ABOVE_MAX_PARKING_PRICE) {
|
|
calcState.setDesc(CalcState::ABOVE_MAX_PARKING_PRICE);
|
|
calcState.setStatus(CalcState::ABOVE_MAX_PARKING_PRICE);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::OVERPAID) {
|
|
calcState.setDesc(CalcState::OVERPAID);
|
|
calcState.setStatus(CalcState::OVERPAID);
|
|
return calcState;
|
|
} else
|
|
if (endTime == CalcState::OUTSIDE_ALLOWED_PARKING_TIME) {
|
|
calcState.setStatus(endTime);
|
|
return calcState;
|
|
} else {
|
|
ticketEndTime = QDateTime::fromString(endTime,Qt::ISODate);
|
|
|
|
ticketEndTime.setTime(QTime(ticketEndTime.time().hour(),
|
|
ticketEndTime.time().minute(), 0));
|
|
|
|
int netto_parking_time = start_parking_time.secsTo(ticketEndTime) / 60;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "step-config:" << pop_time_step_config;
|
|
qCritical() << __func__ << ":" << __LINE__ << "netto-parking-time" << netto_parking_time;
|
|
|
|
if (!ticketEndTime.isValid()) {
|
|
calcState.setDesc(QString("ticketEndTime=%1").arg(endTime));
|
|
return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
|
|
}
|
|
|
|
if (tariff->getPaymentOptions().pop_payment_method_id != PaymentMethod::Unified) {
|
|
|
|
if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::STATIC) {
|
|
// handle carry over for ticket-end-time
|
|
qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
|
|
|
|
int weekDay = start_parking_time.date().dayOfWeek();
|
|
int pop_carry_over_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over_option_id;
|
|
qCritical() << __func__ << ":" << __LINE__ << "configured carry-over-id" << pop_carry_over_option_id;
|
|
|
|
std::optional<ATBPeriodYear> yperiod = Utilities::GetYearPeriodActive(tariff, start_parking_time);
|
|
if (yperiod.has_value()) {
|
|
ATBPeriodYear const &period = yperiod.value();
|
|
pop_carry_over_option_id = period.pye_id;
|
|
qCritical() << __func__ << ":" << __LINE__ << "re-computed carry-over-id" << pop_carry_over_option_id;
|
|
}
|
|
|
|
QTime carryOverStart;
|
|
QTime carryOverEnd;
|
|
int carryOverDuration = -1;
|
|
|
|
// using TariffCarryOverType = std::multimap<int, ATBCarryOver>;
|
|
std::multimap<int, ATBCarryOver>::const_iterator it;
|
|
if ((it = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)) !=
|
|
tariff->TariffCarryOverOptions.cend()) {
|
|
carryOverStart = it->second.carryover[weekDay].static_start;
|
|
carryOverEnd = it->second.carryover[weekDay].static_end;
|
|
carryOverDuration = it->second.carryover[weekDay].duration;
|
|
}
|
|
|
|
if (carryOverStart.isValid() && carryOverEnd.isValid()) {
|
|
qCritical() << __func__ << ":" << __LINE__ << "carryOverStart" << carryOverStart.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "carryOverEnd" << carryOverEnd.toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;
|
|
}
|
|
|
|
if (carryOverStart.isValid() && carryOverEnd.isValid() && carryOverDuration != -1) {
|
|
|
|
// note: in such a case (direct coins) carry-over has been handled
|
|
// already in GetDurationFromCost()
|
|
netto_parking_time -= carryOverDuration;
|
|
qCritical() << __func__ << ":" << __LINE__ << "netto-parking-time" << netto_parking_time;
|
|
|
|
// qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
if (ticketEndTime.time() > carryOverStart) {
|
|
// qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
|
|
} else
|
|
if (ticketEndTime.time() == carryOverStart) {
|
|
qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
qCritical() << __func__ << ":" << __LINE__ << " carryOverStart" << carryOverStart.toString(Qt::ISODate);
|
|
ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
|
|
if (po.pop_apply_carry_over_to_ticket_endtime) {
|
|
ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
|
|
qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
}
|
|
} else {
|
|
// qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
if (ticketEndTime.time() < carryOverEnd) {
|
|
// qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
|
|
ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
|
|
}
|
|
}
|
|
} else {
|
|
qCritical() << __func__ << ":" << __LINE__ << "WARNING: wrong carry-over-settings";
|
|
}
|
|
}
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
|
|
|
|
for (auto[itr, rangeEnd] = tariff->WeekDays.equal_range((Qt::DayOfWeek)(ticketEndTime.date().dayOfWeek()));
|
|
itr != rangeEnd;
|
|
++itr) {
|
|
ATBWeekDay const &wd = itr->second;
|
|
bool parkTimeLimitViolated = wd.getTariffCarryOverSettings().parkingTimeLimitExceeded(start_parking_time,
|
|
ticketEndTime,
|
|
paymentOptionIndex);
|
|
if (parkTimeLimitViolated) {
|
|
//QTime const &tlimit = wd.getTariffCarryOverSettings().parkingTimeLimit();
|
|
//ticketEndTime.setTime(tlimit);
|
|
|
|
QList<int> const &stepList = Calculator::GetInstance().GetTimeSteps(tariff, paymentOptionIndex);
|
|
|
|
QDateTime newTicketEndTime = ticketEndTime;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "PARK-TIME VIOLATED";
|
|
|
|
for (int i = stepList.size() - 1; i > 0; --i) {
|
|
// qCritical() << __func__ << ":" << __LINE__ << "step[" << i << "]" << stepList.at(i);
|
|
|
|
if (netto_parking_time > 0 && stepList.at(i) <= netto_parking_time) {
|
|
int const diff = stepList.at(i-1) - stepList.at(i);
|
|
newTicketEndTime = newTicketEndTime.addSecs(diff * 60);
|
|
|
|
// qCritical() << __func__ << ":" << __LINE__ << "new-ticket-end-time" << newTicketEndTime.toString(Qt::ISODate);
|
|
|
|
parkTimeLimitViolated
|
|
= wd.getTariffCarryOverSettings()
|
|
.parkingTimeLimitExceeded(start_parking_time, newTicketEndTime, paymentOptionIndex);
|
|
|
|
if (!parkTimeLimitViolated) {
|
|
|
|
qCritical() << __func__ << ":" << __LINE__
|
|
<< "PARK-TIME NOT VIOLATED FOR" << newTicketEndTime.toString(Qt::ISODate);
|
|
|
|
int duration = stepList.at(i-1);
|
|
|
|
// qCritical() << __func__ << ":" << __LINE__ << "duration" << duration;
|
|
|
|
std::multimap<int, ATBDuration>::const_iterator it;
|
|
for (it = tariff->Duration.cbegin();
|
|
it != tariff->Duration.cend();
|
|
++it) {
|
|
if (duration == it->second.pun_duration) {
|
|
|
|
// qCritical() << __func__ << ":" << __LINE__ << "duration" << duration;
|
|
|
|
ATBPaymentOption &po = tariff->getPaymentOptions(paymentOptionIndex);
|
|
int const pop_id = po.pop_id;
|
|
for (auto[itr, rangeEnd] = tariff->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
|
|
int const durationId = itr->second.pra_payment_unit_id;
|
|
|
|
// qCritical() << __func__ << ":" << __LINE__ << "durationId" << durationId << it->second.pun_id;
|
|
|
|
// note: for this to work, Duration and PaymentRate must have
|
|
// exactly the same structure
|
|
if (durationId == it->second.pun_id) {
|
|
int const pra_price = itr->second.pra_price;
|
|
po.pop_max_price = pra_price;
|
|
|
|
qCritical() << __func__ << ":" << __LINE__ << "new max-price" << po.pop_max_price;
|
|
|
|
// note: ABOVE_MAX_PARKING_TIME would also be possible
|
|
// but here max-parking-time is dynamic. And for
|
|
// this dynamic value, opverpaid is actually correct
|
|
|
|
calcState.setDesc(CalcState::OVERPAID);
|
|
calcState.setStatus(CalcState::OVERPAID);
|
|
return calcState;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
calcState.setDesc(QString("line=%1 endTime=%2: park-time-limit violated").arg(__LINE__)
|
|
.arg(ticketEndTime.time().toString(Qt::ISODate)));
|
|
return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ticketEndTime.time().hour() == 0 && ticketEndTime.time().minute() == 0) {
|
|
ticketEndTime = ticketEndTime.addDays(-1);
|
|
ticketEndTime.setTime(QTime(23, 59, 0));
|
|
}
|
|
|
|
// DEBUG
|
|
qCritical() << __func__ << ":" << __LINE__ << " endTime:" << endTime;
|
|
qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
|
|
}
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
|
|
//return calcState.set(CalcState::State::SUCCESS);
|
|
qCritical() << __func__ << ":" << __LINE__ << " calcState" << calcState.toString();
|
|
return calcState;
|
|
}
|
|
|
|
CalcState CALCULATE_LIBRARY_API compute_duration_for_daily_ticket(parking_tariff_t *tariff,
|
|
QDateTime const &start_parking_time,
|
|
QDateTime &ticketEndTime,
|
|
PermitType /* PermitType */)
|
|
{
|
|
tariff->getPaymentOptions(0).pop_max_price
|
|
= tariff->getPaymentOptions(0).pop_max_price_save;
|
|
|
|
CalcState calcState;
|
|
if (start_parking_time.isValid()) {
|
|
|
|
ticketEndTime = Calculator::GetInstance().GetDailyTicketDuration(tariff,
|
|
start_parking_time,
|
|
tariff->getPaymentOptions().pop_payment_method_id,
|
|
false); // carry over
|
|
|
|
// DEBUG
|
|
qCritical() << "compute_duration_for_daily_ticket(): ";
|
|
qCritical() << " ticketEndTime: " << ticketEndTime;
|
|
|
|
if (!ticketEndTime.isValid()) {
|
|
calcState.setDesc(QString("ticketEndTime=%1").arg(ticketEndTime.toString(Qt::ISODate)));
|
|
return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
|
|
}
|
|
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|
|
|
|
CalcState CALCULATE_LIBRARY_API compute_price_for_daily_ticket(
|
|
parking_tariff_t *tariff,
|
|
QDateTime const &startDatetime,
|
|
QDateTime &endDatetime,
|
|
PERMIT_TYPE permitType,
|
|
struct price_t *price) {// return value
|
|
|
|
tariff->getPaymentOptions(0).pop_max_price
|
|
= tariff->getPaymentOptions(0).pop_max_price_save;
|
|
|
|
CalcState calcState;
|
|
|
|
if (startDatetime.isValid()) {
|
|
if (std::optional<struct price_t> p =
|
|
Calculator::GetInstance().GetDailyTicketPrice(tariff,
|
|
startDatetime,
|
|
endDatetime,
|
|
permitType)) {
|
|
*price = p.value();
|
|
}
|
|
} else {
|
|
return calcState.set(CalcState::State::INVALID_START_DATE);
|
|
}
|
|
return calcState.set(CalcState::State::SUCCESS);
|
|
}
|
|
|