Compare commits
No commits in common. "master" and "kleipeda-experimental-snapshot-2024-09-12" have entirely different histories.
master
...
kleipeda-e
@ -1,83 +0,0 @@
|
||||
#ifndef ATB_TIME_H_INCLUDED
|
||||
#define ATB_TIME_H_INCLUDED
|
||||
|
||||
#include <QDateTime>
|
||||
|
||||
class ATBTime {
|
||||
static QDateTime const m_end;
|
||||
mutable QDateTime m_time;
|
||||
|
||||
public:
|
||||
explicit ATBTime();
|
||||
explicit ATBTime(int h, int m, int s = 0, int ms = 0);
|
||||
explicit ATBTime(QString const &time);
|
||||
explicit ATBTime(QTime const &time);
|
||||
|
||||
explicit ATBTime(ATBTime const &atbTime) {
|
||||
m_time = atbTime.m_time;
|
||||
}
|
||||
|
||||
ATBTime &operator=(ATBTime && atbTime) {
|
||||
m_time = std::move(atbTime.m_time);
|
||||
return *this;
|
||||
}
|
||||
|
||||
ATBTime &operator=(ATBTime const &atbTime) {
|
||||
m_time = atbTime.m_time;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
int hour() const { return m_time.time().hour(); }
|
||||
int minute() const { return m_time.time().minute(); }
|
||||
int second() const { return m_time.time().second(); }
|
||||
int msec() const { return m_time.time().msec(); }
|
||||
|
||||
int secsTo(QString const &t) const {
|
||||
if (t == "24:00:00") {
|
||||
return m_time.secsTo(m_end);
|
||||
}
|
||||
return m_time.time().secsTo(QTime::fromString(t, Qt::ISODate));
|
||||
}
|
||||
|
||||
int msecsTo(QTime t) const { return m_time.time().msecsTo(t); }
|
||||
|
||||
bool setHMS(int h, int m, int s, int ms = 0);
|
||||
|
||||
bool isNull() const { return m_time.time().isNull(); }
|
||||
bool isValid() const { return m_time.time().isValid(); }
|
||||
|
||||
|
||||
QTime addMSecs(int ms) const;
|
||||
QTime addMSecs(int ms);
|
||||
|
||||
QTime addSecs(int s) const;
|
||||
QTime addSecs(int s);
|
||||
|
||||
int msecsSinceStartOfDay() const;
|
||||
QString toString(Qt::DateFormat format = Qt::TextDate) const;
|
||||
|
||||
|
||||
static bool isValid(int h, int m, int s, int ms = 0);
|
||||
|
||||
static QTime currentTime() { return QDateTime::currentDateTime().time(); }
|
||||
|
||||
static constexpr QTime fromMSecsSinceStartOfDay(int msecs);
|
||||
|
||||
static QTime fromString(QString const &string, Qt::DateFormat format = Qt::TextDate);
|
||||
static QTime fromString(QString const &string, const QString &format);
|
||||
|
||||
friend bool operator!=(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator<(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator<=(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator>=(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator<(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator>(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend bool operator==(const ATBTime &lhs, const ATBTime &rhs) noexcept;
|
||||
friend QDataStream &operator<<(QDataStream &out, ATBTime const &time);
|
||||
friend QDebug &operator<<(QDebug &out, ATBTime const &time);
|
||||
friend QDataStream &operator>>(QDataStream &in, ATBTime &time);
|
||||
};
|
||||
|
||||
|
||||
#endif // ATB_TIME_H_INCLUDED
|
||||
@ -56,7 +56,6 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
static QString const ABOVE_MAX_PARKING_PRICE;
|
||||
static QString const OVERPAID;
|
||||
static QString const OUTSIDE_ALLOWED_PARKING_TIME;
|
||||
static QString const SUCCESS_MAXPRICE;
|
||||
|
||||
enum class State : uint8_t {
|
||||
SUCCESS,
|
||||
@ -72,8 +71,7 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
BELOW_MIN_PARKING_PRICE,
|
||||
ABOVE_MAX_PARKING_PRICE,
|
||||
OVERPAID,
|
||||
OUTSIDE_ALLOWED_PARKING_TIME,
|
||||
SUCCESS_MAXPRICE
|
||||
OUTSIDE_ALLOWED_PARKING_TIME
|
||||
};
|
||||
|
||||
State m_status;
|
||||
@ -90,9 +88,9 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
, m_desc(desc) {
|
||||
}
|
||||
|
||||
explicit CalcState(State state, QString desc,
|
||||
QTime const &from,
|
||||
QTime const &until)
|
||||
explicit CalcState(State state, QString desc = "",
|
||||
QTime const &from = QTime(),
|
||||
QTime const &until = QTime())
|
||||
: m_status(state)
|
||||
, m_desc(desc)
|
||||
, m_allowedTimeRange(from, until) {
|
||||
@ -108,9 +106,6 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
case State::SUCCESS:
|
||||
s = CalcState::SUCCESS;
|
||||
break;
|
||||
case State::SUCCESS_MAXPRICE:
|
||||
s = CalcState::SUCCESS_MAXPRICE;
|
||||
break;
|
||||
case State::ERROR_PARSING_ZONE_NR:
|
||||
s = CalcState::ERROR_PARSING_ZONE_NR;
|
||||
break;
|
||||
@ -163,9 +158,6 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
case State::SUCCESS:
|
||||
s = CalcState::SUCCESS;
|
||||
break;
|
||||
case State::SUCCESS_MAXPRICE:
|
||||
s = CalcState::SUCCESS_MAXPRICE;
|
||||
break;
|
||||
case State::ERROR_PARSING_ZONE_NR:
|
||||
s = CalcState::ERROR_PARSING_ZONE_NR;
|
||||
break;
|
||||
@ -215,9 +207,6 @@ struct CALCULATE_LIBRARY_API CalcState {
|
||||
if (desc == SUCCESS) {
|
||||
m_status = State::SUCCESS;
|
||||
} else
|
||||
if (desc == SUCCESS_MAXPRICE) {
|
||||
m_status = State::SUCCESS_MAXPRICE;
|
||||
}
|
||||
if (desc == ERROR_PARSING_ZONE_NR) {
|
||||
m_status = State::ERROR_PARSING_ZONE_NR;
|
||||
} else
|
||||
|
||||
@ -27,16 +27,9 @@ class Calculator {
|
||||
QDateTime const &start,
|
||||
int netto_parking_time,
|
||||
int paymentOptionIndex);
|
||||
struct State {
|
||||
bool m_timeLimitReached;
|
||||
uint32_t m_costAtTimeLimit;
|
||||
} m_state;
|
||||
|
||||
protected:
|
||||
explicit Calculator() {
|
||||
m_state.m_timeLimitReached = false;
|
||||
m_state.m_costAtTimeLimit = ~0;
|
||||
}
|
||||
explicit Calculator() = default;
|
||||
|
||||
public:
|
||||
Calculator(Calculator const &other) = delete;
|
||||
@ -47,12 +40,6 @@ public:
|
||||
return c;
|
||||
}
|
||||
|
||||
bool timeLimitReached() const { return m_state.m_timeLimitReached; }
|
||||
void setTimeLimitReached(bool timeLimitReached) { m_state.m_timeLimitReached = timeLimitReached; }
|
||||
bool costAtTimeLimit() const { return m_state.m_costAtTimeLimit; }
|
||||
void setCostAtTimeLimit(uint32_t cost) { if (m_state.m_costAtTimeLimit > cost) m_state.m_costAtTimeLimit = cost; }
|
||||
void resetCostAtTimeLimit() { m_state.m_costAtTimeLimit = ~0; }
|
||||
|
||||
void ResetTimeSteps(int paymentOptionIndex) {
|
||||
if (m_timeSteps.size() > 0 && paymentOptionIndex < m_timeSteps.size()) {
|
||||
m_timeSteps[paymentOptionIndex].clear();
|
||||
@ -86,7 +73,7 @@ public:
|
||||
/// <returns>Returns duration in seconds (data type: double)</returns>
|
||||
std::pair<std::string, QDateTime>
|
||||
GetDurationFromCost(Configuration* cfg, uint8_t vehicle_type, char const* start_datetime, double price,
|
||||
PermitType permitType, bool nextDay = false, bool prepaid = false);
|
||||
PermitType permitType, bool nextDay = false, bool prepaid = false);
|
||||
|
||||
/// <summary>
|
||||
/// Gets cost from duration in seconds
|
||||
@ -100,9 +87,6 @@ public:
|
||||
double GetCostFromDuration(Configuration* cfg, uint8_t vehicle_type, QDateTime &start_datetime, QDateTime & end_datetime, int durationMin,
|
||||
PermitType permitType, bool nextDay = false, bool prepaid = false);
|
||||
|
||||
std::pair<CalcState, QDateTime> ComputeDurationFromCost(Configuration *cfg, QDateTime const &startDatetimePassed, int cost);
|
||||
std::pair<CalcState, std::optional<int>> ComputeCostFromDuration(Configuration *cfg, QDateTime const &startDatetime, QDateTime &endDatetime, int nettoParkingTime);
|
||||
|
||||
// Daily ticket
|
||||
QDateTime GetDailyTicketDuration(Configuration* cfg, const QDateTime start_datetime, uint8_t payment_option, bool carry_over);
|
||||
std::optional<struct price_t> GetDailyTicketPrice(Configuration* cfg, QDateTime const &startDatetime, QDateTime &endTime, PERMIT_TYPE permitType);
|
||||
|
||||
@ -29,8 +29,6 @@
|
||||
#include "tariff_prepaid.h"
|
||||
#include "tariff_carryover.h"
|
||||
#include "tariff_permit_type.h"
|
||||
#include "tariff_service.h"
|
||||
#include "tariff_out_of_service.h"
|
||||
|
||||
#include <QVector>
|
||||
#include <optional>
|
||||
@ -52,10 +50,6 @@ public:
|
||||
using TariffPrepaidType = std::multimap<int, ATBPrepaid>;
|
||||
using TariffCarryOverType = std::multimap<int, ATBCarryOver>;
|
||||
using TariffDurationType = std::multimap<int, ATBDuration>;
|
||||
using TariffServiceType = std::multimap<int, ATBTariffService>;
|
||||
using TariffOutOfServiceType = std::multimap<int, ATBTariffOutOfService>;
|
||||
using ATBTariffPrepaidType = std::multimap<int, ATBTariffPrepaid>;
|
||||
using ATBTariffCarryOverType = std::multimap<int, ATBTariffCarryOver>;
|
||||
|
||||
ATBProject project;
|
||||
ATBCurrency Currency;
|
||||
@ -79,10 +73,6 @@ public:
|
||||
TariffInterpolationType TariffInterpolations;
|
||||
TariffPrepaidType TariffPrepaidOptions;
|
||||
TariffCarryOverType TariffCarryOverOptions;
|
||||
TariffServiceType TariffServices;
|
||||
TariffOutOfServiceType TariffOutOfServices;
|
||||
ATBTariffPrepaidType TariffPrepaids;
|
||||
ATBTariffCarryOverType TariffCarryOvers;
|
||||
|
||||
/// <summary>
|
||||
/// Parse JSON string
|
||||
|
||||
@ -6,8 +6,7 @@ enum PaymentMethod {
|
||||
Progressive = 0x01,
|
||||
Degressive = 0x02,
|
||||
Linear = 0x03,
|
||||
Steps = 0x04,
|
||||
Unified = 0x05
|
||||
Steps = 0x04
|
||||
};
|
||||
|
||||
#endif // PAYMENT_METHOD_H_INCLUDED
|
||||
|
||||
@ -25,7 +25,6 @@ public:
|
||||
pop_max_time = 0;
|
||||
pop_min_price = 0;
|
||||
pop_max_price = 0;
|
||||
pop_max_price_save = 0;
|
||||
pop_carry_over = -1;
|
||||
pop_carry_over_option_id = -1;
|
||||
pop_prepaid_option_id = -1;
|
||||
@ -62,7 +61,6 @@ public:
|
||||
double pop_max_time;
|
||||
double pop_min_price;
|
||||
double pop_max_price;
|
||||
double pop_max_price_save;
|
||||
int pop_carry_over;
|
||||
int pop_carry_over_option_id;
|
||||
bool pop_truncate_last_interpolation_step;
|
||||
|
||||
@ -3,111 +3,6 @@
|
||||
|
||||
#include <QTime>
|
||||
|
||||
#include "time_range.h"
|
||||
|
||||
enum class ApplyCarryOver {
|
||||
NEVER = 0,
|
||||
MATCH_PREV_DAY = 1,
|
||||
MATCH_NEXT_DAY = 2,
|
||||
ALWAYS = 3
|
||||
};
|
||||
|
||||
struct ATBTariffCarryOver {
|
||||
int m_id;
|
||||
QString m_weekDay;
|
||||
TimeRange m_range;
|
||||
QDate m_date;
|
||||
ApplyCarryOver m_carryOverIf;
|
||||
|
||||
explicit ATBTariffCarryOver()
|
||||
: m_id(-1)
|
||||
, m_carryOverIf(ApplyCarryOver::NEVER) {
|
||||
}
|
||||
|
||||
void setCarryOverIf(QString const &coif) {
|
||||
if (coif == "never") {
|
||||
m_carryOverIf = ApplyCarryOver::NEVER;
|
||||
} else
|
||||
if (coif == "match_prev_day") {
|
||||
m_carryOverIf = ApplyCarryOver::MATCH_PREV_DAY;
|
||||
} else
|
||||
if (coif == "match_next_day") {
|
||||
m_carryOverIf = ApplyCarryOver::MATCH_NEXT_DAY;
|
||||
} else
|
||||
if (coif == "always") {
|
||||
m_carryOverIf = ApplyCarryOver::ALWAYS;
|
||||
} else {
|
||||
qCritical() << "ERROR unknown carry over application" << coif;
|
||||
}
|
||||
}
|
||||
|
||||
ApplyCarryOver carryOverIf() const {
|
||||
return m_carryOverIf;
|
||||
}
|
||||
|
||||
QString carryOverIfStr() const {
|
||||
if (m_carryOverIf == ApplyCarryOver::NEVER) {
|
||||
return "never";
|
||||
}
|
||||
if (m_carryOverIf == ApplyCarryOver::ALWAYS) {
|
||||
return "always";
|
||||
}
|
||||
if (m_carryOverIf == ApplyCarryOver::MATCH_PREV_DAY) {
|
||||
return "match prev day";
|
||||
}
|
||||
if (m_carryOverIf == ApplyCarryOver::MATCH_NEXT_DAY) {
|
||||
return "match next day";
|
||||
}
|
||||
return QString("ERROR unknown carry over application: %1").arg(static_cast<int>(m_carryOverIf));
|
||||
}
|
||||
|
||||
int computeMinutesUntilCarryOverEnd(QDateTime const &dt) {
|
||||
int minutes = 0;
|
||||
QString end = m_range.m_end.toString(Qt::ISODate);
|
||||
if (end == "24:00:00") {
|
||||
// note: this did not work
|
||||
// QDateTime t(dt.addDays(1));
|
||||
// t.setTime(QTime(0,0,0));
|
||||
// dt: 2024-10-27T00:00:00 EEST, but t: 2024-10-28T00:00:00 EET (!)
|
||||
// so the difference is 1500 instead of 1440
|
||||
// reason: change from summer to winter time
|
||||
|
||||
// compute minutes directly
|
||||
if (dt.time().isValid()) {
|
||||
minutes = 1440 - (dt.time().hour() * 60 + dt.time().minute());
|
||||
}
|
||||
} else {
|
||||
QTime t(QTime::fromString(end, Qt::ISODate));
|
||||
if (t.isValid() && dt.time().isValid()) {
|
||||
minutes = (t.hour() * 60 + t.minute()) - (dt.time().hour() * 60 + dt.time().minute());
|
||||
}
|
||||
}
|
||||
|
||||
if (minutes < 0 || minutes > m_range.m_duration) {
|
||||
minutes = 0;
|
||||
}
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "minutes" << minutes;
|
||||
|
||||
return minutes;
|
||||
}
|
||||
|
||||
friend QDebug operator<<(QDebug debug, ATBTariffCarryOver const &co) {
|
||||
QDebugStateSaver saver(debug);
|
||||
|
||||
debug.nospace()
|
||||
<< "\nTariffCarryOver:\n"
|
||||
<< " week day: " << co.m_weekDay << "\n"
|
||||
<< " date: " << co.m_date.toString(Qt::ISODate) << "\n"
|
||||
<< " id: " << co.m_id << "\n"
|
||||
<< " start: " << co.m_range.m_start << "\n"
|
||||
<< " end: " << co.m_range.m_end << "\n"
|
||||
<< " duration: " << co.m_range.m_duration << "\n"
|
||||
<< " carry over if: " << co.carryOverIfStr() << endl;
|
||||
return debug;
|
||||
}
|
||||
};
|
||||
|
||||
struct ATBCarryOver {
|
||||
struct week {
|
||||
int day;
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
#pragma once
|
||||
#include <variant>
|
||||
#include <cstddef>
|
||||
#include <stdio.h>
|
||||
|
||||
@ -1,79 +0,0 @@
|
||||
#ifndef TARIFF_OUT_OF_SERVICE_H_INCLUDED
|
||||
#define TARIFF_OUT_OF_SERVICE_H_INCLUDED
|
||||
|
||||
#include <QDateTime>
|
||||
#include <QString>
|
||||
|
||||
#include "time_range.h"
|
||||
|
||||
enum class ApplyOutOfService {
|
||||
NEVER = 0,
|
||||
MATCH_PREV_DAY = 1,
|
||||
MATCH_NEXT_DAY = 2,
|
||||
ALWAYS = 3
|
||||
};
|
||||
|
||||
struct ATBTariffOutOfService {
|
||||
int m_id;
|
||||
QString m_weekDay;
|
||||
QDate m_date;
|
||||
TimeRange m_range;
|
||||
ApplyOutOfService m_outOfServiceIf;
|
||||
|
||||
explicit ATBTariffOutOfService()
|
||||
: m_id(-1)
|
||||
, m_outOfServiceIf(ApplyOutOfService::NEVER) {
|
||||
}
|
||||
|
||||
void setOutOfServiceIf(QString const &oosif) {
|
||||
if (oosif == "never") {
|
||||
m_outOfServiceIf = ApplyOutOfService::NEVER;
|
||||
} else
|
||||
if (oosif == "match_prev_day") {
|
||||
m_outOfServiceIf = ApplyOutOfService::MATCH_PREV_DAY;
|
||||
} else
|
||||
if (oosif == "match_next_day") {
|
||||
m_outOfServiceIf = ApplyOutOfService::MATCH_NEXT_DAY;
|
||||
} else
|
||||
if (oosif == "always") {
|
||||
m_outOfServiceIf = ApplyOutOfService::ALWAYS;
|
||||
} else {
|
||||
qCritical() << "ERROR unknown servcie application" << oosif;
|
||||
}
|
||||
}
|
||||
|
||||
ApplyOutOfService outOfServiceIf() const {
|
||||
return m_outOfServiceIf;
|
||||
}
|
||||
|
||||
QString outOfServiceIfStr() const {
|
||||
if (m_outOfServiceIf == ApplyOutOfService::NEVER) {
|
||||
return "never";
|
||||
}
|
||||
if (m_outOfServiceIf == ApplyOutOfService::ALWAYS) {
|
||||
return "always";
|
||||
}
|
||||
if (m_outOfServiceIf == ApplyOutOfService::MATCH_PREV_DAY) {
|
||||
return "match prev day";
|
||||
}
|
||||
if (m_outOfServiceIf == ApplyOutOfService::MATCH_NEXT_DAY) {
|
||||
return "match next day";
|
||||
}
|
||||
return QString("ERROR unknown out of service application: %1").arg(static_cast<int>(m_outOfServiceIf));
|
||||
}
|
||||
friend QDebug operator<<(QDebug debug, ATBTariffOutOfService const &oos) {
|
||||
QDebugStateSaver saver(debug);
|
||||
|
||||
debug.nospace()
|
||||
<< "\nTariffOutOfService:\n"
|
||||
<< " week day: " << oos.m_weekDay << "\n"
|
||||
<< " date: " << oos.m_date.toString(Qt::ISODate) << "\n"
|
||||
<< " id: " << oos.m_id << "\n"
|
||||
<< " start: " << oos.m_range.m_start << "\n"
|
||||
<< " end: " << oos.m_range.m_end << "\n"
|
||||
<< " duration: " << oos.m_range.m_duration << endl;
|
||||
return debug;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // TARIFF_SERVICE_H_INCLUDED
|
||||
@ -1,85 +1,9 @@
|
||||
#ifndef TARIFF_PREPAID_H_INCLUDED
|
||||
#define TARIFF_PREPAID_H_INCLUDED
|
||||
|
||||
#include <QDateTime>
|
||||
#include <QTime>
|
||||
#include <QString>
|
||||
|
||||
#include "time_range.h"
|
||||
|
||||
enum class ApplyPrepaid {
|
||||
NEVER = 0,
|
||||
MATCH_PREV_DAY = 1,
|
||||
MATCH_NEXT_DAY = 2,
|
||||
ALWAYS = 3
|
||||
};
|
||||
|
||||
struct ATBTariffPrepaid {
|
||||
int m_id;
|
||||
QString m_weekDay;
|
||||
QDate m_date;
|
||||
TimeRange m_range;
|
||||
ApplyPrepaid m_prepaidIf;
|
||||
|
||||
explicit ATBTariffPrepaid()
|
||||
: m_id(-1)
|
||||
, m_prepaidIf(ApplyPrepaid::NEVER) {
|
||||
}
|
||||
|
||||
void setPrepaidIf(QString const &ppif) {
|
||||
if (ppif == "never") {
|
||||
m_prepaidIf = ApplyPrepaid::NEVER;
|
||||
} else
|
||||
if (ppif == "match_prev_day") {
|
||||
m_prepaidIf = ApplyPrepaid::MATCH_PREV_DAY;
|
||||
} else
|
||||
if (ppif == "match_next_day") {
|
||||
m_prepaidIf = ApplyPrepaid::MATCH_NEXT_DAY;
|
||||
} else
|
||||
if (ppif == "always") {
|
||||
m_prepaidIf = ApplyPrepaid::ALWAYS;
|
||||
} else {
|
||||
qCritical() << "ERROR unknown carry over application" << ppif;
|
||||
}
|
||||
}
|
||||
|
||||
ApplyPrepaid prepaidIf() const {
|
||||
return m_prepaidIf;
|
||||
}
|
||||
|
||||
QString prepaidIfStr() const {
|
||||
if (m_prepaidIf == ApplyPrepaid::NEVER) {
|
||||
return "never";
|
||||
}
|
||||
if (m_prepaidIf == ApplyPrepaid::ALWAYS) {
|
||||
return "always";
|
||||
}
|
||||
if (m_prepaidIf == ApplyPrepaid::MATCH_PREV_DAY) {
|
||||
return "match prev day";
|
||||
}
|
||||
if (m_prepaidIf == ApplyPrepaid::MATCH_NEXT_DAY) {
|
||||
return "match next day";
|
||||
}
|
||||
return QString("ERROR unknown prepaid application: %1").arg(static_cast<int>(m_prepaidIf));
|
||||
}
|
||||
|
||||
friend QDebug operator<<(QDebug debug, ATBTariffPrepaid const &pp) {
|
||||
QDebugStateSaver saver(debug);
|
||||
|
||||
debug.nospace()
|
||||
<< "\nTariffPrepaid:\n"
|
||||
<< " week day: " << pp.m_weekDay << "\n"
|
||||
<< " date: " << pp.m_date.toString(Qt::ISODate) << "\n"
|
||||
<< " id: " << pp.m_id << "\n"
|
||||
<< " start: " << pp.m_range.m_start << "\n"
|
||||
<< " end: " << pp.m_range.m_end << "\n"
|
||||
<< " duration: " << pp.m_range.m_duration << "\n"
|
||||
<< " prepaid if: " << pp.prepaidIfStr() << endl;
|
||||
return debug;
|
||||
}
|
||||
};
|
||||
|
||||
// deprecated
|
||||
|
||||
struct ATBPrepaid {
|
||||
int id;
|
||||
bool anytime;
|
||||
|
||||
@ -1,81 +0,0 @@
|
||||
#ifndef TARIFF_SERVICE_H_INCLUDED
|
||||
#define TARIFF_SERVICE_H_INCLUDED
|
||||
|
||||
#include <QDateTime>
|
||||
#include <QString>
|
||||
|
||||
#include "time_range.h"
|
||||
|
||||
enum class ApplyService {
|
||||
NEVER = 0,
|
||||
MATCH_PREV_DAY = 1,
|
||||
MATCH_NEXT_DAY = 2,
|
||||
ALWAYS = 3
|
||||
};
|
||||
|
||||
struct ATBTariffService {
|
||||
int m_id;
|
||||
QString m_weekDay;
|
||||
QDate m_date;
|
||||
TimeRange m_range;
|
||||
ApplyService m_serviceIf;
|
||||
|
||||
explicit ATBTariffService()
|
||||
: m_id(-1)
|
||||
, m_serviceIf(ApplyService::NEVER) {
|
||||
}
|
||||
|
||||
void setServiceIf(QString const &sif) {
|
||||
if (sif == "never") {
|
||||
m_serviceIf = ApplyService::NEVER;
|
||||
} else
|
||||
if (sif == "match_prev_day") {
|
||||
m_serviceIf = ApplyService::MATCH_PREV_DAY;
|
||||
} else
|
||||
if (sif == "match_next_day") {
|
||||
m_serviceIf = ApplyService::MATCH_NEXT_DAY;
|
||||
} else
|
||||
if (sif == "always") {
|
||||
m_serviceIf = ApplyService::ALWAYS;
|
||||
} else {
|
||||
qCritical() << "ERROR unknown servcie application" << sif;
|
||||
}
|
||||
}
|
||||
|
||||
ApplyService serviceIf() const {
|
||||
return m_serviceIf;
|
||||
}
|
||||
|
||||
QString serviceIfStr() const {
|
||||
if (m_serviceIf == ApplyService::NEVER) {
|
||||
return "never";
|
||||
}
|
||||
if (m_serviceIf == ApplyService::ALWAYS) {
|
||||
return "always";
|
||||
}
|
||||
if (m_serviceIf == ApplyService::MATCH_PREV_DAY) {
|
||||
return "match prev day";
|
||||
}
|
||||
if (m_serviceIf == ApplyService::MATCH_NEXT_DAY) {
|
||||
return "match next day";
|
||||
}
|
||||
return QString("ERROR unknown service application: %1").arg(static_cast<int>(m_serviceIf));
|
||||
}
|
||||
|
||||
friend QDebug operator<<(QDebug debug, ATBTariffService const &ts) {
|
||||
QDebugStateSaver saver(debug);
|
||||
|
||||
debug.nospace()
|
||||
<< "\nTariffService:\n"
|
||||
<< " week day: " << ts.m_weekDay << "\n"
|
||||
<< " date: " << ts.m_date.toString(Qt::ISODate) << "\n"
|
||||
<< " id: " << ts.m_id << "\n"
|
||||
<< " start: " << ts.m_range.m_start << "\n"
|
||||
<< " end: " << ts.m_range.m_end << "\n"
|
||||
<< " duration: " << ts.m_range.m_duration << "\n"
|
||||
<< " prepaid if: " << ts.serviceIfStr() << endl;
|
||||
return debug;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // TARIFF_SERVICE_H_INCLUDED
|
||||
@ -1,46 +1,12 @@
|
||||
#ifndef TIME_RANGE_H_INCLUDED
|
||||
#define TIME_RANGE_H_INCLUDED
|
||||
|
||||
#include "atb_time.h"
|
||||
|
||||
#include <QString>
|
||||
|
||||
struct TimeRange {
|
||||
ATBTime m_start;
|
||||
ATBTime m_end;
|
||||
int m_duration;
|
||||
|
||||
explicit TimeRange() = default;
|
||||
explicit TimeRange(QString const &start, QString const &end, int duration)
|
||||
: m_start(start)
|
||||
, m_end(end)
|
||||
, m_duration(duration) {
|
||||
}
|
||||
explicit TimeRange(ATBTime const &start, ATBTime const &end, int duration)
|
||||
: m_start(start)
|
||||
, m_end(end)
|
||||
, m_duration(duration) {
|
||||
}
|
||||
|
||||
explicit TimeRange(TimeRange const &timeRange) {
|
||||
m_start = timeRange.m_start;
|
||||
m_end = timeRange.m_end;
|
||||
m_duration = timeRange.m_duration;
|
||||
}
|
||||
|
||||
TimeRange &operator=(TimeRange && timeRange) {
|
||||
m_start = std::move(timeRange.m_start);
|
||||
m_end = std::move(timeRange.m_end);
|
||||
m_duration = timeRange.m_duration;
|
||||
return *this;
|
||||
}
|
||||
|
||||
TimeRange &operator=(TimeRange const &timeRange) {
|
||||
m_start = timeRange.m_start;
|
||||
m_end = timeRange.m_end;
|
||||
m_duration = timeRange.m_duration;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // TIME_RANGE_H_INCLUDED
|
||||
#ifndef TIME_RANGE_H_INCLUDED
|
||||
#define TIME_RANGE_H_INCLUDED
|
||||
|
||||
#include "time_range_header.h"
|
||||
|
||||
struct TimeRange {
|
||||
public:
|
||||
bool IsActive;
|
||||
ATBTimeRange TimeRangeStructure;
|
||||
};
|
||||
|
||||
#endif // TIME_RANGE_H_INCLUDED
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -35,8 +35,7 @@ SOURCES += \
|
||||
src/tariff_log.cpp \
|
||||
src/calculate_price.cpp \
|
||||
src/ticket.cpp \
|
||||
src/tariff_global_defines.cpp \
|
||||
src/atb_time.cpp
|
||||
src/tariff_global_defines.cpp
|
||||
|
||||
HEADERS += \
|
||||
include/mobilisis/calculator_functions.h \
|
||||
@ -90,10 +89,7 @@ HEADERS += \
|
||||
include/mobilisis/tariff_interpolation.h \
|
||||
include/mobilisis/tariff_prepaid.h \
|
||||
include/mobilisis/tariff_carryover.h \
|
||||
include/mobilisis/tariff_global_defines.h \
|
||||
include/mobilisis/atb_time.h \
|
||||
include/mobilisis/tariff_service.h \
|
||||
include/mobilisis/tariff_out_of_service.h
|
||||
include/mobilisis/tariff_global_defines.h
|
||||
|
||||
OTHER_FILES += src/main.cpp \
|
||||
../tariffs/tariff_korneuburg.json \
|
||||
|
||||
@ -1,151 +0,0 @@
|
||||
#include "atb_time.h"
|
||||
#include <QDebugStateSaver>
|
||||
|
||||
QDateTime const ATBTime::m_end(QDateTime::fromString("1970-01-02T00:00:00", Qt::ISODate));
|
||||
|
||||
ATBTime::ATBTime()
|
||||
: m_time(QDateTime::fromString("1970-01-01T00:00:00", Qt::ISODate)) {
|
||||
}
|
||||
|
||||
ATBTime::ATBTime(int h, int m, int /*s*/, int /*ms*/)
|
||||
: m_time(QDateTime::fromString("1970-01-01T00:00:00", Qt::ISODate)) {
|
||||
|
||||
if (h == 24 && m == 0) {
|
||||
m_time = m_end;
|
||||
} else {
|
||||
QTime const t(h, m, 0, 0);
|
||||
m_time.setTime(t);
|
||||
}
|
||||
}
|
||||
|
||||
ATBTime::ATBTime(QString const &t)
|
||||
: m_time(QDateTime::fromString("1970-01-01T00:00:00")) {
|
||||
|
||||
if (t == "24:00:00") {
|
||||
m_time = m_end;
|
||||
} else {
|
||||
QTime tmp = QTime::fromString(t, Qt::ISODate);
|
||||
if (tmp.isValid()) {
|
||||
m_time.setTime(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ATBTime::ATBTime(QTime const &t)
|
||||
: m_time(QDateTime::fromString("1970-01-01T00:00:00")) {
|
||||
m_time.setTime(t);
|
||||
}
|
||||
|
||||
QTime ATBTime::addMSecs(int ms) const {
|
||||
return m_time.time().addMSecs(ms);
|
||||
}
|
||||
|
||||
QTime ATBTime::addMSecs(int ms) {
|
||||
QTime t = m_time.time();
|
||||
t = t.addMSecs(ms);
|
||||
m_time.setTime(t);
|
||||
return t;
|
||||
}
|
||||
|
||||
QTime ATBTime::addSecs(int s) const {
|
||||
return m_time.time().addSecs(s);
|
||||
}
|
||||
|
||||
QTime ATBTime::addSecs(int s) {
|
||||
QTime t = m_time.time();
|
||||
t = t.addSecs(s);
|
||||
m_time.setTime(t);
|
||||
return t;
|
||||
}
|
||||
|
||||
constexpr QTime ATBTime::fromMSecsSinceStartOfDay(int msecs) {
|
||||
return QTime::fromMSecsSinceStartOfDay(msecs);
|
||||
}
|
||||
|
||||
QTime ATBTime::fromString(QString const &string, Qt::DateFormat format) {
|
||||
return QTime::fromString(string, format);
|
||||
}
|
||||
|
||||
QTime ATBTime::fromString(QString const &string, QString const &format) {
|
||||
return QTime::fromString(string, format);
|
||||
}
|
||||
|
||||
bool ATBTime::isValid(int h, int m, int s, int ms) {
|
||||
return QTime(h, m, s, ms).isValid();
|
||||
}
|
||||
|
||||
int ATBTime::msecsSinceStartOfDay() const {
|
||||
return m_time.time().msecsSinceStartOfDay();
|
||||
}
|
||||
|
||||
bool ATBTime::setHMS(int h, int m, int s, int ms) {
|
||||
if (isValid(h, m, s, ms)) {
|
||||
QTime t(h, m, s, ms);
|
||||
m_time.setTime(t);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
QString ATBTime::toString(Qt::DateFormat format) const {
|
||||
if (m_time == m_end) {
|
||||
return "24:00:00";
|
||||
}
|
||||
return m_time.time().toString(format);
|
||||
}
|
||||
|
||||
bool operator!=(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
return lhs.m_time.time() != rhs.m_time.time();
|
||||
}
|
||||
|
||||
bool operator<=(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
if (rhs.m_time == rhs.m_end) {
|
||||
return true;
|
||||
}
|
||||
return lhs.m_time.time() <= rhs.m_time.time();
|
||||
}
|
||||
|
||||
bool operator>=(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
return lhs.m_time.time() >= rhs.m_time.time();
|
||||
}
|
||||
|
||||
bool operator<(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
if (rhs.m_time == rhs.m_end) {
|
||||
return true;
|
||||
}
|
||||
return lhs.m_time.time() < rhs.m_time.time();
|
||||
}
|
||||
|
||||
bool operator>(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
return lhs.m_time.time() > rhs.m_time.time();
|
||||
}
|
||||
|
||||
bool operator==(const ATBTime &lhs, const ATBTime &rhs) noexcept {
|
||||
return lhs.m_time.time() == rhs.m_time.time();
|
||||
}
|
||||
|
||||
QDebug &operator<<(QDebug &debug, ATBTime const &time) {
|
||||
QDebugStateSaver saver(debug);
|
||||
if (time.m_time == time.m_end) {
|
||||
debug.nospace() << QString("24:00:00");
|
||||
} else {
|
||||
debug.nospace() << time.m_time.time().toString(Qt::ISODate);
|
||||
}
|
||||
return debug;
|
||||
}
|
||||
|
||||
QDataStream &operator<<(QDataStream &out, ATBTime const &time) {
|
||||
if (time.m_time == time.m_end) {
|
||||
out << QString("24:00:00");
|
||||
} else {
|
||||
out << time.m_time.time();
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
QDataStream &operator>>(QDataStream &in, ATBTime &time) {
|
||||
QTime t;
|
||||
in >> t;
|
||||
time.m_time.setTime(t);
|
||||
return in;
|
||||
}
|
||||
@ -26,7 +26,6 @@ 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);
|
||||
@ -77,7 +76,6 @@ int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
|
||||
if (paymentOptionIndex == -1) {
|
||||
paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
|
||||
}
|
||||
|
||||
int maxTime = 0;
|
||||
|
||||
switch(permitType) {
|
||||
@ -338,9 +336,7 @@ int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg,
|
||||
|
||||
switch(permitType) {
|
||||
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
||||
if (paymentMethodId == PaymentMethod::Progressive
|
||||
|| paymentMethodId == PaymentMethod::Steps
|
||||
|| paymentMethodId == PaymentMethod::Unified) {
|
||||
if (paymentMethodId == PaymentMethod::Progressive || paymentMethodId == PaymentMethod::Steps) {
|
||||
//maxPrice = Utilities::getMaximalParkingPrice(cfg, paymentMethodId);
|
||||
ATBPaymentOption const &po = cfg->getPaymentOptions(paymentOptionIndex);
|
||||
maxPrice = po.pop_max_price; // maxTime is given in minutes
|
||||
@ -396,12 +392,14 @@ int CALCULATE_LIBRARY_API get_zone_nr(int zone)
|
||||
if(zone > -1) return zone;
|
||||
else
|
||||
{
|
||||
QFile zone("/mnt/system_data/zone_nr");
|
||||
QFile zone("/etc/zone_nr");
|
||||
if (zone.exists()) {
|
||||
QFileInfo finfo(zone);
|
||||
if (zone.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||||
QTextStream in(&zone);
|
||||
return in.readLine(100).toInt();
|
||||
if (finfo.size() <= 4) { // decimal 000\n
|
||||
if (zone.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||||
QTextStream in(&zone);
|
||||
return in.readLine(100).toInt();
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
@ -482,15 +480,6 @@ int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int cu
|
||||
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()) {
|
||||
@ -527,9 +516,6 @@ int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int cu
|
||||
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;
|
||||
@ -540,8 +526,6 @@ int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int cu
|
||||
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))
|
||||
{
|
||||
@ -698,11 +682,6 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
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;
|
||||
|
||||
@ -773,9 +752,6 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
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;
|
||||
|
||||
@ -842,13 +818,6 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
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
|
||||
@ -901,9 +870,6 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
@ -919,7 +885,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
|
||||
// handle carry over
|
||||
int minutesUntilCarryOver = effectiveStartTime.time().secsTo(carryOverStart) / 60;
|
||||
if ((minutesUntilCarryOver > 0) && (netto_parking_time > minutesUntilCarryOver)) {
|
||||
if (netto_parking_time > minutesUntilCarryOver) {
|
||||
int const rest = netto_parking_time - minutesUntilCarryOver;
|
||||
QDateTime s(effectiveStartTime);
|
||||
s = s.addSecs(minutesUntilCarryOver * 60);
|
||||
@ -969,28 +935,11 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
//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,
|
||||
@ -1000,7 +949,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
|
||||
netto_parking_time, // minutes, netto
|
||||
false, prepaid);
|
||||
}
|
||||
|
||||
// qCritical() << __func__ << __LINE__;
|
||||
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));
|
||||
@ -1034,10 +983,6 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
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);
|
||||
@ -1093,9 +1038,6 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
QDateTime &ticketEndTime,
|
||||
PermitType permitType)
|
||||
{
|
||||
tariff->getPaymentOptions(0).pop_max_price
|
||||
= tariff->getPaymentOptions(0).pop_max_price_save;
|
||||
|
||||
CalcState calcState;
|
||||
|
||||
bool prepaid = true;
|
||||
@ -1129,10 +1071,6 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
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()) {
|
||||
@ -1149,9 +1087,8 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
}
|
||||
}
|
||||
}
|
||||
QDateTime start(start_parking_time);
|
||||
start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
|
||||
QString cs = start.toString(Qt::ISODate);
|
||||
|
||||
QString cs = start_parking_time.toString(Qt::ISODate);
|
||||
|
||||
std::pair<std::string, QDateTime> p_endTime
|
||||
= Calculator::GetInstance().GetDurationFromCost(
|
||||
@ -1163,18 +1100,9 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
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);
|
||||
@ -1232,171 +1160,85 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
} 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";
|
||||
}
|
||||
}
|
||||
|
||||
if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::STATIC) {
|
||||
// handle carry over for ticket-end-time
|
||||
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);
|
||||
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;
|
||||
|
||||
QList<int> const &stepList = Calculator::GetInstance().GetTimeSteps(tariff, paymentOptionIndex);
|
||||
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;
|
||||
}
|
||||
|
||||
QDateTime newTicketEndTime = ticketEndTime;
|
||||
QTime carryOverStart;
|
||||
QTime carryOverEnd;
|
||||
int carryOverDuration = -1;
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "PARK-TIME VIOLATED";
|
||||
// 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;
|
||||
}
|
||||
|
||||
for (int i = stepList.size() - 1; i > 0; --i) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "step[" << i << "]" << stepList.at(i);
|
||||
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 (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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (carryOverStart.isValid() && carryOverEnd.isValid() && carryOverDuration != -1) {
|
||||
// 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 {
|
||||
// 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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "WARNING: wrong carry-over-settings";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ticketEndTime.setTime(QTime(ticketEndTime.time().hour(),
|
||||
ticketEndTime.time().minute(), 0));
|
||||
|
||||
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 const parkTimeLimitViolated = wd.getTariffCarryOverSettings().parkingTimeLimitExceeded(start_parking_time,
|
||||
ticketEndTime,
|
||||
paymentOptionIndex);
|
||||
if (parkTimeLimitViolated) {
|
||||
//QTime const &tlimit = wd.getTariffCarryOverSettings().parkingTimeLimit();
|
||||
//ticketEndTime.setTime(tlimit);
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1413,9 +1255,7 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
|
||||
return calcState.set(CalcState::State::INVALID_START_DATE);
|
||||
}
|
||||
|
||||
//return calcState.set(CalcState::State::SUCCESS);
|
||||
qCritical() << __func__ << ":" << __LINE__ << " calcState" << calcState.toString();
|
||||
return calcState;
|
||||
return calcState.set(CalcState::State::SUCCESS);
|
||||
}
|
||||
|
||||
CalcState CALCULATE_LIBRARY_API compute_duration_for_daily_ticket(parking_tariff_t *tariff,
|
||||
@ -1423,9 +1263,6 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_daily_ticket(parking_tariff
|
||||
QDateTime &ticketEndTime,
|
||||
PermitType /* PermitType */)
|
||||
{
|
||||
tariff->getPaymentOptions(0).pop_max_price
|
||||
= tariff->getPaymentOptions(0).pop_max_price_save;
|
||||
|
||||
CalcState calcState;
|
||||
if (start_parking_time.isValid()) {
|
||||
|
||||
@ -1457,12 +1294,9 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_daily_ticket(
|
||||
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,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,762 +0,0 @@
|
||||
#include "calculate_price.h"
|
||||
#include "configuration.h"
|
||||
#include "calculator_functions.h"
|
||||
#include "payment_option.h"
|
||||
#include "utilities.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";
|
||||
|
||||
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;
|
||||
|
||||
switch(permitType) {
|
||||
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
||||
QList<int> const tsteps = Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
|
||||
Q_UNUSED(tsteps);
|
||||
minTime = cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
|
||||
} 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);
|
||||
Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
|
||||
minTime = qRound(cfg->getPaymentOptions(paymentOptionIndex).pop_min_time);
|
||||
}
|
||||
|
||||
return minTime;
|
||||
}
|
||||
|
||||
int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
|
||||
PERMIT_TYPE permitType,
|
||||
int paymentOptionIndex) {
|
||||
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: ;
|
||||
}
|
||||
|
||||
return maxTime;
|
||||
|
||||
}
|
||||
|
||||
int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
|
||||
PERMIT_TYPE permitType,
|
||||
int paymentOptionIndex,
|
||||
QDateTime const &start) {
|
||||
int minPrice = -1;
|
||||
|
||||
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: ;
|
||||
}
|
||||
|
||||
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); // in minutes
|
||||
int pop_max_time = get_maximal_parkingtime(cfg); // 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;
|
||||
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);
|
||||
|
||||
switch(permitType) {
|
||||
case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
|
||||
if (paymentMethodId == PaymentMethod::Progressive || paymentMethodId == PaymentMethod::Steps) {
|
||||
maxPrice = Utilities::getMaximalParkingPrice(cfg, paymentMethodId);
|
||||
} 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;
|
||||
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;
|
||||
return calcState.set(CalcState::State::ERROR_PARSING_TARIFF);
|
||||
}
|
||||
} else {
|
||||
delete *tariff;
|
||||
*tariff = nullptr;
|
||||
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)
|
||||
{
|
||||
qCritical() << " compute_next_timestep() currentTimeMinutes: " << currentTimeMinutes;
|
||||
qCritical() << " compute_next_timestep() up/down (1=up, 0=down): " << UpDown;
|
||||
|
||||
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() << " compute_next_timestep() paymentMethodId: Progressive";
|
||||
break;
|
||||
case PaymentMethod::Degressive:
|
||||
qCritical() << " compute_next_timestep() paymentMethodId: Degressive";
|
||||
break;
|
||||
case PaymentMethod::Linear:
|
||||
qCritical() << " compute_next_timestep() paymentMethodId: Linear";
|
||||
break;
|
||||
case PaymentMethod::Steps:
|
||||
qCritical() << " compute_next_timestep() paymentMethodId: Steps";
|
||||
break;
|
||||
case PaymentMethod::Undefined:
|
||||
qCritical() << " 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))
|
||||
{
|
||||
const QList<int> stepList = Calculator::GetInstance().GetTimeSteps(tariff);
|
||||
qCritical() << " compute_next_timestep() timeSteps:" << stepList;
|
||||
|
||||
int currentStepIndex = stepList.indexOf(currentTimeMinutes);
|
||||
|
||||
if (currentStepIndex == -1) {
|
||||
qCritical() << "compute_next_timestep() *NO STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
||||
return currentTimeMinutes;
|
||||
}
|
||||
|
||||
if (UpDown == 1) { // UP
|
||||
if (stepList[currentStepIndex] == stepList.last()) {
|
||||
qCritical() << "compute_next_timestep() *NO NEXT STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
||||
return currentTimeMinutes;
|
||||
}
|
||||
else {
|
||||
return stepList[currentStepIndex + 1];
|
||||
}
|
||||
}
|
||||
if (UpDown == 0) { // DOWN
|
||||
if (stepList[currentStepIndex] == stepList.first()) {
|
||||
qCritical() << "compute_next_timestep() *NO PREVIOUS STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
|
||||
return currentTimeMinutes;
|
||||
}
|
||||
else {
|
||||
return stepList[currentStepIndex - 1];
|
||||
}
|
||||
}
|
||||
} 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) {
|
||||
CalcState calcState;
|
||||
double minMin = tariff->PaymentOption.find(tariff->getPaymentOptions().pop_payment_method_id)->second.pop_min_time;
|
||||
double maxMin = tariff->PaymentOption.find(tariff->getPaymentOptions().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().pop_payment_method_id,
|
||||
start,
|
||||
end,
|
||||
duration, false, true);
|
||||
double minCost = tariff->PaymentOption.find(tariff->getPaymentOptions().pop_payment_method_id)->second.pop_min_price;
|
||||
if (cost < minCost) {
|
||||
calcState.setDesc(QString("minCost=%1, cost=%2").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,
|
||||
bool prepaid)
|
||||
{
|
||||
CalcState calcState;
|
||||
|
||||
int paymentOptionIndex = tariff->getPaymentOptionIndex(start_parking_time);
|
||||
|
||||
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
|
||||
<< " minMin: " << minMin << endl
|
||||
<< " maxMin: " << maxMin;
|
||||
|
||||
|
||||
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) {
|
||||
// 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;
|
||||
}
|
||||
cost = Calculator::GetInstance().GetCostFromDuration(tariff, start_parking_time, netto_parking_time, paymentOptionIndex);
|
||||
end_parking_time = start_parking_time.addSecs(netto_parking_time*60);
|
||||
|
||||
// qCritical() << "(" << __func__ << ":" << __LINE__ << ")"
|
||||
// << "end_parking_time" << end_parking_time.toString(Qt::ISODate);
|
||||
|
||||
} 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("minCost=%1, cost=%2").arg(minCost, cost));
|
||||
return calcState.set(CalcState::State::BELOW_MIN_PARKING_PRICE);
|
||||
}
|
||||
|
||||
// DEBUG
|
||||
qCritical() << " end_parking_time: " << end_parking_time;
|
||||
qCritical() << " -> 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);
|
||||
}
|
||||
|
||||
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) {
|
||||
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);
|
||||
|
||||
// DEBUG
|
||||
qCritical() << "compute_duration_for_parking_ticket(): ";
|
||||
qCritical() << " start (cs): " << cs;
|
||||
qCritical() << " price: " << price;
|
||||
|
||||
duration = Calculator::GetInstance().GetDurationFromCost(tariff,
|
||||
tariff->getPaymentOptions().pop_payment_method_id,
|
||||
cs.toLocal8Bit().constData(),
|
||||
price, false, true).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)
|
||||
{
|
||||
CalcState calcState;
|
||||
if (start_parking_time.isValid()) {
|
||||
QString cs = start_parking_time.toString(Qt::ISODate);
|
||||
QString endTime = Calculator::GetInstance().GetDurationFromCost(
|
||||
tariff,
|
||||
tariff->getPaymentOptions().pop_payment_method_id,
|
||||
cs.toLocal8Bit().constData(),
|
||||
price, false, true).c_str();
|
||||
|
||||
if (endTime == CalcState::SUCCESS) {
|
||||
calcState.setDesc(QString("SUCCESS"));
|
||||
calcState.setStatus(endTime);
|
||||
} 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);
|
||||
|
||||
// DEBUG
|
||||
//qCritical() << "compute_duration_for_parking_ticket(): ";
|
||||
//qCritical() << " endTime: " << endTime;
|
||||
//qCritical() << " ticketEndTime: " << ticketEndTime;
|
||||
|
||||
if (!ticketEndTime.isValid()) {
|
||||
calcState.setDesc(QString("ticketEndTime=%1").arg(endTime));
|
||||
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_daily_ticket(parking_tariff_t *tariff, QDateTime const &start_parking_time, QDateTime &ticketEndTime)
|
||||
{
|
||||
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
|
||||
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);
|
||||
}
|
||||
|
||||
@ -6,8 +6,6 @@
|
||||
#include "ticket.h"
|
||||
#include "tariff_global_defines.h"
|
||||
#include "tariff_prepaid.h"
|
||||
#include "tariff_out_of_service.h"
|
||||
#include "tariff_service.h"
|
||||
|
||||
#include <sstream>
|
||||
#include <algorithm>
|
||||
@ -119,635 +117,6 @@ QDateTime Calculator::GetDailyTicketDuration(Configuration* cfg, const QDateTime
|
||||
|
||||
return QDateTime();
|
||||
}
|
||||
|
||||
///
|
||||
/// \brief getPrepaid
|
||||
/// \param cfg
|
||||
/// \param dt
|
||||
/// \return
|
||||
///
|
||||
|
||||
std::optional<ATBTariffPrepaid> getPrepaid(Configuration const *cfg, QDateTime const &dt) {
|
||||
std::optional<ATBTariffPrepaid> value = std::nullopt;
|
||||
|
||||
int weekDay = dt.date().dayOfWeek();
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << dt.toString(Qt::ISODate) << weekDay;
|
||||
|
||||
ATBTime inputTime(dt.time());
|
||||
QDate d; // check if a special date is configured in tariff-file for this day
|
||||
auto const &prepaidRange = cfg->TariffPrepaids.equal_range(weekDay);
|
||||
|
||||
for (auto i = prepaidRange.first; i != prepaidRange.second; ++i) {
|
||||
ATBTariffPrepaid const &prepaid = i->second;
|
||||
if (!prepaid.m_date.isNull() && prepaid.m_date.isValid() && prepaid.m_date == dt.date()) {
|
||||
d = dt.date();
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "found special day" << d.toString(Qt::ISODate);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
for (auto i = prepaidRange.first; i != prepaidRange.second; ++i) {
|
||||
ATBTariffPrepaid const &prepaid = i->second;
|
||||
if (!prepaid.m_date.isNull() && prepaid.m_date.isValid() && prepaid.m_date == d) {
|
||||
TimeRange const &prepaidTimeRange = prepaid.m_range;
|
||||
if (inputTime >= prepaidTimeRange.m_start && inputTime < prepaidTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << prepaidTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << prepaidTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(i->second);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "no special day" << dt.date().toString(Qt::ISODate);
|
||||
for (auto i = prepaidRange.first; i != prepaidRange.second; ++i) {
|
||||
ATBTariffPrepaid const &prepaid = i->second;
|
||||
if (prepaid.m_date.isNull() || !prepaid.m_date.isValid()) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "default";
|
||||
TimeRange const &prepaidTimeRange = prepaid.m_range;
|
||||
if (inputTime >= prepaidTimeRange.m_start && inputTime < prepaidTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << prepaidTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << prepaidTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(i->second);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
///
|
||||
/// \brief getCarryOver
|
||||
/// \param cfg
|
||||
/// \param dt
|
||||
/// \return
|
||||
///
|
||||
std::optional<ATBTariffCarryOver> getCarryOver(Configuration const *cfg, QDateTime const &dt) {
|
||||
std::optional<ATBTariffCarryOver> value = std::nullopt;
|
||||
|
||||
|
||||
int weekDay = dt.date().dayOfWeek();
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << dt.toString(Qt::ISODate) << weekDay;
|
||||
|
||||
ATBTime inputTime(dt.time());
|
||||
auto const &carryOverRange = cfg->TariffCarryOvers.equal_range(weekDay);
|
||||
|
||||
QDate d; // check if a special date is configured in tariff-file for this day
|
||||
for (auto i = carryOverRange.first; i != carryOverRange.second; ++i) {
|
||||
ATBTariffCarryOver const &carryOver = i->second;
|
||||
if (!carryOver.m_date.isNull() && carryOver.m_date.isValid() && carryOver.m_date == dt.date()) {
|
||||
d = dt.date();
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "found special day" << d.toString(Qt::ISODate);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
for (auto i = carryOverRange.first; i != carryOverRange.second; ++i) {
|
||||
ATBTariffCarryOver const &carryOver = i->second;
|
||||
|
||||
if (!carryOver.m_date.isNull() && carryOver.m_date.isValid() && carryOver.m_date == d) {
|
||||
TimeRange const &carryOverTimeRange = carryOver.m_range;
|
||||
if (inputTime >= carryOverTimeRange.m_start && inputTime < carryOverTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << carryOverTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << carryOverTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(carryOver);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "no special day" << dt.date().toString(Qt::ISODate);
|
||||
for (auto i = carryOverRange.first; i != carryOverRange.second; ++i) {
|
||||
ATBTariffCarryOver const &carryOver = i->second;
|
||||
if (carryOver.m_date.isNull() || !carryOver.m_date.isValid()) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "default";
|
||||
TimeRange const &carryOverTimeRange = carryOver.m_range;
|
||||
if (inputTime >= carryOverTimeRange.m_start && inputTime < carryOverTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << carryOverTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << carryOverTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(carryOver);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
///
|
||||
/// \brief getService
|
||||
/// \param cfg
|
||||
/// \param dt
|
||||
/// \return
|
||||
///
|
||||
|
||||
std::optional<ATBTariffService> getService(Configuration const *cfg, QDateTime const &dt) {
|
||||
std::optional<ATBTariffService> value = std::nullopt;
|
||||
|
||||
int weekDay = dt.date().dayOfWeek();
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << dt.toString(Qt::ISODate) << weekDay;
|
||||
|
||||
ATBTime inputTime(dt.time());
|
||||
auto const &serviceRange = cfg->TariffServices.equal_range(weekDay);
|
||||
|
||||
QDate d; // check if a special date is configured in tariff-file for this day
|
||||
for (auto i = serviceRange.first; i != serviceRange.second; ++i) {
|
||||
ATBTariffService const &service = i->second;
|
||||
if (!service.m_date.isNull() && service.m_date.isValid() && service.m_date == dt.date()) {
|
||||
d = dt.date();
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "found special day" << d.toString(Qt::ISODate);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
for (auto i = serviceRange.first; i != serviceRange.second; ++i) {
|
||||
ATBTariffService const &service = i->second;
|
||||
|
||||
if (!service.m_date.isNull() && service.m_date.isValid() && service.m_date == d) {
|
||||
TimeRange const &serviceTimeRange = service.m_range;
|
||||
if (inputTime >= serviceTimeRange.m_start && inputTime < serviceTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << serviceTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << serviceTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(service);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "no special day" << dt.date().toString(Qt::ISODate);
|
||||
for (auto i = serviceRange.first; i != serviceRange.second; ++i) {
|
||||
ATBTariffService const &service = i->second;
|
||||
if (service.m_date.isNull() || !service.m_date.isValid()) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "default";
|
||||
TimeRange const &serviceTimeRange = service.m_range;
|
||||
if (inputTime >= serviceTimeRange.m_start && inputTime < serviceTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << serviceTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << serviceTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(service);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
///
|
||||
/// \brief getOutOfService
|
||||
/// \param cfg
|
||||
/// \param dt
|
||||
/// \return
|
||||
///
|
||||
std::optional<ATBTariffOutOfService> getOutOfService(Configuration const *cfg, QDateTime const &dt) {
|
||||
std::optional<ATBTariffOutOfService> value = std::nullopt;
|
||||
|
||||
int weekDay = dt.date().dayOfWeek();
|
||||
// qCritical() << __func__ << ":" << __LINE__ << dt.toString(Qt::ISODate) << weekDay;
|
||||
|
||||
ATBTime inputTime(dt.time());
|
||||
QDate date;
|
||||
|
||||
auto const &outOfServiceRange = cfg->TariffOutOfServices.equal_range(weekDay);
|
||||
|
||||
QDate d; // check if a special date is configured in tariff-file for this day
|
||||
for (auto i = outOfServiceRange.first; i != outOfServiceRange.second; ++i) {
|
||||
ATBTariffOutOfService const &outOfService = i->second;
|
||||
if (!outOfService.m_date.isNull() && outOfService.m_date.isValid() && outOfService.m_date == dt.date()) {
|
||||
d = dt.date();
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "found special day" << d.toString(Qt::ISODate);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
for (auto i = outOfServiceRange.first; i != outOfServiceRange.second; ++i) {
|
||||
ATBTariffOutOfService const &outOfService = i->second;
|
||||
|
||||
if (!outOfService.m_date.isNull() && outOfService.m_date.isValid() && outOfService.m_date == d) {
|
||||
TimeRange const &outOfServiceTimeRange = outOfService.m_range;
|
||||
if (inputTime >= outOfServiceTimeRange.m_start && inputTime < outOfServiceTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << outOfServiceTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << outOfServiceTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(outOfService);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "no special day" << dt.date().toString(Qt::ISODate);
|
||||
for (auto i = outOfServiceRange.first; i != outOfServiceRange.second; ++i) {
|
||||
ATBTariffOutOfService const &outOfService = i->second;
|
||||
if (outOfService.m_date.isNull() || !outOfService.m_date.isValid()) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "default";
|
||||
TimeRange const &outOfServiceTimeRange = outOfService.m_range;
|
||||
if (inputTime >= outOfServiceTimeRange.m_start && inputTime < outOfServiceTimeRange.m_end) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << outOfServiceTimeRange.m_start.toString(Qt::ISODate);
|
||||
// qCritical() << __func__ << ":" << __LINE__ << outOfServiceTimeRange.m_end.toString(Qt::ISODate);
|
||||
value = value.value_or(outOfService);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
std::pair<CalcState, QDateTime>
|
||||
Calculator::ComputeDurationFromCost(Configuration *cfg,
|
||||
QDateTime const &startDatetimePassed, // given in local time
|
||||
int cost) {
|
||||
|
||||
QDateTime inputDate = startDatetimePassed;
|
||||
inputDate.setTime(QTime(inputDate.time().hour(), inputDate.time().minute(), 0));
|
||||
|
||||
// TODO:
|
||||
int paymentOptionIndex = 0;
|
||||
|
||||
bool overPaid = false;
|
||||
bool successMaxPrice = false;
|
||||
|
||||
int const pop_id = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
|
||||
int const pop_accumulate_prices = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_prices;
|
||||
int const pop_max_price = cfg->getPaymentOptions(paymentOptionIndex).pop_max_price;
|
||||
int const pop_max_time = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
|
||||
int const pop_min_price = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
|
||||
int const pop_allow_overpay = cfg->getPaymentOptions(paymentOptionIndex).pop_allow_overpay;
|
||||
|
||||
int price = 0;
|
||||
int durationId = 0;
|
||||
int netto_parking_time_in_minutes = 0;
|
||||
int brutto_parking_time_in_minutes = 0;
|
||||
int free_parking_time_in_minutes = 0;
|
||||
|
||||
QMap<int, int> nettoParktimePrice;
|
||||
QMap<int, int> priceNettoParktime;
|
||||
|
||||
for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
|
||||
durationId = itr->second.pra_payment_unit_id;
|
||||
|
||||
int const pra_price = itr->second.pra_price;
|
||||
if (pop_accumulate_prices) {
|
||||
price += pra_price;
|
||||
} else {
|
||||
price = pra_price;
|
||||
}
|
||||
|
||||
//if ((double)price == cost) {
|
||||
auto search = cfg->Duration.find(durationId);
|
||||
if (search != cfg->Duration.end()) {
|
||||
// found now the duration in minutes
|
||||
// check if we are still inside the working-time-range
|
||||
ATBDuration duration = search->second;
|
||||
nettoParktimePrice.insert(duration.pun_duration, price);
|
||||
priceNettoParktime.insert(price, duration.pun_duration);
|
||||
}
|
||||
|
||||
|
||||
//}
|
||||
}
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << nettoParktimePrice;
|
||||
// qCritical() << __func__ << ":" << __LINE__ << priceNettoParktime;
|
||||
|
||||
if (cost == pop_max_price) {
|
||||
qCritical() << DBG_HEADER << "SUCCESS MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
successMaxPrice = true;
|
||||
}
|
||||
|
||||
if (cost > pop_max_price) {
|
||||
qCritical() << DBG_HEADER << "MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
if (pop_allow_overpay == false) {
|
||||
return std::make_pair(CalcState(CalcState::State::OVERPAID), QDateTime());
|
||||
}
|
||||
cost = pop_max_price;
|
||||
overPaid = true;
|
||||
qCritical() << DBG_HEADER << "OVERPAID, MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
// return CalcState::OVERPAID.toStdString();
|
||||
}
|
||||
|
||||
if (cost < pop_min_price) {
|
||||
qCritical() << DBG_HEADER << "MIN-PARKING-PRICE" << pop_min_price << ", COST" << cost;
|
||||
return std::make_pair(CalcState(CalcState::State::BELOW_MIN_PARKING_PRICE), QDateTime());
|
||||
}
|
||||
|
||||
int weekDay = inputDate.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "START weekDay" << weekDay << inputDate.toString(Qt::ISODate);
|
||||
qCritical() << __func__ << ":" << __LINE__ << "START cost" << cost;
|
||||
|
||||
QDateTime dt;
|
||||
bool computationStarted = false;
|
||||
price = 0;
|
||||
netto_parking_time_in_minutes = 0;
|
||||
brutto_parking_time_in_minutes = 0;
|
||||
free_parking_time_in_minutes = 0;
|
||||
|
||||
int const nettoParktimeForCost = priceNettoParktime[int(cost)];
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("cost=%1 nettoParkTimeForCost=%2").
|
||||
arg(cost).arg(nettoParktimeForCost);
|
||||
|
||||
int cnt = 0;
|
||||
while (++cnt < 10 && netto_parking_time_in_minutes < nettoParktimeForCost) {
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "cnt [" << cnt;
|
||||
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
weekDay = dt.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("%1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
|
||||
if (std::optional<ATBTariffOutOfService> oos = getOutOfService(cfg, dt)) {
|
||||
dt.setTime(QTime(oos.value().m_range.m_start.hour(),
|
||||
oos.value().m_range.m_start.minute(), 0));
|
||||
if (overPaid) {
|
||||
QList <int> keys = nettoParktimePrice.keys();
|
||||
for (int k = 0; k < keys.size(); ++k) {
|
||||
if (keys[k] < netto_parking_time_in_minutes) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int const maxPriceForTimeLimit = nettoParktimePrice[keys[k]];
|
||||
if (cost > maxPriceForTimeLimit) {
|
||||
cfg->getPaymentOptions(paymentOptionIndex).pop_max_price = maxPriceForTimeLimit;
|
||||
|
||||
CalcState cs(CalcState::State::OVERPAID);
|
||||
return std::make_pair(cs, dt);
|
||||
}
|
||||
if (cost == maxPriceForTimeLimit) {
|
||||
cfg->getPaymentOptions(paymentOptionIndex).pop_max_price = maxPriceForTimeLimit;
|
||||
|
||||
CalcState cs(CalcState::State::SUCCESS_MAXPRICE);
|
||||
return std::make_pair(cs, dt);
|
||||
}
|
||||
}
|
||||
return std::make_pair(CalcState(CalcState::State::OVERPAID), dt);
|
||||
}
|
||||
qCritical() << __func__ << ":" << __LINE__ << "set time-limit reached";
|
||||
qCritical() << __func__ << ":" << __LINE__ << "netto-parking-time" << netto_parking_time_in_minutes;
|
||||
|
||||
Calculator::GetInstance().setTimeLimitReached(true);
|
||||
QList <int> keys = nettoParktimePrice.keys();
|
||||
for (int k = 0; k < keys.size(); ++k) {
|
||||
if (keys[k] < netto_parking_time_in_minutes) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int const maxPriceForTimeLimit = nettoParktimePrice[keys[k]];
|
||||
qCritical() << __func__ << ":" << __LINE__ << keys[k] << maxPriceForTimeLimit << cost;
|
||||
// Calculator::GetInstance().setCostAtTimeLimit(nettoParktimePrice[keys[k]]);
|
||||
if (cost > maxPriceForTimeLimit) {
|
||||
cfg->getPaymentOptions(paymentOptionIndex).pop_max_price = maxPriceForTimeLimit;
|
||||
|
||||
CalcState cs(CalcState::State::OVERPAID);
|
||||
return std::make_pair(cs, dt);
|
||||
}
|
||||
if (cost == maxPriceForTimeLimit) {
|
||||
cfg->getPaymentOptions(paymentOptionIndex).pop_max_price = maxPriceForTimeLimit;
|
||||
|
||||
CalcState cs(CalcState::State::SUCCESS_MAXPRICE);
|
||||
return std::make_pair(cs, dt);
|
||||
}
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "DT" << dt.toString(Qt::ISODate);
|
||||
return std::make_pair(CalcState(CalcState::State::SUCCESS), dt);
|
||||
}
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "outside allowed parking time" << dt.toString(Qt::ISODate);
|
||||
|
||||
return std::make_pair(CalcState(CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME,
|
||||
CalcState::OUTSIDE_ALLOWED_PARKING_TIME), dt);
|
||||
}
|
||||
|
||||
if (computationStarted == false) {
|
||||
computationStarted = true;
|
||||
if (std::optional<ATBTariffPrepaid> pp = getPrepaid(cfg, dt)) {
|
||||
TimeRange const &prepaidTimeRange = pp.value().m_range;
|
||||
ATBTime t(dt.time().hour(), dt.time().minute(), 0, 0);
|
||||
free_parking_time_in_minutes += t.secsTo(prepaidTimeRange.m_end.toString(Qt::ISODate)) / 60;
|
||||
}
|
||||
}
|
||||
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
weekDay = dt.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("%1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
|
||||
if (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
|
||||
int minutes = co.value().computeMinutesUntilCarryOverEnd(dt);
|
||||
if (minutes > 0) {
|
||||
free_parking_time_in_minutes += minutes;
|
||||
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
weekDay = dt.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("%1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
}
|
||||
}
|
||||
|
||||
if (std::optional<ATBTariffService> serv = getService(cfg, dt)) {
|
||||
TimeRange const &serviceTimeRange = serv.value().m_range;
|
||||
|
||||
if (nettoParktimeForCost > netto_parking_time_in_minutes) {
|
||||
int rest_parking_time_in_minutes = nettoParktimeForCost - netto_parking_time_in_minutes;
|
||||
ATBTime t(dt.time().hour(), dt.time().minute(), 0, 0);
|
||||
int timeToServiceEnd = t.secsTo(serviceTimeRange.m_end.toString(Qt::ISODate)) / 60;
|
||||
|
||||
// TODO: wohl aehnlich wie carry-over zu behandlen
|
||||
if (serviceTimeRange.m_duration > 0) {
|
||||
if (timeToServiceEnd < rest_parking_time_in_minutes) {
|
||||
netto_parking_time_in_minutes += timeToServiceEnd;
|
||||
} else {
|
||||
netto_parking_time_in_minutes += rest_parking_time_in_minutes;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
weekDay = dt.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("%1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << "cnt" << cnt << "]";
|
||||
}
|
||||
|
||||
if (cnt >= 10) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "BREAK";
|
||||
}
|
||||
|
||||
// configure if last carry-over ranges shall be added to ticket-end-time
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
|
||||
cnt = 0;
|
||||
QVector<TimeRange> timeRanges;
|
||||
while (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
|
||||
if (++cnt > 10) {
|
||||
break;
|
||||
}
|
||||
TimeRange const &carryOverTimeRange = co.value().m_range;
|
||||
if (!timeRanges.isEmpty()) {
|
||||
if (timeRanges.last().m_end != carryOverTimeRange.m_start) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
timeRanges.push_back(carryOverTimeRange);
|
||||
|
||||
int minutes = co.value().computeMinutesUntilCarryOverEnd(dt);
|
||||
if (minutes > 0) {
|
||||
free_parking_time_in_minutes += co.value().computeMinutesUntilCarryOverEnd(dt);
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("%1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
} else break;
|
||||
}
|
||||
|
||||
brutto_parking_time_in_minutes = free_parking_time_in_minutes + netto_parking_time_in_minutes;
|
||||
dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
|
||||
weekDay = dt.date().dayOfWeek();
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << QString("ticket-end-time %1 (%2): brutto: %3 = netto: %4 + free: %5")
|
||||
.arg(dt.toString(Qt::ISODate))
|
||||
.arg(weekDay)
|
||||
.arg(brutto_parking_time_in_minutes)
|
||||
.arg(netto_parking_time_in_minutes)
|
||||
.arg(free_parking_time_in_minutes);
|
||||
|
||||
if (successMaxPrice) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "SUCC" << dt;
|
||||
return std::make_pair(CalcState(CalcState::State::SUCCESS_MAXPRICE), dt);
|
||||
}
|
||||
if (overPaid) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "OVER" << dt;
|
||||
return std::make_pair(CalcState(CalcState::State::OVERPAID), dt);
|
||||
}
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "DT" << dt.toString(Qt::ISODate);
|
||||
return std::make_pair(CalcState(CalcState::State::SUCCESS), dt);
|
||||
}
|
||||
|
||||
std::pair<CalcState, std::optional<int>>
|
||||
Calculator::ComputeCostFromDuration(Configuration *cfg, QDateTime const &startDatetime,
|
||||
QDateTime &endDatetime, int nettoParkingTime) {
|
||||
|
||||
// TODO
|
||||
int paymentOptionIndex = 0;
|
||||
|
||||
std::optional<int> cost{};
|
||||
|
||||
int const pop_id = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
|
||||
int const pop_accumulate_prices = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_prices;
|
||||
|
||||
int price = 0;
|
||||
int durationId = 0;
|
||||
int netto_parking_time_in_minutes = 0;
|
||||
int brutto_parking_time_in_minutes = 0;
|
||||
int free_parking_time_in_minutes = 0;
|
||||
|
||||
QMap<int, int> nettoParktimePrice;
|
||||
QMap<int, int> priceNettoParktime;
|
||||
|
||||
for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
|
||||
durationId = itr->second.pra_payment_unit_id;
|
||||
|
||||
int const pra_price = itr->second.pra_price;
|
||||
if (pop_accumulate_prices) {
|
||||
price += pra_price;
|
||||
} else {
|
||||
price = pra_price;
|
||||
}
|
||||
|
||||
auto search = cfg->Duration.find(durationId);
|
||||
if (search != cfg->Duration.end()) {
|
||||
// found now the duration in minutes
|
||||
// check if we are still inside the working-time-range
|
||||
ATBDuration duration = search->second;
|
||||
nettoParktimePrice.insert(duration.pun_duration, price);
|
||||
priceNettoParktime.insert(price, duration.pun_duration);
|
||||
}
|
||||
}
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "START netto-parking-time" << nettoParkingTime;
|
||||
CalcState returnState;
|
||||
|
||||
QList<int> keys = nettoParktimePrice.keys();
|
||||
int index = keys.indexOf(nettoParkingTime);
|
||||
if (index != -1) {
|
||||
int c = nettoParktimePrice[keys.at(index)];
|
||||
qCritical() << __func__ << ":" << __LINE__ << "cost for netto-parking-time" << c;
|
||||
|
||||
std::pair<CalcState, QDateTime> r = ComputeDurationFromCost(cfg, startDatetime, c);
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "result"
|
||||
<< r.first.toString() << r.second.toString(Qt::ISODate);
|
||||
|
||||
returnState = r.first;
|
||||
endDatetime = r.second;
|
||||
|
||||
|
||||
if (returnState.getStatus() == CalcState::State::SUCCESS ||
|
||||
returnState.getStatus() == CalcState::State::SUCCESS_MAXPRICE ||
|
||||
returnState.getStatus() == CalcState::State::OVERPAID) {
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "--- endDateTime" << endDatetime.toString(Qt::ISODate);
|
||||
qCritical() << __func__ << ":" << __LINE__ << "------ r.second" << r.second.toString(Qt::ISODate);
|
||||
qCritical() << __func__ << ":" << __LINE__ << "status" << returnState.toString() << (int)returnState.getStatus();
|
||||
|
||||
if (!endDatetime.isNull() && endDatetime.isValid()) {
|
||||
cost = c;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (cost) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "--- return cost" << cost.value();
|
||||
return std::make_pair(returnState, cost);
|
||||
}
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << "--- return error for cost" << returnState.toString();
|
||||
return std::make_pair(returnState, cost);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
std::pair<std::string, QDateTime>
|
||||
Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
@ -767,7 +136,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
|
||||
|
||||
bool overPaid = false;
|
||||
bool successMaxPrice = false; // max-price and cost match
|
||||
|
||||
int paymentOptionIndex = getPaymentOptionIndex(*cfg, inputDate);
|
||||
if (paymentOptionIndex == -1) {
|
||||
@ -884,17 +252,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
qCritical() << DBG_HEADER << " TODO";
|
||||
}
|
||||
} else
|
||||
if (paymentMethodId == PaymentMethod::Unified) {
|
||||
std::pair<CalcState, QDateTime> r =
|
||||
ComputeDurationFromCost(cfg, QDateTime::fromString(startDatetimePassed, Qt::ISODate), cost);
|
||||
|
||||
CalcState cs = r.first;
|
||||
|
||||
qCritical() << __func__ << ":" << __LINE__ << cs.toString();
|
||||
qCritical() << __func__ << ":" << __LINE__ << r.second.toString(Qt::ISODate);
|
||||
|
||||
return std::make_pair(r.first.toString().toStdString(), r.second);
|
||||
} else
|
||||
if (paymentMethodId == PaymentMethod::Steps) {
|
||||
if (tariffIs24_7(cfg)) {
|
||||
// use tariff with structure as for instance Schoenau, Koenigsee:
|
||||
@ -913,16 +270,8 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
|
||||
int const pop_id = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
|
||||
int const pop_max_price = cfg->getPaymentOptions(paymentOptionIndex).pop_max_price;
|
||||
//int const pop_max_time = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
|
||||
int const pop_min_price = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
|
||||
int const pop_allow_overpay = cfg->getPaymentOptions(paymentOptionIndex).pop_allow_overpay;
|
||||
int const pop_accumulate_prices = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_prices;
|
||||
int price = 0;
|
||||
|
||||
if (cost == pop_max_price) {
|
||||
qCritical() << DBG_HEADER << "SUCCESS MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
successMaxPrice = true;
|
||||
}
|
||||
|
||||
if (cost > pop_max_price) {
|
||||
qCritical() << DBG_HEADER << "MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
@ -931,7 +280,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
}
|
||||
cost = pop_max_price;
|
||||
overPaid = true;
|
||||
qCritical() << DBG_HEADER << "OVERPAID, MAX-PARKING-PRICE" << pop_max_price << ", COST" << cost;
|
||||
// return CalcState::OVERPAID.toStdString();
|
||||
}
|
||||
|
||||
@ -1055,9 +403,9 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
qCritical() << DBG_HEADER << " CURRENT WORKING-TIME-TO" << current_working_time_to.toString(Qt::ISODate);
|
||||
#endif
|
||||
|
||||
// int const pop_accumulate_prices = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_prices;
|
||||
int const pop_accumulate_prices = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_prices;
|
||||
// int const pop_accumulate_durations = cfg->getPaymentOptions(paymentOptionIndex).pop_accumulate_durations;
|
||||
// int price = 0;
|
||||
int price = 0;
|
||||
int new_price = 0;
|
||||
int durationInSecs = 0;
|
||||
uint32_t duration_previous = 0;
|
||||
@ -1099,9 +447,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), d);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), d);
|
||||
}
|
||||
return std::make_pair(d.toString(Qt::ISODate).toStdString(), d);
|
||||
}
|
||||
} else {
|
||||
@ -1178,16 +523,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
|
||||
//qCritical() << DBG_HEADER << "NEW INPUT" << inputDate.toString(Qt::ISODate);
|
||||
|
||||
int const pop_carry_over = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over;
|
||||
if (pop_carry_over) {
|
||||
int weekDay = inputDate.date().dayOfWeek();
|
||||
int const pop_carry_over_option_id = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_option_id;
|
||||
if (pop_carry_over_option_id != -1) {
|
||||
int const carryOverDuration = cfg->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;
|
||||
inputDate = inputDate.addSecs(carryOverDuration * 60);
|
||||
}
|
||||
}
|
||||
|
||||
inputDate = inputDate.addSecs(durationInSecs);
|
||||
#if DEBUG_GET_DURATION_FROM_COST==1
|
||||
qCritical() << DBG_HEADER << "TICKET-END" << inputDate.toString(Qt::ISODate);
|
||||
@ -1226,9 +561,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), inputDate);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), inputDate);
|
||||
}
|
||||
return std::make_pair(s.toStdString(), inputDate);
|
||||
} // if ((double)price == cost) {
|
||||
else {
|
||||
@ -1316,9 +648,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
} else {
|
||||
QDateTime const dt = start;
|
||||
@ -1369,9 +698,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
}
|
||||
|
||||
@ -1470,9 +796,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
}
|
||||
}
|
||||
@ -1517,9 +840,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
}
|
||||
|
||||
@ -1554,9 +874,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
}
|
||||
|
||||
@ -1676,9 +993,6 @@ Calculator::GetDurationFromCost(Configuration* cfg,
|
||||
if (overPaid) {
|
||||
return std::make_pair(CalcState::OVERPAID.toStdString(), end_datetime);
|
||||
}
|
||||
if (successMaxPrice) {
|
||||
return std::make_pair(CalcState::SUCCESS_MAXPRICE.toStdString(), end_datetime);
|
||||
}
|
||||
return std::make_pair(end_datetime.toString(Qt::ISODate).toStdString(), end_datetime);
|
||||
}
|
||||
}
|
||||
@ -1848,7 +1162,7 @@ CalcState Calculator::isParkingAllowedForWeekDay(Configuration const *cfg,
|
||||
(int)cfg->TimeRange.count(pop_carry_over_end_time_range) <= 0) {
|
||||
|
||||
qCritical() << DBG_HEADER << "PARKING_ALLOWED. startTime" << startTime.toString(Qt::ISODate);
|
||||
return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED", startTime, QTime());
|
||||
return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED", startTime);
|
||||
|
||||
} else
|
||||
// search entry in time-range-field of tariff-file
|
||||
|
||||
@ -10,9 +10,6 @@
|
||||
#include "tariff_global_defines.h"
|
||||
#include "tariff_settings.h"
|
||||
#include "tariff_carryover_settings.h"
|
||||
#include "atb_time.h"
|
||||
#include "tariff_prepaid.h"
|
||||
#include "tariff_carryover.h"
|
||||
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
@ -64,405 +61,6 @@ ATBWeekDay parseWeekDay(Configuration &cfg,
|
||||
ATBWeekDay WeekDay;
|
||||
QTime start, end, parking_time_limit, about_to_exceed_limit;
|
||||
ATBTariffCarryOverSettings::ParkingTimeLimitChecker parkTimeLimitChecker;
|
||||
QDate const &d = QDate::fromString(innerObjName, Qt::ISODate);
|
||||
if (innerObjName == QString("default") ||
|
||||
(!d.isNull() && d.isValid())) { // special day, given in date-format
|
||||
// start with new implementation of tariff-calculator
|
||||
// see for instance: bad neuenahr (249), Zone5
|
||||
|
||||
// qCritical() << __func__ << ":" << __LINE__ << innerObjName;
|
||||
|
||||
if (k->value.IsObject()) {
|
||||
auto obj = k->value.GetObject();
|
||||
for (auto m = obj.MemberBegin(); m != obj.MemberEnd(); ++m) {
|
||||
QString const &name = m->name.GetString();
|
||||
if (name == "payment_settings") {
|
||||
if (m->value.IsArray()) {
|
||||
auto payment = m->value.GetArray();
|
||||
if (payment.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no payment settings for" << weekDayName;
|
||||
} else {
|
||||
for (rapidjson::SizeType j = 0; j < payment.Size(); ++j) {
|
||||
if (payment[j].IsObject()) {
|
||||
auto paymentSetting = payment[j].GetObject();
|
||||
for (auto n = paymentSetting.MemberBegin(); n != paymentSetting.MemberEnd(); ++n) {
|
||||
QString const &name = QString::fromStdString(n->name.GetString());
|
||||
if (name == "min_time") {
|
||||
if (n->value.IsInt()) { min_time = n->value.GetInt(); }
|
||||
} else if (name == "max_time") {
|
||||
if (n->value.IsInt()) { max_time = n->value.GetInt(); }
|
||||
} else if (name == "min_price") {
|
||||
if (n->value.IsInt()) { min_price = n->value.GetInt(); }
|
||||
} else if (name == "max_price") {
|
||||
if (n->value.IsInt()) { max_price = n->value.GetInt(); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} else
|
||||
if (name == "prepaid_settings") {
|
||||
if (m->value.IsArray()) {
|
||||
auto prepaid = m->value.GetArray();
|
||||
if (prepaid.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no prepaid-settings for" << weekDayName;
|
||||
} else {
|
||||
ATBTariffPrepaid TariffPrepaid;
|
||||
for (rapidjson::SizeType j = 0; j < prepaid.Size(); ++j) {
|
||||
if (prepaid[j].IsObject()) {
|
||||
auto prepaidSetting = prepaid[j].GetObject();
|
||||
for (auto n = prepaidSetting.MemberBegin(); n != prepaidSetting.MemberEnd(); ++n) {
|
||||
QString const &name = QString::fromStdString(n->name.GetString());
|
||||
if (name == "prepaid_ranges") {
|
||||
if (n->value.IsArray()) {
|
||||
auto prepaidRanges = n->value.GetArray();
|
||||
if (prepaidRanges.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no prepaid-ranges for" << weekDayName;
|
||||
} else {
|
||||
QString prepaidStartStr;
|
||||
QString prepaidEndStr;
|
||||
QString prepaidIf;
|
||||
int prepaidDuration = -1;
|
||||
for (rapidjson::SizeType i = 0; i < prepaidRanges.Size(); ++i) {
|
||||
if (prepaidRanges[j].IsObject()) {
|
||||
auto prepaidRange = prepaidRanges[i].GetObject();
|
||||
for (auto r = prepaidRange.MemberBegin(); r != prepaidRange.MemberEnd(); ++r) {
|
||||
QString const &memName = QString::fromStdString(r->name.GetString());
|
||||
if (memName == "prepaid_id") {
|
||||
if (r->value.IsInt()) {
|
||||
TariffPrepaid.m_id = r->value.GetInt();
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "prepaidId not an integer";
|
||||
}
|
||||
} else
|
||||
if (memName == "prepaid_duration") {
|
||||
if (r->value.IsInt()) {
|
||||
prepaidDuration = r->value.GetInt();
|
||||
}
|
||||
} else
|
||||
if (memName == "prepaid_start") {
|
||||
if (r->value.IsString()) {
|
||||
prepaidStartStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "prepaid_end") {
|
||||
if (r->value.IsString()) {
|
||||
prepaidEndStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "prepaid_if") {
|
||||
if (r->value.IsString()) {
|
||||
prepaidIf = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "WARNING unknown prepaid setting" << memName;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!prepaidStartStr.isEmpty() && !prepaidEndStr.isEmpty() && prepaidDuration != -1) {
|
||||
ATBTime prepaidStart(prepaidStartStr);
|
||||
ATBTime prepaidEnd(prepaidEndStr);
|
||||
if (prepaidStart.isValid() && prepaidEnd.isValid()) {
|
||||
TariffPrepaid.m_range = TimeRange(prepaidStart, prepaidEnd, prepaidDuration);
|
||||
TariffPrepaid.m_weekDay = weekDayName;
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
TariffPrepaid.m_date = d;
|
||||
}
|
||||
TariffPrepaid.setPrepaidIf(prepaidIf);
|
||||
|
||||
qCritical() << TariffPrepaid;
|
||||
|
||||
cfg.TariffPrepaids.insert(std::pair<int, ATBTariffPrepaid>(weekDay, TariffPrepaid));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
if (name == "carry_over_settings") {
|
||||
if (m->value.IsArray()) {
|
||||
auto carryOver = m->value.GetArray();
|
||||
if (carryOver.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no carry-over-settings for" << weekDayName;
|
||||
} else {
|
||||
ATBTariffCarryOver TariffCarryOver;
|
||||
for (rapidjson::SizeType j = 0; j < carryOver.Size(); ++j) {
|
||||
if (carryOver[j].IsObject()) {
|
||||
auto carryOverSetting = carryOver[j].GetObject();
|
||||
for (auto n = carryOverSetting.MemberBegin(); n != carryOverSetting.MemberEnd(); ++n) {
|
||||
QString const &name = QString::fromStdString(n->name.GetString());
|
||||
if (name == "carry_over_ranges") {
|
||||
if (n->value.IsArray()) {
|
||||
auto carryOverRanges = n->value.GetArray();
|
||||
if (carryOverRanges.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no carry-over-ranges for" << weekDayName;
|
||||
} else {
|
||||
QString carryOverStartStr;
|
||||
QString carryOverEndStr;
|
||||
QString carryOverIf;
|
||||
int carryOverDuration = -1;
|
||||
for (rapidjson::SizeType i = 0; i < carryOverRanges.Size(); ++i) {
|
||||
if (carryOverRanges[j].IsObject()) {
|
||||
auto carryOverRange = carryOverRanges[i].GetObject();
|
||||
for (auto r = carryOverRange.MemberBegin(); r != carryOverRange.MemberEnd(); ++r) {
|
||||
QString const &memName = QString::fromStdString(r->name.GetString());
|
||||
if (memName == "carry_over_id") {
|
||||
if (r->value.IsInt()) {
|
||||
TariffCarryOver.m_id = r->value.GetInt();
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "carryOverId not an integer";
|
||||
}
|
||||
} else
|
||||
if (memName == "carry_over_duration") {
|
||||
if (r->value.IsInt()) {
|
||||
carryOverDuration = r->value.GetInt();
|
||||
}
|
||||
} else
|
||||
if (memName == "carry_over_start") {
|
||||
if (r->value.IsString()) {
|
||||
carryOverStartStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "carry_over_end") {
|
||||
if (r->value.IsString()) {
|
||||
carryOverEndStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "carry_over_if") {
|
||||
if (r->value.IsString()) {
|
||||
carryOverIf = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "WARNING unknown carry-over setting" << memName;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!carryOverStartStr.isEmpty() && !carryOverEndStr.isEmpty() && carryOverDuration != -1) {
|
||||
ATBTime carryOverStart(carryOverStartStr);
|
||||
ATBTime carryOverEnd(carryOverEndStr);
|
||||
if (carryOverStart.isValid() && carryOverEnd.isValid()) {
|
||||
TariffCarryOver.m_range = TimeRange(carryOverStart, carryOverEnd, carryOverDuration);
|
||||
TariffCarryOver.m_weekDay = weekDayName;
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
TariffCarryOver.m_date = d;
|
||||
}
|
||||
if (!carryOverIf.isEmpty()) {
|
||||
TariffCarryOver.setCarryOverIf(carryOverIf);
|
||||
}
|
||||
|
||||
// qCritical() << TariffCarryOver;
|
||||
|
||||
cfg.TariffCarryOvers.insert(std::pair<int, ATBTariffCarryOver>(weekDay, TariffCarryOver));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
if (name == "service_settings") {
|
||||
ATBTariffService TariffService;
|
||||
if (m->value.IsArray()) {
|
||||
auto service = m->value.GetArray();
|
||||
if (service.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no service settings for" << weekDayName;
|
||||
} else {
|
||||
for (rapidjson::SizeType j = 0; j < service.Size(); ++j) {
|
||||
if (service[j].IsObject()) {
|
||||
auto serviceSetting = service[j].GetObject();
|
||||
for (auto n = serviceSetting.MemberBegin(); n != serviceSetting.MemberEnd(); ++n) {
|
||||
QString const &name = QString::fromStdString(n->name.GetString());
|
||||
if (name == "service_ranges") {
|
||||
if (n->value.IsArray()) {
|
||||
auto serviceRanges = n->value.GetArray();
|
||||
if (serviceRanges.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no service ranges for" << weekDayName;
|
||||
} else {
|
||||
QString serviceStartStr;
|
||||
QString serviceEndStr;
|
||||
QString serviceIf;
|
||||
int serviceDuration = -1;
|
||||
for (rapidjson::SizeType i = 0; i < serviceRanges.Size(); ++i) {
|
||||
if (serviceRanges[j].IsObject()) {
|
||||
auto serviceRange = serviceRanges[i].GetObject();
|
||||
for (auto r = serviceRange.MemberBegin(); r != serviceRange.MemberEnd(); ++r) {
|
||||
QString const &memName = QString::fromStdString(r->name.GetString());
|
||||
if (memName == "service_id") {
|
||||
if (r->value.IsInt()) {
|
||||
TariffService.m_id = r->value.GetInt();
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "serviceId not an integer";
|
||||
}
|
||||
} else
|
||||
if (memName == "service_duration") {
|
||||
if (r->value.IsInt()) {
|
||||
serviceDuration = r->value.GetInt();
|
||||
}
|
||||
} else
|
||||
if (memName == "service_start") {
|
||||
if (r->value.IsString()) {
|
||||
serviceStartStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "service_end") {
|
||||
if (r->value.IsString()) {
|
||||
serviceEndStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "service_if") {
|
||||
if (r->value.IsString()) {
|
||||
serviceIf = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "WARNING unknown service setting" << memName;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!serviceStartStr.isEmpty() && !serviceEndStr.isEmpty() && serviceDuration != -1) {
|
||||
ATBTime serviceStart(serviceStartStr);
|
||||
ATBTime serviceEnd(serviceEndStr);
|
||||
if (serviceStart.isValid() && serviceEnd.isValid()) {
|
||||
TariffService.m_range = TimeRange(serviceStart, serviceEnd, serviceDuration);
|
||||
TariffService.m_weekDay = weekDayName;
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
TariffService.m_date = d;
|
||||
}
|
||||
if (!serviceIf.isEmpty()) {
|
||||
TariffService.setServiceIf(serviceIf);
|
||||
}
|
||||
|
||||
// qCritical() << TariffService;
|
||||
|
||||
cfg.TariffServices.insert(std::pair<int, ATBTariffService>(weekDay, TariffService));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
if (name == "out_of_service_settings") {
|
||||
ATBTariffOutOfService TariffOutOfService;
|
||||
if (m->value.IsArray()) {
|
||||
auto outOfService = m->value.GetArray();
|
||||
if (outOfService.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no out of service settings for" << weekDayName;
|
||||
} else {
|
||||
for (rapidjson::SizeType j = 0; j < outOfService.Size(); ++j) {
|
||||
if (outOfService[j].IsObject()) {
|
||||
auto outOfServiceSetting = outOfService[j].GetObject();
|
||||
for (auto n = outOfServiceSetting.MemberBegin(); n != outOfServiceSetting.MemberEnd(); ++n) {
|
||||
QString const &name = QString::fromStdString(n->name.GetString());
|
||||
if (name == "out_of_service_ranges") {
|
||||
if (n->value.IsArray()) {
|
||||
auto outOfServiceRanges = n->value.GetArray();
|
||||
if (outOfServiceRanges.Size() == 0) {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "no out of service ranges for" << weekDayName;
|
||||
} else {
|
||||
QString outOfServiceStartStr;
|
||||
QString outOfServiceEndStr;
|
||||
QString outOfServiceIf;
|
||||
int outOfServiceDuration = -1;
|
||||
for (rapidjson::SizeType i = 0; i < outOfServiceRanges.Size(); ++i) {
|
||||
if (outOfServiceRanges[j].IsObject()) {
|
||||
auto outOfServiceRange = outOfServiceRanges[i].GetObject();
|
||||
for (auto r = outOfServiceRange.MemberBegin(); r != outOfServiceRange.MemberEnd(); ++r) {
|
||||
QString const &memName = QString::fromStdString(r->name.GetString());
|
||||
if (memName == "out_of_service_id") {
|
||||
if (r->value.IsInt()) {
|
||||
TariffOutOfService.m_id = r->value.GetInt();
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "outOfServiceId not an integer";
|
||||
}
|
||||
} else
|
||||
if (memName == "out_of_service_duration") {
|
||||
if (r->value.IsInt()) {
|
||||
outOfServiceDuration = r->value.GetInt();
|
||||
}
|
||||
} else
|
||||
if (memName == "out_of_service_start") {
|
||||
if (r->value.IsString()) {
|
||||
outOfServiceStartStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "out_of_service_end") {
|
||||
if (r->value.IsString()) {
|
||||
outOfServiceEndStr = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else
|
||||
if (memName == "out_of_service_if") {
|
||||
if (r->value.IsString()) {
|
||||
outOfServiceIf = QString::fromStdString(r->value.GetString());
|
||||
}
|
||||
} else {
|
||||
qCritical() << __func__ << ":" << __LINE__ << "WARNING unknown out of service setting" << memName;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!outOfServiceStartStr.isEmpty() && !outOfServiceEndStr.isEmpty() && outOfServiceDuration != -1) {
|
||||
ATBTime outOfServiceStart(outOfServiceStartStr);
|
||||
ATBTime outOfServiceEnd(outOfServiceEndStr);
|
||||
if (outOfServiceStart.isValid() && outOfServiceEnd.isValid()) {
|
||||
TariffOutOfService.m_range = TimeRange(outOfServiceStart, outOfServiceEnd, outOfServiceDuration);
|
||||
TariffOutOfService.m_weekDay = weekDayName;
|
||||
if (!d.isNull() && d.isValid()) {
|
||||
TariffOutOfService.m_date = d;
|
||||
}
|
||||
if (!outOfServiceIf.isEmpty()) {
|
||||
TariffOutOfService.setOutOfServiceIf(outOfServiceIf);
|
||||
}
|
||||
|
||||
// qCritical() << TariffOutOfService;
|
||||
|
||||
cfg.TariffOutOfServices.insert(std::pair<int, ATBTariffOutOfService>(weekDay, TariffOutOfService));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
if (innerObjName == QString("week_day_default")) {
|
||||
if (k->value.IsObject()) {
|
||||
auto obj = k->value.GetObject();
|
||||
@ -1402,7 +1000,6 @@ bool Configuration::ParseJson(Configuration* cfg, const char* json)
|
||||
this->currentPaymentOptions.last().pop_min_time = k->value.GetDouble();
|
||||
} else if (strcmp(inner_obj_name, "pop_max_price") == 0) {
|
||||
this->currentPaymentOptions.last().pop_max_price = k->value.GetDouble();
|
||||
this->currentPaymentOptions.last().pop_max_price_save = k->value.GetDouble();
|
||||
} else if (strcmp(inner_obj_name, "pop_max_time") == 0) {
|
||||
this->currentPaymentOptions.last().pop_max_time = k->value.GetDouble();
|
||||
} else if (strcmp(inner_obj_name, "pop_min_price") == 0) {
|
||||
|
||||
@ -427,8 +427,6 @@ PaymentMethod Utilities::getPaymentMethodId(Configuration const *cfg) {
|
||||
return PaymentMethod::Degressive;
|
||||
case PaymentMethod::Progressive:
|
||||
return PaymentMethod::Progressive;
|
||||
case PaymentMethod::Unified:
|
||||
return PaymentMethod::Unified;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
127
main/main.cpp
127
main/main.cpp
@ -39,11 +39,11 @@ extern "C" char* strptime(const char* s,
|
||||
|
||||
#define SZEGED (0)
|
||||
#define SCHOENAU_KOENIGSEE (0)
|
||||
#define NEUHAUSER_KORNEUBURG (1)
|
||||
#define NEUHAUSER_KORNEUBURG (0)
|
||||
#define NEUHAUSER_LINSINGER_MASCHINENBAU (0)
|
||||
#define NEUHAUSER_NORDISCHES_AUSBILDUNGSZENTRUM (0)
|
||||
#define NEUHAUSER_BILEXA_GALTUER (0)
|
||||
#define BAD_NEUENAHR_AHRWEILER (0)
|
||||
#define BAD_NEUENAHR_AHRWEILER (1)
|
||||
#define NEUHAUSER_CHRISTOPH_REISEN (0)
|
||||
#define NEUHAUSER_PERNEGG_AN_DER_MUR (0)
|
||||
#define NEUHAUSER_STOCKERAU (0)
|
||||
@ -52,7 +52,6 @@ extern "C" char* strptime(const char* s,
|
||||
#define SCHNALS_LEITER_KIRCHL (0)
|
||||
#define SCHNALS_STAUMAUER (SCHNALS_LEITER_KIRCHL)
|
||||
#define VALSER_ALM (0)
|
||||
#define NEUHAUSER_FORCHACH (0)
|
||||
|
||||
#if NEUHAUSER_KIRCHDORF==1
|
||||
static bool test_neuhauser_kirchdorf(int step, double cost) {
|
||||
@ -756,7 +755,7 @@ int main() {
|
||||
int pop_max_price;
|
||||
int pop_daily_card_price;
|
||||
|
||||
int zone = 1;
|
||||
int zone = 3;
|
||||
|
||||
if (zone == 1) {
|
||||
input.open("/opt/ptu5/opt/customer_502/etc/psa_tariff/tariff01.json");
|
||||
@ -845,7 +844,7 @@ int main() {
|
||||
CalcState calcState;
|
||||
QDateTime s(QDateTime::currentDateTime());
|
||||
|
||||
// s.setTime(QTime(12, 0, 0));
|
||||
s.setTime(QTime(12, 0, 0));
|
||||
|
||||
//calcState = compute_duration_for_parking_ticket(&cfg, s,
|
||||
// (double)1200, end, PermitType(PERMIT_TYPE::SHORT_TERM_PARKING_PKW));
|
||||
@ -853,26 +852,9 @@ int main() {
|
||||
//qCritical() << calcState.toString();
|
||||
|
||||
calcState = compute_duration_for_parking_ticket(&cfg, s,
|
||||
(double)9000, end, PermitType(PERMIT_TYPE::SHORT_TERM_PARKING_BUS));
|
||||
(double)50, end, PermitType(PERMIT_TYPE::SHORT_TERM_PARKING_BUS));
|
||||
qCritical() << end.toString(Qt::ISODate);
|
||||
qCritical() << calcState.toString();
|
||||
|
||||
struct price_t costs;
|
||||
|
||||
CalcState cs;
|
||||
|
||||
for (int i = 0, j=timeSteps.size() ; i < timeSteps.size(); --j, ++i) {
|
||||
QDateTime end = start.addSecs(timeSteps.at(i)*60);
|
||||
|
||||
qCritical() << "XXXXX end" << end.toString(Qt::ISODate);
|
||||
|
||||
cs = compute_price_for_parking_ticket(&cfg, s, timeSteps.at(i), end, &costs,
|
||||
PermitType(PERMIT_TYPE::SHORT_TERM_PARKING));
|
||||
if (cs.getStatus() != CalcState::State::SUCCESS) {
|
||||
qCritical() << "ERROR STATUS" << costs.netto;
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (zone == 2) {
|
||||
@ -1387,29 +1369,6 @@ int main() {
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#if NEUHAUSER_FORCHACH==1
|
||||
std::ifstream input;
|
||||
input.open("/opt/ptu5/opt/customer_749/etc/psa_tariff/tariff01.json");
|
||||
|
||||
std::stringstream sstr;
|
||||
while(input >> sstr.rdbuf());
|
||||
std::string json(sstr.str());
|
||||
|
||||
Configuration cfg;
|
||||
|
||||
bool isParsed = cfg.ParseJson(&cfg, json.c_str());
|
||||
cout << endl;
|
||||
|
||||
if (isParsed) {
|
||||
compute_product_price(&cfg, PermitType(PERMIT_TYPE::DAY_TICKET_PKW));
|
||||
compute_product_price(&cfg, PermitType(PERMIT_TYPE::DAY_TICKET_CAMPER));
|
||||
|
||||
QDateTime start = QDateTime::currentDateTime();
|
||||
QDateTime ticketEndTime;
|
||||
compute_duration_for_daily_ticket(&cfg, start, ticketEndTime, PermitType(PERMIT_TYPE::DAY_TICKET));
|
||||
}
|
||||
|
||||
#endif
|
||||
#if BAD_NEUENAHR_AHRWEILER==1
|
||||
std::ifstream input;
|
||||
@ -1432,8 +1391,7 @@ int main() {
|
||||
case 2: {
|
||||
qCritical() << " ZONE 2: KURZZEIT 1";
|
||||
// kuzzeit-1-tarif
|
||||
//input.open("/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff02.json");
|
||||
input.open("/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff05.json");
|
||||
input.open("/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff02.json");
|
||||
//pop_max_time = 5*60;
|
||||
} break;
|
||||
case 3: {
|
||||
@ -1625,8 +1583,7 @@ int main() {
|
||||
break;
|
||||
case 1:
|
||||
//start = QDateTime(QDate(2024, 10, 3), QTime(17, 0, 0)); // sunday
|
||||
//start = QDateTime(QDate(2025, 4, 20), QTime(18, 0, 0)); // sunday
|
||||
start = QDateTime(QDate(2024, 9, 27), QTime(17, 0, 0)); // friday
|
||||
start = QDateTime(QDate(2024, 9, 8), QTime(16, 2, 0)); // sunday
|
||||
fail = false;
|
||||
break;
|
||||
case 2:
|
||||
@ -1658,8 +1615,8 @@ int main() {
|
||||
// << "START" << start.toString(Qt::ISODate)
|
||||
// << "<duration" << *step;
|
||||
|
||||
if (*step != 180)
|
||||
continue;
|
||||
// if (*step != 180)
|
||||
// continue;
|
||||
|
||||
|
||||
double cost = 0;
|
||||
@ -2804,62 +2761,24 @@ int main() {
|
||||
bool nextDay = false;
|
||||
bool prePaid = true;
|
||||
// zone 1 (lila)
|
||||
QDateTime s(QDate(2024, 10, 8), QTime());
|
||||
QDateTime s(QDate(2023, 11, 30), QTime());
|
||||
QDateTime end;
|
||||
|
||||
static QList<int> const timeSteps = Calculator::GetInstance().GetTimeSteps(&cfg);
|
||||
qCritical() << "TimeSteps" << timeSteps;
|
||||
|
||||
for (int duration = 30; duration <= pop_max_time; duration += 5) {
|
||||
int offset = 600;
|
||||
//for (int offset = 720; offset < 601; ++offset) {
|
||||
//if (offset > 720 && offset < 840) {
|
||||
// continue;
|
||||
//}
|
||||
for (int offset = 420; offset < 1140; ++offset) {
|
||||
if (offset > 720 && offset < 840) {
|
||||
continue;
|
||||
}
|
||||
QDateTime start = s.addSecs(offset * 60);
|
||||
//qCritical() << "start" << start.toString(Qt::ISODate);
|
||||
|
||||
CalcState cs;
|
||||
#if 1
|
||||
struct price_t costs;
|
||||
for (int i = 0, j=timeSteps.size() ; i < timeSteps.size(); --j, ++i) {
|
||||
QDateTime end = start.addSecs(timeSteps.at(i)*60);
|
||||
|
||||
// if (i != 2) continue;
|
||||
|
||||
cs = compute_price_for_parking_ticket(&cfg, start, timeSteps.at(i), end, &costs, PermitType(PERMIT_TYPE::SHORT_TERM_PARKING));
|
||||
int price1 = costs.netto;
|
||||
|
||||
qCritical() << "compute_price_for_parking_ticket()/GetCostFromDuration() TIME: "
|
||||
<< timeSteps.at(i) << "ZZZZZZZZZZZZZ PRICE=" << price1 << "end=" << end.toString(Qt::ISODate);
|
||||
}
|
||||
exit(0);
|
||||
#else
|
||||
|
||||
double cost = 360;
|
||||
qCritical() << "XXXXXXXX START" << start.toString(Qt::ISODate) << "cost" << cost;
|
||||
QDateTime end;
|
||||
|
||||
cs = compute_duration_for_parking_ticket(&cfg, start, cost, end,
|
||||
PermitType(PERMIT_TYPE::SHORT_TERM_PARKING));
|
||||
qCritical() << __LINE__ << cs.toString()
|
||||
<< "START" << start.toString(Qt::ISODate)
|
||||
<< "<duration" << start.secsTo(end) / 60
|
||||
<< "cost" << cost
|
||||
<< "> end" << end.toString(Qt::ISODate);
|
||||
//}
|
||||
|
||||
exit(0);
|
||||
#endif
|
||||
|
||||
//double cost = Calculator::GetInstance().GetCostFromDuration(&cfg, 3, start, end, duration, nextDay, prePaid);
|
||||
double cost = Calculator::GetInstance().GetCostFromDuration(&cfg, 3, start, end, duration, nextDay, prePaid);
|
||||
//Q_ASSERT(cost == duration*2.5);
|
||||
//qCritical() << "";
|
||||
//qCritical() << "start" << start.toString(Qt::ISODate)
|
||||
// << "end" << end.toString(Qt::ISODate)
|
||||
// << "duration" << duration
|
||||
// << "cost" << cost;
|
||||
#if 0
|
||||
qCritical() << "start" << start.toString(Qt::ISODate)
|
||||
<< "end" << end.toString(Qt::ISODate)
|
||||
<< "duration" << duration
|
||||
<< "cost" << cost;
|
||||
|
||||
switch(duration) {
|
||||
case 30:
|
||||
if (cost == 60.0) {
|
||||
@ -3023,17 +2942,15 @@ int main() {
|
||||
<< "cost" << cost;
|
||||
exit(-1);
|
||||
}
|
||||
#endif
|
||||
|
||||
//std::string duration = Calculator::GetInstance().GetDurationFromCost(&cfg, 3, start.toString(Qt::ISODate).toStdString().c_str(), cost);
|
||||
//Q_ASSERT(cost == duration*2.5);
|
||||
//qCritical() << "start" << start.toString(Qt::ISODate)
|
||||
// << "cost" << cost
|
||||
// << "until" << duration.c_str() << start.secsTo(QDateTime::fromString(duration.c_str(), Qt::ISODate)) / 60;
|
||||
//}
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
Configuration::SpecialDaysType specialDays = cfg.SpecialDays;
|
||||
for (Configuration::SpecialDaysType::const_iterator it = specialDays.cbegin();
|
||||
it != specialDays.cend(); ++it) {
|
||||
@ -3054,7 +2971,7 @@ int main() {
|
||||
<< "duration" << duration
|
||||
<< "cost" << cost;
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
@ -34,12 +34,7 @@ OTHER_FILES += \
|
||||
/opt/ptu5/opt/customer_335/etc/psa_tariff/tariff02.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff01.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff02.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff03.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff04.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff05.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff06.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff07.json \
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff08.json
|
||||
/opt/ptu5/opt/customer_249/etc/psa_tariff/tariff03.json
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user