Merge branch 'neuhauser-kirchdorf' of git.mimbach49.de:GerhardHoffmann/MOBILISIS-Calculator into neuhauser-kirchdorf

library/include/mobilisis/calculate_price.h

@@ -175,8 +175,6 @@ struct CALCULATE_LIBRARY_API CalcState {
     }
 
     CalcState &set(State s) { m_status = s; return *this; }
-    CalcState &setStatus(State s) { return set(s); }
-    State getStatus() const { return m_status; }
     CalcState &setDesc(QString s) { m_desc = s; return *this; }
 
     void setAllowedTimeRange(QTime const &from, QTime const &until) {
@@ -196,29 +194,11 @@ int CALCULATE_LIBRARY_API get_zone_nr(int zone = -1);
 int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int currentTimeMinutes, int UpDown);
 
 QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg);
-
+int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration *cfg, PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING);
-int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration const *cfg,
+int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration *cfg, PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING);
-                                                  PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING,
+int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg, PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING);
-                                                  int paymentOptionIndex=0);
+int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg, PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING);
-
+int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg, PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING);
-int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
-                                                  PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING,
-                                                  int paymentOptionIndex=0);
-
-int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
-                                                   PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING,
-                                                   int paymentOptionIndex = 0,
-                                                   QDateTime const &start = QDateTime::currentDateTime());
-
-int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg,
-                                                   PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING,
-                                                   int paymentOptionIndex=0);
-
-int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg,
-                                                PERMIT_TYPE permitType = PERMIT_TYPE::SHORT_TERM_PARKING,
-                                                QDateTime const &start = QDateTime::currentDateTime(),
-                                                QDateTime *productStart = nullptr,
-                                                QDateTime *productEnd = nullptr);
 
 CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(       // deprecated
                                             parking_tariff_t *tariff,

library/include/mobilisis/calculator_functions.h

@@ -14,19 +14,9 @@
 using namespace std;
 
 class Calculator {
-    mutable QVector<QList<int>> m_timeSteps;
+    mutable QList<int> m_timeSteps;
     mutable QList<int> m_priceSteps;
 
-    CalcState isParkingAllowedForWeekDay(Configuration const *cfg,
-                                         QDateTime const &start,
-                                         int netto_parking_time,
-                                         int paymentOptionIndex);
-
-    CalcState isParkingAllowedForSpecialDay(Configuration const *cfg,
-                                            QDateTime const &start,
-                                            int netto_parking_time,
-                                            int paymentOptionIndex);
-
 protected:
     explicit Calculator() = default;
 
@@ -39,28 +29,13 @@ public:
         return c;
     }
 
-    void ResetTimeSteps(int paymentOptionIndex) {
+    void ResetTimeSteps() { m_timeSteps.clear(); }
-        if (m_timeSteps.size() > 0) {
+    QList<int> timeSteps() const { return m_timeSteps; }
-            m_timeSteps[paymentOptionIndex].clear();
-        }
-    }
-    QList<int> timeSteps(int paymentOptionIndex=0) const {
-        if (m_timeSteps.size() > 0) {
-            return m_timeSteps[paymentOptionIndex];
-        }
-        return QList<int>();
-    }
 
     void ResetPriceSteps() { m_priceSteps.clear(); }
     QList<int> priceSteps() const { return m_priceSteps; }
 
-    CalcState isParkingAllowed(Configuration const *cfg,
+    CalcState isParkingAllowed(Configuration const *cfg, QDateTime const &start);
-                               QDateTime const &start);
-
-    CalcState isParkingAllowed(Configuration const *cfg,
-                               QDateTime const &start,
-                               int netto_parking_time,
-                               int paymentOptionIndex);
 
 	/// <summary>
 	/// Gets duration in seconds from cost
@@ -91,8 +66,8 @@ public:
     // helper function to find time steps for a tariff with PaymentMethod::Steps
     // (e.g. Schoenau/Koenigsee)
     //
-    QList<int> GetTimeSteps(Configuration *cfg, int paymentOptionIndex=0) const;
+    QList<int> GetTimeSteps(Configuration *cfg) const;
-    QList<int> GetSteps(Configuration *cfg, int paymentOptionIndex=0) const { return GetTimeSteps(cfg, paymentOptionIndex); }
+    QList<int> GetSteps(Configuration *cfg) const { return GetTimeSteps(cfg); }
 
     QList<int> GetPriceSteps(Configuration *cfg) const;
 
@@ -112,8 +87,8 @@ public:
 // testing public:
     // Introduced for PaymentMethod::Steps (e.g. Schoenau)
     // For tariff of following structure: only steps, no special days, nonstop.
-    uint32_t GetCostFromDuration(Configuration *cfg, QDateTime const &start, quint64 durationMinutes, int paymentOptionIndex=0) const;
+    uint32_t GetCostFromDuration(Configuration *cfg, QDateTime const &start, quint64 durationMinutes) const;
-    uint32_t GetCostFromDuration(Configuration *cfg, QDateTime const &start, QDateTime const &end, int paymentOptionIndex=0) const;
+    uint32_t GetCostFromDuration(Configuration *cfg, QDateTime const &start, QDateTime const &end) const;
 
 private:
     Ticket private_GetCostFromDuration(Configuration const* cfg,
@@ -129,7 +104,7 @@ private:
                               int durationMinutes);
 
     //
-    uint32_t GetPriceForTimeStep(Configuration *cfg, int timeStep, int paymentOptionIndex=0) const;
+    uint32_t GetPriceForTimeStep(Configuration *cfg, int timeStep) const;
     uint32_t GetPriceForStep(Configuration *cfg, int step) const {
         return GetPriceForTimeStep(cfg, step);
     }

library/include/mobilisis/configuration.h

@@ -36,12 +36,6 @@ class Calculator;
 class Configuration
 {
 public:
-    using SpecialDaysType = std::multimap<int, ATBSpecialDays>;
-    using SpecialDaysWorktimeType = std::multimap<int, ATBSpecialDaysWorktime>;
-    using TimeRangeType = std::multimap<int, ATBTimeRange>;
-    using TariffProductType = std::multimap<int, ATBTariffProduct>;
-    using ATBPaymentOptionType = std::multimap<int, ATBPaymentOption>;
-
     ATBProject project;
     ATBCurrency Currency;
 	ATBDuration duration;
@@ -49,18 +43,18 @@ public:
 	multimap<int, ATBDuration> Duration;
 	multimap<int, ATBPaymentMethod> PaymentMethod;
 	multimap<int, ATBPaymentRate> PaymentRate;
-    SpecialDaysWorktimeType SpecialDaysWorktime;
+	multimap<int, ATBSpecialDaysWorktime> SpecialDaysWorktime;
-    SpecialDaysType SpecialDays;
+	multimap<int, ATBSpecialDays> SpecialDays;
 	multimap<int, ATBWeekDays> WeekDays;
 	multimap<int, ATBPeriodYear> YearPeriod;
 	multimap<int, ATBWeekDaysWorktime> WeekDaysWorktime;
-    ATBPaymentOptionType PaymentOption;
+	multimap<int, ATBPaymentOption> PaymentOption;
     multimap<int, ATBDailyTicket> DailyTicket;
-    TimeRangeType TimeRange;
+    multimap<int, ATBTimeRange> TimeRange;
     multimap<int, ATBTimeStepConfig> TimeStepConfig;
     multimap<int, ATBTimeBase> TimeBase;
     multimap<int, ATBCustomer> Customer;
-    TariffProductType TariffProduct;
+    multimap<int, ATBTariffProduct> TariffProduct;
 
 	/// <summary>
 	/// Parse JSON string
@@ -69,18 +63,10 @@ public:
 	/// <returns>Returns operation status bool (OK | FAIL) </returns>
 	bool ParseJson(Configuration* cfg, const char* json);
 
-    ATBPaymentOption &getPaymentOptions(int paymentOptionsIndex=0);
+    ATBPaymentOption &getPaymentOptions();
-    ATBPaymentOption const &getPaymentOptions(int paymentOptionsIndex=0) const;
+    ATBPaymentOption const &getPaymentOptions() const;
     QVector<ATBPaymentOption> &getAllPaymentOptions();
     QVector<ATBPaymentOption> const &getAllPaymentOptions() const;
-    int getPaymentOptionIndex(QDateTime const &dt) const;
-    int getPaymentOptionIndexIfSpecialDay(QDateTime const &dt) const;
-    bool isSpecialDay(QDateTime const &dt) const;
-    int specialDayId(QDateTime const &dt) const;
-    ATBSpecialDays specialDay(QDateTime const &dt) const;
-    bool isDayIncluded(uint64_t businessHours, QDateTime const &dt) const;
-    bool isDayIncludedAsSpecialDay(uint64_t businessHours, QDateTime const &dt) const;
-    bool isDayIncludedAsSpecialDay(uint64_t businessHours, int specialDayId) const;
     std::optional<QVector<ATBPaymentRate>> getPaymentRateForAllKeys() const;
     std::optional<QVector<ATBPaymentRate>> getPaymentRateForKey(int key) const;
     std::optional<QVector<ATBDailyTicket>> getDailyTicketsForAllKeys() const;
@@ -88,7 +74,6 @@ public:
     std::optional<QVector<ATBTariffProduct>> getTariffProductForAllKeys() const;
     std::optional<QVector<ATBTariffProduct>> getTariffProductForProductId(int id) const;
     std::optional<QVector<ATBTariffProduct>> getTariffProductForProductId(PermitType permitType) const;
-    std::optional<QVector<ATBTariffProduct>> getTariffProductForProductTypeName(QString const &permitTypeName) const;
     std::optional<ATBCustomer> getCustomerForType(ATBCustomer::CustomerType customerType);
     std::optional<ATBWeekDaysWorktime> getWeekDayWorkTime(QTime const &time, Qt::DayOfWeek dayOfWeek);
 

library/include/mobilisis/payment_opt.h

@@ -1,11 +1,5 @@
-#ifndef PAYMENT_OPT_H_INCLUDED
+#pragma once
-#define PAYMENT_OPT_H_INCLUDED
-
-
 #include <string>
-#include <cinttypes>
-
-#include <QDateTime>
 
 class ATBPaymentOption
 {
@@ -24,10 +18,7 @@ public:
         pop_min_price = 0;
         pop_max_price = 0;
         pop_carry_over = -1;
-        pop_carry_over_target = false;
         pop_carry_over_time_range_id = -1;
-        pop_carry_over_start_time_range = -1;
-        pop_carry_over_end_time_range = -1;
         pop_daily_card_price = -1;
         pop_business_hours = -1;
         pop_time_step_config = -1;
@@ -44,21 +35,8 @@ public:
     double pop_min_price;
     double pop_max_price;
     int pop_carry_over;
-    bool pop_carry_over_target;
     int pop_carry_over_time_range_id;
-    int pop_carry_over_start_time_range;
-    int pop_carry_over_end_time_range;
     int pop_daily_card_price;
-    uint64_t pop_business_hours;
+    int pop_business_hours;
     int pop_time_step_config;
-
-    struct ATBMaxDateTime {
-        int direction;
-        uint8_t week;
-        uint8_t day;
-        QTime time;
-    } pop_min_date_time,
-      pop_max_date_time;
 };
-
-#endif // PAYMENT_OPT_H_INCLUDED

library/include/mobilisis/spec_days.h

@@ -4,12 +4,10 @@
 class ATBSpecialDays
 {
 public:
-    explicit ATBSpecialDays() = default;
 	int ped_id;
 	std::string ped_label;
 	std::string ped_date_start;
 	std::string ped_date_end;
-    int ped_period_special_day_id;
+	int ped_period_special_day_id;
-    int ped_payment_option_id;
 	int ped_year;
 };

library/include/mobilisis/tariff_business_hours.h

@@ -4,87 +4,19 @@
 /// <summary>
 /// Business hours (byte represents payment option id)
 /// </summary>
-///
+enum BusinessHours
-
-#include <Qt>
-
-#define _NO_RESTRICTION_24_7_               (uint64_t)(0ULL)
-#define _MON_                               (uint64_t)(1ULL << 8)
-#define _TUE_                               (uint64_t)(1ULL << 9)
-#define _WED_                               (uint64_t)(1ULL << 10)
-#define _THU_                               (uint64_t)(1ULL << 11)
-#define _FRI_                               (uint64_t)(1ULL << 12)
-#define _SAT_                               (uint64_t)(1ULL << 13)
-#define _SUN_                               (uint64_t)(1ULL << 14)
-#define _WEEK_DAYS_                         ((_MON_|_TUE_|_WED_|_THU_|_FRI_))
-#define _WORKING_DAYS_                      ((_MON_|_TUE_|_WED_|_THU_|_FRI_|_SAT_))
-#define _ALL_DAYS_                          ((_MON_|_TUE_|_WED_|_THU_|_FRI_|_SAT_|_SUN_))
-#define _OFFICIAL_HOLIDAY_                  (uint64_t)(1ULL << 15)
-#define _ONLY_WEEKEND_                      ((_SAT_|_SUN_))
-#define _ONLY_OPEN_FOR_BUSINESS_DAYS_       (uint64_t)(1ULL << 16)    /* verkaufsoffen */
-#define _WITH_RESTRICTED_HOURS_             (uint64_t)(1ULL << 17)
-#define _ALL_DAYS_WITH_RESTRICTED_HOURS_    ((_WITH_RESTRICTED_HOURS_|_ALL_DAYS_))
-#define _WEEKEND_WITH_RESTRICTED_HOURS_     ((_WITH_RESTRICTED_HOURS_|_FRI_|_SAT_|_SUN_))
-#define _FRI_WITH_RESTRICTED_HOURS_         ((_WITH_RESTRICTED_HOURS_|_FRI_))
-#define _SAT_WITH_RESTRICTED_HOURS_         ((_WITH_RESTRICTED_HOURS_|_SAT_))
-#define _SUN_WITH_RESTRICTED_HOURS_         ((_WITH_RESTRICTED_HOURS_|_SUN_))
-#define _NOT_DEFINED_                       (uint64_t)(~0ULL)
-
-enum BusinessHours : std::uint64_t
 {
     NoRestriction_24_7          = 0,
     OnlyWorkingDays             = 1,    // [Monday-Friday]
     OnlyWeekDays                = 2,    // [Monday-Saturday]
     OnlyWeekEnd                 = 4,    // [Saturday+Sunday]
     OnlyOfficialHolidays        = 8,
-    OnlySundaysAndHolidays      = 12,   // [Sun+Holiday]
     OnlySpecialDays             = 16,
     OnlySchoolHolidays          = 32,
     SpecialAndSchoolHolidays    = 48,
     OnlyOpenForBusinessDays     = 64,   // verkaufsoffen
     AllDaysWithRestrictedHours  = 128,  // every day, restricted to some time range
-    NoBusinessHoursDefined      = 255,
+    NoBusinessHoursDefined      = 255
-
-    // new 12.04.2024
-    NO_RESTRICTION_24_7 = _NO_RESTRICTION_24_7_,
-    MON = _MON_,
-    TUE = _TUE_,
-    WED = _WED_,
-    THU = _THU_,
-    FRI = _FRI_,
-    SAT = _SAT_,
-    SUN = _SUN_,
-    WEEK_DAYS = _WEEK_DAYS_,
-    WORKING_DAYS = _WORKING_DAYS_,
-    ALL_DAYS = _ALL_DAYS_,
-    OFFICIAL_HOLIDAY = _OFFICIAL_HOLIDAY_,
-    ONLY_WEEKEND = _ONLY_WEEKEND_,
-    ONLY_OPEN_FOR_BUSINESS_DAYS = _ONLY_OPEN_FOR_BUSINESS_DAYS_,
-    ALL_DAYS_WITH_RESTRICTED_HOURS = _ALL_DAYS_WITH_RESTRICTED_HOURS_,
-    WEEKEND_WITH_RESTRICTED_HOURS = _WEEKEND_WITH_RESTRICTED_HOURS_,
-    FRI_WITH_RESTRICTED_HOURS = _FRI_WITH_RESTRICTED_HOURS_,
-    SAT_WITH_RESTRICTED_HOURS = _SAT_WITH_RESTRICTED_HOURS_,
-    SUN_WITH_RESTRICTED_HOURS = _SUN_WITH_RESTRICTED_HOURS_,
-    NOT_DEFINED = _NOT_DEFINED_
-};
-
-#if 0
-static bool business(uint64_t businessHours, QDateTime &const dt) {
-    switch (dayOfWeek) {
-    case Qt::Monday:
-        (businessHours & _MON_) == _MON_;
-    case Qt::Tuesday:
-    case Qt::Wednesday:
-    case Qt::Thursday:
-    case Qt::Saturday:
-    case Qt::Sunday:
-    }
-
-}
-#endif
-
-struct BusinessHours_struct {
-    BusinessHours bh;
 };
 
 #endif // TARIFF_BUSINESS_HOURS_H_INCLUDED

library/include/mobilisis/tariff_global_defines.h

@@ -1,6 +0,0 @@
-#ifndef TARIFF_GLOBAL_DEFINES_H_INCLUDED
-#define TARIFF_GLOBAL_DEFINES_H_INCLUDED
-
-#define DBG_HEADER "(" << __func__ << ":" << __LINE__ << ")"
-
-#endif // TARIFF_GLOBAL_DEFINES_H_INCLUDED

library/include/mobilisis/tariff_permit_type.h

@@ -4,16 +4,15 @@
 #include <QString>
 
 enum class PERMIT_TYPE : quint8 {
-    SHORT_TERM_PARKING=0,
+    SHORT_TERM_PARKING,
-    DAY_TICKET=1,
+    DAY_TICKET,
-    SZEGED_START=2,
+    SZEGED_START,
-    SZEGED_STOP=3,
+    SZEGED_STOP,
-    DAY_TICKET_ADULT=4,
+    DAY_TICKET_ADULT,
-    DAY_TICKET_TEEN=5,
+    DAY_TICKET_TEEN,
-    DAY_TICKET_CHILD=6,
+    DAY_TICKET_CHILD,
-    INVALID=7,
+    FOOD_STAMP,
-    FOOD_STAMP=8,
+    INVALID
-    TWENTY_FOUR_HOURS_TICKET=9
 };
 
 struct PermitType {
@@ -46,9 +45,6 @@ struct PermitType {
         case 7:
             m_permitType = PERMIT_TYPE::FOOD_STAMP;
             break;
-        case 8:
-            m_permitType = PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET;
-            break;
         default:
             m_permitType = PERMIT_TYPE::INVALID;
         }
@@ -78,8 +74,6 @@ struct PermitType {
             return 6;
         case PERMIT_TYPE::FOOD_STAMP:
             return 7;
-        case PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET:
-            return 8;
         default:
             break;
         }
@@ -87,64 +81,52 @@ struct PermitType {
 
     }
 
-    QString toString() {
-        switch(m_permitType) {
-        case PERMIT_TYPE::DAY_TICKET:
-            return QString("DAY_TICKET");
-        case PERMIT_TYPE::DAY_TICKET_ADULT:
-            return QString("DAY_TICKET_ADULT");
-        case PERMIT_TYPE::DAY_TICKET_CHILD:
-            return QString("DAY_TICKET_CHILD");
-        case PERMIT_TYPE::DAY_TICKET_TEEN:
-            return QString("DAY_TICKET_TEEN");
-        case PERMIT_TYPE::SHORT_TERM_PARKING:
-            return QString("SHORT_TERM_PARKING");
-        case PERMIT_TYPE::SZEGED_START:
-            return QString("SZEGED_START");
-        case PERMIT_TYPE::SZEGED_STOP:
-            return QString("SZEGED_STOP");
-        case PERMIT_TYPE::FOOD_STAMP:
-            return QString("FOOD_STAMP");
-        case PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET:
-            return QString("TWENTY_FOUR_HOURS_TICKET");
-        default:
-            break;
-        }
-        return QString("INVALID");
-    }
-
-    QString toString() const {
-        switch(m_permitType) {
-        case PERMIT_TYPE::DAY_TICKET:
-            return QString("DAY_TICKET");
-        case PERMIT_TYPE::DAY_TICKET_ADULT:
-            return QString("DAY_TICKET_ADULT");
-        case PERMIT_TYPE::DAY_TICKET_CHILD:
-            return QString("DAY_TICKET_CHILD");
-        case PERMIT_TYPE::DAY_TICKET_TEEN:
-            return QString("DAY_TICKET_TEEN");
-        case PERMIT_TYPE::SHORT_TERM_PARKING:
-            return QString("SHORT_TERM_PARKING");
-        case PERMIT_TYPE::SZEGED_START:
-            return QString("SZEGED_START");
-        case PERMIT_TYPE::SZEGED_STOP:
-            return QString("SZEGED_STOP");
-        case PERMIT_TYPE::FOOD_STAMP:
-            return QString("FOOD_STAMP");
-        case PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET:
-            return QString("TWENTY_FOUR_HOURS_TICKET");
-        default:
-            break;
-        }
-        return QString("INVALID");
-    }
-
     operator QString () {
-        return toString();
+        switch(m_permitType) {
+        case PERMIT_TYPE::DAY_TICKET:
+            return QString("DAY_TICKET");
+        case PERMIT_TYPE::DAY_TICKET_ADULT:
+            return QString("DAY_TICKET_ADULT");
+        case PERMIT_TYPE::DAY_TICKET_CHILD:
+            return QString("DAY_TICKET_CHILD");
+        case PERMIT_TYPE::DAY_TICKET_TEEN:
+            return QString("DAY_TICKET_TEEN");
+        case PERMIT_TYPE::SHORT_TERM_PARKING:
+            return QString("SHORT_TERM_PARKING");
+        case PERMIT_TYPE::SZEGED_START:
+            return QString("SZEGED_START");
+        case PERMIT_TYPE::SZEGED_STOP:
+            return QString("SZEGED_STOP");
+        case PERMIT_TYPE::FOOD_STAMP:
+            return QString("FOOD_STAMP");
+        default:
+            break;
+        }
+        return QString("INVALID");
     }
 
     operator QString () const {
-        return toString();
+        switch(m_permitType) {
+        case PERMIT_TYPE::DAY_TICKET:
+            return QString("DAY_TICKET");
+        case PERMIT_TYPE::DAY_TICKET_ADULT:
+            return QString("DAY_TICKET_ADULT");
+        case PERMIT_TYPE::DAY_TICKET_CHILD:
+            return QString("DAY_TICKET_CHILD");
+        case PERMIT_TYPE::DAY_TICKET_TEEN:
+            return QString("DAY_TICKET_TEEN");
+        case PERMIT_TYPE::SHORT_TERM_PARKING:
+            return QString("SHORT_TERM_PARKING");
+        case PERMIT_TYPE::SZEGED_START:
+            return QString("SZEGED_START");
+        case PERMIT_TYPE::SZEGED_STOP:
+            return QString("SZEGED_STOP");
+        case PERMIT_TYPE::FOOD_STAMP:
+            return QString("FOOD_STAMP");
+        default:
+            break;
+        }
+        return QString("INVALID");
     }
 };
 

library/include/mobilisis/tariff_product.h

@@ -45,8 +45,6 @@ struct ATBTariffProduct {
         return false;
     }
 
-    uint32_t getProductPrice() const { return m_tariff_product_price; }
-
     friend QDebug operator<<(QDebug debug, ATBTariffProduct const &product) {
         QDebugStateSaver saver(debug);
 

library/include/mobilisis/utilities.h

@@ -15,9 +15,6 @@
 using namespace std;
 
 namespace Utilities {
-
-    bool isDayIncluded(uint64_t businessHours, QDateTime const &dt);
-
 	/// <summary>
 	/// Get day of week from current date (Zeller's Algorithm), starting day is Sunday
 	/// </summary>
@@ -79,9 +76,7 @@ namespace Utilities {
 	double CalculatePricePerUnit(double pra_price, double durationUnit = -1);
 
     QTime SpecialDaysWorkTimeFrom(Configuration const *cfg, int specialDayId);
-    QTime SpecialDaysWorkTimeFrom(Configuration::SpecialDaysWorktimeType::const_iterator it);
     QTime SpecialDaysWorkTimeUntil(Configuration const *cfg, int specialDayId);
-    QTime SpecialDaysWorkTimeUntil(Configuration::SpecialDaysWorktimeType::const_iterator it);
     QTime WeekDaysWorkTimeFrom(std::multimap<int, ATBWeekDaysWorktime>::const_iterator itr);
     QTime WeekDaysWorkTimeUntil(std::multimap<int, ATBWeekDaysWorktime>::const_iterator itr);
     int WeekDayId(std::multimap<int, ATBWeekDaysWorktime>::const_iterator itr);
@@ -99,5 +94,4 @@ namespace Utilities {
     BusinessHours getBusinessHours(Configuration const *cfg, PaymentMethod methodId);
     uint32_t computeWeekDaysPrice(Configuration const *cfg, PaymentMethod id);
     double computeWeekDaysDurationUnit(Configuration const *cfg, PaymentMethod id);
-    QStringList dumpBusinessHours(uint64_t businessHours);
 }

library/library.pro

@@ -79,8 +79,7 @@ HEADERS += \
     include/mobilisis/tariff_timebase.h \
     include/mobilisis/tariff_timestep_config.h \
     include/mobilisis/tariff_product.h \
-    include/mobilisis/tariff_permit_type.h \
+    include/mobilisis/tariff_permit_type.h
-    include/mobilisis/tariff_global_defines.h
 
 OTHER_FILES += src/main.cpp \
     ../tariffs/tariff_korneuburg.json \

library/src/calculate_price.cpp

@@ -14,14 +14,12 @@ 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,
+int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration *cfg, PERMIT_TYPE permitType) {
-                                                  PERMIT_TYPE permitType,
-                                                  int paymentOptionIndex) {
     int minTime = 0;
 
     switch(permitType) {
     case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
-        minTime = cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
+        minTime = cfg->getPaymentOptions().pop_min_time;
     } break;
     case PERMIT_TYPE::DAY_TICKET_ADULT: {
     } break;
@@ -32,22 +30,20 @@ int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration const *cfg,
     default:
         // for each new sell-procedure, recomute the timesteps. implicitly, set
         // the minimal parking time.
-        Calculator::GetInstance().ResetTimeSteps(paymentOptionIndex);
+        Calculator::GetInstance().ResetTimeSteps();
-        Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
+        Calculator::GetInstance().GetTimeSteps(cfg);
-        minTime = qRound(cfg->getPaymentOptions(paymentOptionIndex).pop_min_time);
+        minTime = qRound(cfg->getPaymentOptions().pop_min_time);
     }
 
     return minTime;
 }
 
-int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
+int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration *cfg, PERMIT_TYPE permitType) {
-                                                  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;
+        maxTime = cfg->getPaymentOptions().pop_max_time;
     } break;
     case PERMIT_TYPE::DAY_TICKET_ADULT: {
     } break;
@@ -59,18 +55,14 @@ int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
     }
 
     return maxTime;
-
 }
 
-int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
+int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg, PERMIT_TYPE permitType) {
-                                                   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;
+        minPrice = cfg->getPaymentOptions().pop_min_price;
     } break;
     case PERMIT_TYPE::DAY_TICKET_ADULT: {
     } break;
@@ -78,20 +70,13 @@ int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
     } 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,
+int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg, PERMIT_TYPE permitType) {
-                                                PERMIT_TYPE permitType,
-                                                QDateTime const &start,
-                                                QDateTime *productStart,
-                                                QDateTime *productEnd) {
 
     switch(permitType) {
     case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
@@ -127,66 +112,6 @@ int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg,
             }
         }
     } 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;
-        }
-    } 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;
     }
@@ -194,19 +119,17 @@ int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg,
     return 0;
 }
 
-int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg,
+int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg, PERMIT_TYPE permitType) {
-                                                   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) {
+        if (paymentMethodId == PaymentMethod::Progressive) {
             maxPrice = Utilities::getMaximalParkingPrice(cfg, paymentMethodId);
         } else { // PaymentMethod::Linear -> e.g. szeged
-            int const key = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
+            int const key = cfg->getPaymentOptions().pop_id;
-            int const maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time; // maxTime is given in minutes
+            int const maxTime = cfg->getPaymentOptions().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();
@@ -476,15 +399,11 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
         bool prepaid)
 {
     CalcState calcState;
-
+    double minMin = tariff->getPaymentOptions().pop_min_time;
-    int paymentOptionIndex = tariff->getPaymentOptionIndex(start_parking_time);
+    double maxMin = tariff->getPaymentOptions().pop_max_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
@@ -509,33 +428,15 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
         return calcState.set(CalcState::State::SUCCESS);
     }
 
-    double cost = -1;
     if (start_parking_time.isValid()) {
-        if (tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id == PaymentMethod::Steps) {
+        double cost = Calculator::GetInstance().GetCostFromDuration(
-            // 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().pop_min_price;
-        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);
@@ -544,10 +445,8 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
         // DEBUG
         qCritical() << "               -> calculated cost (price->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);
     }

library/src/calculator_functions.cpp

@@ -4,7 +4,6 @@
 #include "tariff_log.h"
 #include "tariff_time_range.h"
 #include "ticket.h"
-#include "tariff_global_defines.h"
 
 #include <sstream>
 #include <algorithm>
@@ -591,294 +590,35 @@ std::string Calculator::GetDurationFromCost(Configuration* cfg,
 
 uint32_t Calculator::GetCostFromDuration(Configuration *cfg,
                                          QDateTime const &start,
-                                         quint64 timeStepInMinutes,
+                                         quint64 timeStepInMinutes) const {
-                                         int paymentOptionIndex) const {
     // for instance, a tariff as used in Schoenau, Koenigssee: only steps, no
     // special days, nonstop.
     static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
     if (paymentMethodId == PaymentMethod::Steps) {
         QDateTime const end = start.addSecs(timeStepInMinutes*60);
-        return GetCostFromDuration(cfg, start, end, paymentOptionIndex);
+        return GetCostFromDuration(cfg, start, end);
     }
     return 0;
 }
 
 uint32_t Calculator::GetCostFromDuration(Configuration * cfg,
                                          QDateTime const &start,
-                                         QDateTime const &end,
+                                         QDateTime const &end) const {
-                                         int paymentOptionIndex) const {
     static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
     if (paymentMethodId == PaymentMethod::Steps) {
         int const timeStepInMinutes = start.secsTo(end) / 60;
-        return GetPriceForTimeStep(cfg, timeStepInMinutes, paymentOptionIndex);
+        return GetPriceForTimeStep(cfg, timeStepInMinutes);
     }
     return 0;
 }
 
-CalcState Calculator::isParkingAllowedForWeekDay(Configuration const *cfg,
-                                                 QDateTime const &start,
-                                                 int netto_parking_time,
-                                                 int paymentOptionIndex) {
 
-    qCritical() << DBG_HEADER << "start" << start.toString(Qt::ISODate)
+CalcState Calculator::isParkingAllowed(Configuration const *cfg, QDateTime const &start) {
-                << "paymentOptionIndex" << paymentOptionIndex;
-
-    QString errorStr = "UNKNOWN ERROR";
-
-    PaymentMethod const paymentMethodId = Utilities::getPaymentMethodId(cfg);
-    if (paymentMethodId == PaymentMethod::Steps) {
-        uint64_t const businessHours = cfg->getPaymentOptions(paymentOptionIndex).pop_business_hours;
-        if (cfg->isDayIncluded(businessHours, start)) {
-            if (businessHours == BusinessHours::NO_RESTRICTION_24_7) {
-                return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED",
-                         QTime(0, 0, 0), QTime(23, 59, 59));
-            }
-            int const weekdayId = start.date().dayOfWeek();
-            if (cfg->WeekDaysWorktime.count(weekdayId) > 0) {
-                using WTIterator = std::multimap<int, ATBWeekDaysWorktime>::const_iterator;
-                std::pair<WTIterator, WTIterator> p = cfg->WeekDaysWorktime.equal_range(weekdayId);
-
-                for (WTIterator itr = p.first; itr != p.second; ++itr) {
-                    QTime const &from = Utilities::WeekDaysWorkTimeFrom(itr);
-                    QTime const &until = Utilities::WeekDaysWorkTimeUntil(itr);
-
-                    qCritical() << DBG_HEADER
-                                << "CHECK IF PARKING IS ALLOWED IN TIME-RANGE ("
-                                << from.toString(Qt::ISODate) << "->" << until.toString(Qt::ISODate) << ") ...";
-
-                    QTime const &startTime = start.time();
-
-                    if (startTime >= from && startTime <= until) {
-                        QDateTime const end = start.addSecs(netto_parking_time*60);
-                        QTime const endTime = end.time();
-                        if (endTime <= until && start.date().dayOfWeek() == end.date().dayOfWeek()) {
-                            qCritical() << DBG_HEADER;
-                            return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED", from, until);
-                        } else {
-                            errorStr = QString("%1 startTime not in range (%2 not in [%3, %4))")
-                                                .arg(__LINE__)
-                                                .arg(startTime.toString(Qt::ISODate))
-                                                .arg(from.toString(Qt::ISODate))
-                                                .arg(endTime.toString(Qt::ISODate));
-                        }
-                    } else {
-                        errorStr = QString("%1 startTime not in range (%2 not in [%3, %4))")
-                                            .arg(__LINE__)
-                                            .arg(startTime.toString(Qt::ISODate))
-                                            .arg(from.toString(Qt::ISODate))
-                                            .arg(until.toString(Qt::ISODate));
-                    }
-
-                    int const pop_carry_over = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over;
-                    if (pop_carry_over == 1) {
-                        qCritical() << DBG_HEADER
-                                    << "NO. CHECK IF PARKING IS ALLOWED WITH CARRY-OVER ...";
-
-                        int const pop_carry_over_start_time_range = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_start_time_range;
-                        int const pop_carry_over_end_time_range = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_end_time_range;
-
-                        if (cfg->TimeRange.count(pop_carry_over_start_time_range) == 1 &&
-                            cfg->TimeRange.count(pop_carry_over_end_time_range) == 1) {
-
-                            ATBTimeRange s = cfg->TimeRange.find(pop_carry_over_start_time_range)->second;
-                            ATBTimeRange e = cfg->TimeRange.find(pop_carry_over_end_time_range)->second;
-
-                            if (startTime >= s.getTimeFrom() && startTime <= s.getTimeUntil()) {
-                                QDateTime sd = start;
-                                sd.setTime(s.getTimeUntil());
-
-                                QDateTime ed = start.addDays(1);
-                                ed.setTime(e.getTimeFrom());
-
-                                int const jumpSecs = sd.secsTo(ed);
-                                QDateTime const end = start.addSecs(netto_parking_time*60 + jumpSecs);
-                                if (end.time() <= e.getTimeUntil()) {
-
-                                    qCritical() << DBG_HEADER
-                                                << "PARKING IS ALLOWED WITH CARRY-OVER ("
-                                                << start.toString(Qt::ISODate) << "->" << ed.toString(Qt::ISODate) << ")";
-
-                                    return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED",
-                                                     startTime, end.time());
-                                } else {
-                                    errorStr = QString("endTime %1 exceeds [%2, %3))")
-                                                  .arg(end.toString(Qt::ISODate))
-                                                  .arg(sd.toString(Qt::ISODate))
-                                                  .arg(ed.toString(Qt::ISODate));
-                                }
-                            } else {
-                                errorStr = QString("startTime %1 exceeds [%2, %3))")
-                                              .arg(startTime.toString(Qt::ISODate))
-                                              .arg(s.getTimeFrom().toString(Qt::ISODate))
-                                              .arg(s.getTimeUntil().toString(Qt::ISODate));
-                            }
-                        } else {
-                           errorStr = "no carry-over limits configured";
-                        }
-                    } else {
-                        errorStr = "no carry-over configured";
-                    }
-                }
-            } else {
-                errorStr = QString("no weekday configured for day-id %1").arg(weekdayId);
-            }
-
-        } else {
-            errorStr = QString("start %1 not contained in business hours %2")
-                            .arg(start.toString(Qt::ISODate))
-                            .arg(businessHours);
-        }
-    }
-
-    return CalcState(CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME, errorStr,
-                     QTime(), QTime());
-}
-
-
-CalcState Calculator::isParkingAllowedForSpecialDay(Configuration const *cfg,
-                                                    QDateTime const &start,
-                                                    int netto_parking_time,
-                                                    int paymentOptionIndex) {
-    QString errorStr = "UNKNOWN ERROR";
-
-    qCritical() << DBG_HEADER << "start" << start.toString(Qt::ISODate)
-                << "paymentOptionIndex" << paymentOptionIndex;
-
-    PaymentMethod const paymentMethodId = Utilities::getPaymentMethodId(cfg);
-    if (paymentMethodId == PaymentMethod::Steps) {
-        //uint64_t const businessHours = cfg->getPaymentOptions(paymentOptionIndex).pop_business_hours;
-        int const specialDayId = cfg->specialDayId(start);
-        if ((specialDayId > 0) && (cfg->SpecialDaysWorktime.count(specialDayId) > 0)) {
-            using SDIterator = Configuration::SpecialDaysWorktimeType::const_iterator;
-            std::pair<SDIterator, SDIterator> p = cfg->SpecialDaysWorktime.equal_range(specialDayId);
-
-            for (SDIterator it = p.first; it != p.second; ++it) {
-                QTime const &from = Utilities::SpecialDaysWorkTimeFrom(it);
-                QTime const &until = Utilities::SpecialDaysWorkTimeUntil(it);
-
-                qCritical() << DBG_HEADER
-                            << "CHECK IF PARKING IS ALLOWED IN TIME-RANGE ("
-                            << from.toString(Qt::ISODate) << "->" << until.toString(Qt::ISODate) << ") ...";
-
-                QTime const &startTime = start.time();
-
-                if (startTime >= from && startTime <= until) {
-                    QTime const endTime = start.addSecs(netto_parking_time*60).time();
-                    if (endTime <= until) {
-                        return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED", from, until);
-                    } else {
-                        errorStr = QString("%1 startTime not in range (%2 not in [%3, %4))")
-                                            .arg(__LINE__)
-                                            .arg(startTime.toString(Qt::ISODate))
-                                            .arg(from.toString(Qt::ISODate))
-                                            .arg(endTime.toString(Qt::ISODate));
-                    }
-                } else {
-                    errorStr = QString("%1 startTime not in range (%2 not in [%3, %4))")
-                                        .arg(__LINE__)
-                                        .arg(startTime.toString(Qt::ISODate))
-                                        .arg(from.toString(Qt::ISODate))
-                                        .arg(until.toString(Qt::ISODate));
-                }
-
-                int const pop_carry_over = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over;
-                if (pop_carry_over == 1) {
-                    qCritical() << DBG_HEADER << "NO. CHECK IF PARKING IS ALLOWED WITH CARRY-OVER ...";
-
-                    int const pop_carry_over_start_time_range = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_start_time_range;
-                    int const pop_carry_over_end_time_range = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_end_time_range;
-
-                    if (cfg->TimeRange.count(pop_carry_over_start_time_range) == 1 &&
-                        cfg->TimeRange.count(pop_carry_over_end_time_range) == 1) {
-
-                        ATBTimeRange s = cfg->TimeRange.find(pop_carry_over_start_time_range)->second;
-                        ATBTimeRange e = cfg->TimeRange.find(pop_carry_over_end_time_range)->second;
-
-                        if (startTime >= s.getTimeFrom() && startTime <= s.getTimeUntil()) {
-                            QDateTime sd = start;
-                            sd.setTime(s.getTimeUntil());
-
-                            QDateTime ed = start.addDays(1);
-                            ed.setTime(e.getTimeFrom());
-
-                            int const jumpSecs = sd.secsTo(ed);
-                            QDateTime const end = start.addSecs(netto_parking_time*60 + jumpSecs);
-                            if (end.time() <= e.getTimeUntil()) {
-
-                                ed.setTime(e.getTimeUntil()); // for printing
-
-                                qCritical() << DBG_HEADER
-                                            << "PARKING IS ALLOWED WITH CARRY-OVER ("
-                                            << start.toString(Qt::ISODate) << "->" << ed.toString(Qt::ISODate) << ")";
-
-                                return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED",
-                                                 startTime, end.time());
-                            } else {
-                                ed.setTime(e.getTimeUntil()); // for printing
-
-                                errorStr = QString("endTime %1 exceeds [%2, %3))")
-                                              .arg(end.toString(Qt::ISODate))
-                                              .arg(sd.toString(Qt::ISODate))
-                                              .arg(ed.toString(Qt::ISODate));
-                            }
-                        } else {
-                            errorStr = QString("startTime %1 exceeds [%2, %3))")
-                                          .arg(startTime.toString(Qt::ISODate))
-                                          .arg(s.getTimeFrom().toString(Qt::ISODate))
-                                          .arg(s.getTimeUntil().toString(Qt::ISODate));
-                        }
-                    } else {
-                       errorStr = "no carry-over limits configured";
-                    }
-                } else {
-                    errorStr = "no carry-over configured";
-                }
-            }
-        }
-    }
-
-    return CalcState(CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME, errorStr,
-                     QTime(), QTime());
-}
-
-
-CalcState Calculator::isParkingAllowed(Configuration const *cfg,
-                                       QDateTime const &start,
-                                       int netto_parking_time,
-                                       int paymentOptionIndex) {
-
-    qCritical() << DBG_HEADER << "CHECK IF PARKING IS ALLOWED AT"
-                << start.toString(Qt::ISODate) << "...";
-
-    CalcState cs;
-
-    if ((cs = isParkingAllowedForWeekDay(cfg, start, netto_parking_time, paymentOptionIndex))) {
-        return cs;
-    }
-
-    qCritical() << DBG_HEADER << QString(cs);
-
-    if ((cs = isParkingAllowedForSpecialDay(cfg, start, netto_parking_time, paymentOptionIndex))) {
-        return cs;
-    }
-
-    qCritical() << DBG_HEADER << QString(cs);
-
-    return CalcState(CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME, "UNKNOWN ERROR",
-                     QTime(), QTime());
-}
-
-CalcState Calculator::isParkingAllowed(Configuration const *cfg,
-                                       QDateTime const &start) {
     static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
 
     if (paymentMethodId == PaymentMethod::Steps) {
         int const weekdayId = start.date().dayOfWeek();
         BusinessHours businessHours = Utilities::getBusinessHours(cfg, paymentMethodId);
-        if (businessHours == BusinessHours::NoRestriction_24_7) {
-            return CalcState(CalcState::State::SUCCESS, "PARKING_ALLOWED",
-                             QTime(0, 0, 0), QTime(23, 59, 59));
-        } else
         if (businessHours == BusinessHours::OnlyWeekDays) {
             if (weekdayId != (int)Qt::Saturday && weekdayId != (int)Qt::Sunday) { // e.g. Neuhauser, Linsinger Maschinenbau (741)
                 if (cfg->WeekDaysWorktime.count(weekdayId) > 0) {
@@ -1829,28 +1569,24 @@ QList<int> Calculator::GetPriceSteps(Configuration * /*cfg*/) const {
     return QList<int>();
 }
 
-QList<int> Calculator::GetTimeSteps(Configuration *cfg, int paymentOptionIndex) const {
+QList<int> Calculator::GetTimeSteps(Configuration *cfg) const {
-    qCritical() << "(" << __func__ << ":" << __LINE__ << ")" << "paymentOptionIndex:" << paymentOptionIndex;
+    if (m_timeSteps.size() > 0) {
-
-    if (m_timeSteps.size() > paymentOptionIndex) {
         //qCritical() << __PRETTY_FUNCTION__ << "timeSteps:" << m_timeSteps;
-        return m_timeSteps[paymentOptionIndex];
+        return m_timeSteps;
-    } else {
-        m_timeSteps.push_back(QList<int>());
     }
 
     QDateTime start = QDateTime::currentDateTime();
     start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
 
-    int const pop_id = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
+    int const pop_id = cfg->getPaymentOptions().pop_id;
-    int const pop_carry_over = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over;
+    int const pop_carry_over = cfg->getPaymentOptions().pop_carry_over;
-    int const pop_time_step_config = cfg->getPaymentOptions(paymentOptionIndex).pop_time_step_config;
+    int const pop_time_step_config = cfg->getPaymentOptions().pop_time_step_config;
 
     static PaymentMethod const paymentMethodId = Utilities::getPaymentMethodId(cfg);
 
-    qCritical() << "(" << __func__ << ":" << __LINE__ << ")        start parking time:" << start.toString(Qt::ISODate);
+    qCritical() << __func__ << ":" << __LINE__ << "       start parking time:" << start.toString(Qt::ISODate);
-    qCritical() << "(" << __func__ << ":" << __LINE__ << ")         payment option id:" << pop_id;
+    qCritical() << __func__ << ":" << __LINE__ << "        payment option id:" << pop_id;
-    qCritical() << "(" << __func__ << ":" << __LINE__ << ") payment option carry over:" << pop_carry_over;
+    qCritical() << __func__ << ":" << __LINE__ << "payment option carry over:" << pop_carry_over;
 
     if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::DYNAMIC) {
         //qCritical() << __PRETTY_FUNCTION__ << "payment option time step config:" << "TimeStepConfig::DYNAMIC";
@@ -1859,13 +1595,13 @@ QList<int> Calculator::GetTimeSteps(Configuration *cfg, int paymentOptionIndex)
             std::size_t const s = cfg->TimeRange.size();
             for (std::size_t id = 1; id <= s; ++id) {
                 int const step = Utilities::getTimeRangeStep(cfg, id, paymentMethodId);
-                m_timeSteps[paymentOptionIndex].append(step);
+                m_timeSteps.append(step);
             }
         } else {
             uint16_t timeStepCompensation = 0;
 
             if (pop_carry_over) {
-                int const pop_carry_over_time_range_id = cfg->getPaymentOptions(paymentOptionIndex).pop_carry_over_time_range_id;
+                int const pop_carry_over_time_range_id = cfg->getPaymentOptions().pop_carry_over_time_range_id;
                 QTime const carryOverTimeRangeFrom = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_from;
                 QTime const carryOverTimeRangeTo = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_to;
 
@@ -1889,19 +1625,19 @@ QList<int> Calculator::GetTimeSteps(Configuration *cfg, int paymentOptionIndex)
                                                 .arg(timeStep).arg(duration.pun_duration_max);
                                         break;
                                     }
-                                    qCritical() << "(" << __func__ << ":" << __LINE__ << ") configured minimal parking time:" << cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
+                                    qCritical() << __PRETTY_FUNCTION__ << "configured minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
 
                                     // set dynamic minimal parking time
-                                    cfg->getPaymentOptions(paymentOptionIndex).pop_min_time = timeStep;
+                                    cfg->getPaymentOptions().pop_min_time = timeStep;
 
-                                    qCritical() << "(" << __func__ << ":" << __LINE__ << ") computed minimal parking time:" << cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
+                                    qCritical() << __PRETTY_FUNCTION__ << "  computed minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
 
                                     duration.pun_duration = timeStep;
                                     timeStepCompensation = duration.pun_duration_max - duration.pun_duration;
-                                    m_timeSteps[paymentOptionIndex] << duration.pun_duration;
+                                    m_timeSteps << duration.pun_duration;
                                 } else {
                                     duration.pun_duration = duration.pun_duration_max - timeStepCompensation;
-                                    m_timeSteps[paymentOptionIndex] << duration.pun_duration;;
+                                    m_timeSteps << duration.pun_duration;;
                                 }
 
                                 cfg->Duration.erase(search);
@@ -1922,31 +1658,24 @@ QList<int> Calculator::GetTimeSteps(Configuration *cfg, int paymentOptionIndex)
             }
         }
     } else {
-        qCritical() << "(" << __func__ << ":" << __LINE__ << ") payment option time step config:" << "TimeStepConfig::STATIC";
+        qCritical() << __PRETTY_FUNCTION__ << "payment option time step config:" << "TimeStepConfig::STATIC";
 
         for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr)
         {
             int const durationId = itr->second.pra_payment_unit_id;
             int const durationUnit = cfg->Duration.find(durationId)->second.pun_duration;
-            int size = m_timeSteps.size();
+            m_timeSteps << durationUnit;
-
-            while (size <= paymentOptionIndex) {
-                m_timeSteps.push_back(QList<int>());
-                size = m_timeSteps.size();
-            }
-
-            m_timeSteps[paymentOptionIndex] << durationUnit;
         }
     }
 
-    qCritical() << "(" << __func__ << ":" << __LINE__ << ")" << "NEW timeSteps:" << m_timeSteps;
+    qCritical() << __PRETTY_FUNCTION__ << "NEW timeSteps:" << m_timeSteps;
 
-    return m_timeSteps[paymentOptionIndex];
+    return m_timeSteps;
 }
 
-uint32_t Calculator::GetPriceForTimeStep(Configuration *cfg, int timeStep, int paymentOptionIndex) const {
+uint32_t Calculator::GetPriceForTimeStep(Configuration *cfg, int timeStep) const {
 
-    int const pop_id = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
+    int const pop_id = cfg->getPaymentOptions().pop_id;
 
     for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr)
     {

library/src/configuration.cpp

@@ -1,15 +1,11 @@
 #include "configuration.h"
-#include "utilities.h"
 #include "tariff_timebase.h"
 #include "time_range_header.h"
 #include "tariff_timestep_config.h"
 #include "tariff_permit_type.h"
-#include "tariff_business_hours.h"
-#include "tariff_global_defines.h"
 
 #include <QString>
 #include <QDebug>
-#include <QRegularExpression>
 
 /// <inheritdoc/>
 MemberType Configuration::IdentifyJsonMember(const char* member_name)
@@ -417,80 +413,12 @@ bool Configuration::ParseJson(Configuration* cfg, const char* json)
                             this->currentPaymentOptions.last().pop_carry_over = k->value.GetInt();
                         } else if (strcmp(inner_obj_name, "pop_carry_over_time_range_id") == 0) {
                             this->currentPaymentOptions.last().pop_carry_over_time_range_id = k->value.GetInt();
-                        } else if (strcmp(inner_obj_name, "pop_carry_over_start_time_range") == 0) {
-                            this->currentPaymentOptions.last().pop_carry_over_start_time_range = k->value.GetInt();
-                        } else if (strcmp(inner_obj_name, "pop_carry_over_end_time_range") == 0) {
-                            this->currentPaymentOptions.last().pop_carry_over_end_time_range = k->value.GetInt();
                         } else if (strcmp(inner_obj_name, "pop_daily_card_price") == 0) {
                             this->currentPaymentOptions.last().pop_daily_card_price = k->value.GetInt();
                         } else if (strcmp(inner_obj_name, "pop_business_hours") == 0) {
-                            if (k->value.IsInt()) {
+                            this->currentPaymentOptions.last().pop_business_hours = k->value.GetInt();
-                                int const v = k->value.GetInt();
-                                this->currentPaymentOptions.last().pop_business_hours = v;
-                            } else
-                            if (k->value.IsString()) {
-                                bool ok;
-                                uint64_t const v = QString::fromStdString(k->value.GetString()).toLongLong(&ok);
-                                if (ok) {
-                                    this->currentPaymentOptions.last().pop_business_hours = v;
-                                }
-                            }
                         } else if (strcmp(inner_obj_name, "pop_time_step_config") == 0) {
                             this->currentPaymentOptions.last().pop_time_step_config = k->value.GetInt();
-                        } else if ((strcmp(inner_obj_name, "pop_min_date_time") == 0)
-                                || (strcmp(inner_obj_name, "pop_max_date_time") == 0)) {
-                            if (k->value.IsString()) { // -w0dFriT16:20:00 or +w0dMonT00:00:00
-                                static const QRegularExpression re(R"(([+-])w([0-9]+)d([A-Za-z]{3})T([0-9]{2}:[0-9]{2}:[0-9]{2}))");
-                                QString const &s = QString::fromStdString(k->value.GetString());
-                                QRegularExpressionMatch match = re.match(s);
-                                if (match.hasMatch()) {
-                                    ATBPaymentOption::ATBMaxDateTime dt;
-                                    int lastCaptured = match.lastCapturedIndex();
-                                    if (lastCaptured == 4) {
-                                        dt.direction = (match.captured(1) == "-") ? -1 : +1;
-
-                                        bool ok;
-                                        uint8_t week = match.captured(2).toUInt(&ok);
-                                        if (ok) {
-                                            dt.week = week;
-                                        }
-
-                                        QString const &day = match.captured(3);
-                                        if (day.compare("Mon", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Monday;
-                                        } else if (day.compare("Tue", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Tuesday;
-                                        } else if (day.compare("Wed", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Wednesday;
-                                        } else if (day.compare("Thu", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Thursday;
-                                        } else if (day.compare("Fri", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Friday;
-                                        } else if (day.compare("Sat", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Saturday;
-                                        } else if (day.compare("Sun", Qt::CaseInsensitive) == 0) {
-                                            dt.day = (int)Qt::Sunday;
-                                        }
-
-                                        QTime t = QTime::fromString(match.captured(4), Qt::ISODate);
-                                        if (t.isValid()) {
-                                            dt.time = t;
-                                        }
-                                    }
-
-                                    if (strcmp(inner_obj_name, "pop_min_date_time") == 0) {
-                                        this->currentPaymentOptions.last().pop_min_date_time = dt;
-                                    } else
-                                    if (strcmp(inner_obj_name, "pop_max_date_time") == 0) {
-                                        this->currentPaymentOptions.last().pop_max_date_time = dt;
-                                    }
-                                }
-                            }
-                        } else if (strcmp(inner_obj_name, "pop_carry_over_target") == 0) {
-                            if (k->value.IsBool()) {
-                                bool const v = k->value.GetBool();
-                                this->currentPaymentOptions.last().pop_carry_over_target = v;
-                            }
                         }
                         break;
 					case MemberType::DurationType:
@@ -525,8 +453,7 @@ bool Configuration::ParseJson(Configuration* cfg, const char* json)
 						else if (strcmp(inner_obj_name, "ped_date_start") == 0) SpecialDays.ped_date_start = k->value.GetString();
 						else if (strcmp(inner_obj_name, "ped_date_end") == 0) SpecialDays.ped_date_end = k->value.GetString();
 						else if (strcmp(inner_obj_name, "ped_period_special_day_id") == 0) SpecialDays.ped_period_special_day_id = k->value.GetInt();
-                        else if (strcmp(inner_obj_name, "ped_payment_option_id") == 0) SpecialDays.ped_payment_option_id = k->value.GetInt();
+						else if (strcmp(inner_obj_name, "ped_year") == 0) SpecialDays.ped_year = k->value.GetInt();
-                        else if (strcmp(inner_obj_name, "ped_year") == 0) SpecialDays.ped_year = k->value.GetInt();
 						break;
 					case MemberType::PeriodYearType:
 						if (strcmp(inner_obj_name, "pye_id") == 0) YearPeriod.pye_id = k->value.GetInt();
@@ -615,135 +542,15 @@ bool Configuration::ParseJson(Configuration* cfg, const char* json)
 	}
 }
 
-int Configuration::getPaymentOptionIndexIfSpecialDay(QDateTime const &dt) const {
-    if (isSpecialDay(dt)) {
-        int const numOptions = getAllPaymentOptions().size();
-        for (int opt=0; opt < numOptions; ++opt) {
-            uint64_t const pop_business_hours = getPaymentOptions(opt).pop_business_hours;
-            if ((pop_business_hours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-                return opt;
-            }
-        }
-    }
-    return -1;
-}
 
-int Configuration::getPaymentOptionIndex(QDateTime const &dt) const {
+ATBPaymentOption const &Configuration::getPaymentOptions() const {
-    int const numOptions = getAllPaymentOptions().size();
-
-    // special days are handled before usual week days
-    int const sid = specialDayId(dt);
-    if (sid > 0) {
-        ATBSpecialDays const sd = specialDay(dt);
-        if (sd.ped_id != 0) {
-            for (int opt=0; opt < numOptions; ++opt) {
-                uint64_t const pop_id = getPaymentOptions(opt).pop_id;
-                if (pop_id == (uint64_t)sd.ped_payment_option_id) {
-                    return opt;
-                }
-            }
-        }
-    }
-
-    for (int opt=0; opt < numOptions; ++opt) {
-        uint64_t const pop_business_hours = getPaymentOptions(opt).pop_business_hours;
-
-
-        uint64_t p = 0;
-        int const dayOfWeek = dt.date().dayOfWeek();
-
-        switch (dayOfWeek) {
-        case (int)Qt::Monday: {
-            p = BusinessHours::MON;
-        } break;
-        case (int)Qt::Tuesday: {
-            p = BusinessHours::TUE;
-        } break;
-        case (int)Qt::Wednesday: {
-            p = BusinessHours::WED;
-        } break;
-        case (int)Qt::Thursday: {
-            p = BusinessHours::THU;
-        } break;
-        case (int)Qt::Friday: {
-            p = BusinessHours::FRI;
-        } break;
-        case (int)Qt::Saturday: {
-            p = BusinessHours::SAT;
-        } break;
-        case (int)Qt::Sunday: {
-            p = BusinessHours::SUN;
-            qCritical() << DBG_HEADER << Utilities::dumpBusinessHours(pop_business_hours) << pop_business_hours << p;
-        } break;
-        }
-
-        if ((pop_business_hours & p) == p) {
-            return opt;
-        }
-    }
-
-    qCritical() << DBG_HEADER << "ERROR: DEFAULT VALUE OF '0' RETURNED AS STATIC VALUE";
-    return 0;
-}
-
-ATBSpecialDays Configuration::specialDay(QDateTime const &dt) const {
-    SpecialDaysType::const_iterator it;
-    for (it = SpecialDays.cbegin(); it != SpecialDays.cend(); ++it) {
-        if (dt.date().toString(Qt::ISODate) == QString::fromStdString(it->second.ped_date_start)) {
-            return it->second;
-        }
-    }
-
-    return ATBSpecialDays();
-}
-
-int Configuration::specialDayId(QDateTime const &dt) const {
-    SpecialDaysType::const_iterator it;
-    for (it = SpecialDays.cbegin(); it != SpecialDays.cend(); ++it) {
-        if (dt.date().toString(Qt::ISODate) == QString::fromStdString(it->second.ped_date_start)) {
-            int const specialDayId = it->second.ped_id;
-            return specialDayId; // must be > 0
-        }
-    }
-    return 0;
-}
-
-bool Configuration::isSpecialDay(QDateTime const &dt) const {
-    return (specialDayId(dt) > 0);
-}
-
-bool Configuration::isDayIncludedAsSpecialDay(uint64_t businessHours, int specialDayId) const {
-    if (specialDayId > 0) {
-        bool const &r = ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY);
-        return r;
-    }
-    return false;
-}
-
-bool Configuration::isDayIncludedAsSpecialDay(uint64_t businessHours, QDateTime const &dt) const {
-    // included in 'businessHours'
-
-    if (isSpecialDay(dt)) {
-        bool const &r = ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY);
-        qCritical() << "XXXXXXXXXXXXXXXXXX r" << r << businessHours;
-        return r;
-    }
-
-    return false;
-}
-
-bool Configuration::isDayIncluded(uint64_t businessHours, QDateTime const &dt) const {
-    return Utilities::isDayIncluded(businessHours, dt);
-}
-
-ATBPaymentOption const &Configuration::getPaymentOptions(int paymentOptionsIndex) const {
     Q_ASSERT(!this->currentPaymentOptions.isEmpty());
-    return this->currentPaymentOptions.at(paymentOptionsIndex);
+    return this->currentPaymentOptions.at(0);
 }
 
-ATBPaymentOption &Configuration::getPaymentOptions(int paymentOptionsIndex) {
+ATBPaymentOption &Configuration::getPaymentOptions() {
     Q_ASSERT(!this->currentPaymentOptions.isEmpty());
-    return this->currentPaymentOptions[paymentOptionsIndex];
+    return this->currentPaymentOptions[0];
 }
 
 QVector<ATBPaymentOption> const &Configuration::getAllPaymentOptions() const {
@@ -773,39 +580,13 @@ Configuration::getTariffProductForAllKeys() const {
     return value;
 }
 
-std::optional<QVector<ATBTariffProduct>>
-Configuration::getTariffProductForProductTypeName(QString const &permitTypeName) const {
-    QVector<ATBTariffProduct> products;
-    std::optional<QVector<ATBTariffProduct>> value;
-
-    products.clear();
-
-    for(const auto &product: this->TariffProduct) {
-        ATBTariffProduct const &v = product.second;
-        if (v.m_tariff_product_name == permitTypeName) {
-            products.append(v);
-        }
-    }
-
-    if (products.size() > 0) {
-        value = value.value_or(products);
-    }
-
-    return value;
-}
-
 std::optional<QVector<ATBTariffProduct>>
 Configuration::getTariffProductForProductId(PermitType permitType) const {
-    QString permitTypeName(permitType);
-    return getTariffProductForProductTypeName(permitTypeName);
-
-    /*
     QVector<ATBTariffProduct> products;
     std::optional<QVector<ATBTariffProduct>> value;
 
     products.clear();
 
-
     for (auto[it, rangeEnd] = this->TariffProduct.equal_range(permitType); it != rangeEnd; ++it) {
         products.append(it->second);
     }
@@ -815,7 +596,6 @@ Configuration::getTariffProductForProductId(PermitType permitType) const {
     }
 
     return value;
-    */
 }
 
 std::optional<QVector<ATBTariffProduct>>

library/src/utilities.cpp

@@ -1,6 +1,5 @@
 #include "utilities.h"
 #include "tariff_log.h"
-#include "tariff_business_hours.h"
 
 #include <QDebug>
 #include <algorithm>
@@ -261,7 +260,7 @@ bool Utilities::CheckSpecialDay(Configuration* cfg, const char* currentDateTimeS
 						//cout << "CheckSpecialDay() => Month is in range between start and end" << endl;
 						if ((current_tm.tm_mday >= start_tm.tm_mday) && (current_tm.tm_mday <= end_tm.tm_mday))
 						{
-                            //LOG_DEBUG("CheckSpecialDay() => SPECIAL DAY");
+							LOG_DEBUG("CheckSpecialDay() => SPECIAL DAY");
 							*specialDayId = spec_days_itr->second.ped_id;
 							*specialDayPrice = cfg->SpecialDaysWorktime.find(*specialDayId)->second.pedwt_price;
 							return true;
@@ -276,7 +275,7 @@ bool Utilities::CheckSpecialDay(Configuration* cfg, const char* currentDateTimeS
 					//cout << "CheckSpecialDay() => Month is in range between start and end" << endl;
 					if ((current_tm.tm_mday >= start_tm.tm_mday) && (current_tm.tm_mday <= end_tm.tm_mday))
 					{
-                        //LOG_DEBUG("CheckSpecialDay() => SPECIAL DAY");
+						LOG_DEBUG("CheckSpecialDay() => SPECIAL DAY");
 						*specialDayId = spec_days_itr->second.ped_id;
 						*specialDayPrice = cfg->SpecialDaysWorktime.find(*specialDayId)->second.pedwt_price;
 						return true;
@@ -318,7 +317,7 @@ bool Utilities::CheckSpecialDay(Configuration const *cfg,
                             continue;
                         }
                     }
-                    //qDebug() << "CheckSpecialDay() => SPECIAL DAY";
+                    qDebug() << "CheckSpecialDay() => SPECIAL DAY";
                     *specialDayId = spec_days_itr->second.ped_id;
                     *specialDayPrice = cfg->SpecialDaysWorktime.find(*specialDayId)->second.pedwt_price;
                     return true;
@@ -334,14 +333,6 @@ QTime Utilities::SpecialDaysWorkTimeFrom(Configuration const *cfg, int specialDa
     return QTime::fromString(cfg->SpecialDaysWorktime.find(specialDayId)->second.pedwt_time_from.c_str(), Qt::ISODate);
 }
 
-QTime Utilities::SpecialDaysWorkTimeFrom(Configuration::SpecialDaysWorktimeType::const_iterator it) {
-    return QTime::fromString(it->second.pedwt_time_from.c_str(), Qt::ISODate);
-}
-
-QTime Utilities::SpecialDaysWorkTimeUntil(Configuration::SpecialDaysWorktimeType::const_iterator it) {
-    return QTime::fromString(it->second.pedwt_time_to.c_str(), Qt::ISODate);
-}
-
 QTime Utilities::SpecialDaysWorkTimeUntil(Configuration const *cfg, int specialDayId) {
     return QTime::fromString(cfg->SpecialDaysWorktime.find(specialDayId)->second.pedwt_time_to.c_str(), Qt::ISODate);
 }
@@ -408,10 +399,7 @@ uint32_t Utilities::getMaximalParkingPrice(Configuration const *cfg, PaymentMeth
 
 uint32_t Utilities::getTimeRangeStep(Configuration const *cfg, int step, PaymentMethod methodId) {
     if (methodId == PaymentMethod::Progressive) {
-        Configuration::TimeRangeType::const_iterator it = cfg->TimeRange.find(step);
+        return std::max((int)cfg->TimeRange.find(step)->second.time_range_to_in_minutes_from_start, 0);
-        if (it != cfg->TimeRange.cend()) {
-            return std::max((int)(it->second.time_range_to_in_minutes_from_start), 0);
-        }
     }
 
     return 0;
@@ -432,10 +420,10 @@ uint32_t Utilities::getFirstDurationStep(Configuration const *cfg, PaymentMethod
 }
 
 BusinessHours Utilities::getBusinessHours(Configuration const *cfg, PaymentMethod methodId) {
-    uint64_t businessHours = cfg->PaymentOption.find(methodId)->second.pop_business_hours;
+    int businessHours = cfg->PaymentOption.find(methodId)->second.pop_business_hours;
 
     switch (businessHours) {
-    //case NoRestriction_24_7: return BusinessHours::NoRestriction_24_7;
+    case NoRestriction_24_7: return BusinessHours::NoRestriction_24_7;
     case OnlyWorkingDays: return BusinessHours::OnlyWorkingDays;
     case OnlyWeekDays: return BusinessHours::OnlyWeekDays;
     case OnlyWeekEnd: return BusinessHours::OnlyWeekEnd;
@@ -445,21 +433,6 @@ BusinessHours Utilities::getBusinessHours(Configuration const *cfg, PaymentMetho
     case SpecialAndSchoolHolidays: return BusinessHours::SpecialAndSchoolHolidays;
     case OnlyOpenForBusinessDays: return BusinessHours::OnlyOpenForBusinessDays;
     case AllDaysWithRestrictedHours: return BusinessHours::AllDaysWithRestrictedHours;
-    case _NO_RESTRICTION_24_7_: return BusinessHours::NO_RESTRICTION_24_7;
-    case _MON_: return BusinessHours::MON;
-    case _TUE_: return BusinessHours::TUE;
-    case _WED_: return BusinessHours::WED;
-    case _THU_: return BusinessHours::THU;
-    case _FRI_: return BusinessHours::FRI;
-    case _SAT_: return BusinessHours::SAT;
-    case _SUN_: return BusinessHours::SUN;
-    case _WEEK_DAYS_: return BusinessHours::WEEK_DAYS;
-    case _WORKING_DAYS_: return BusinessHours::WORKING_DAYS;
-    case _ALL_DAYS_: return BusinessHours::ALL_DAYS;
-    case _OFFICIAL_HOLIDAY_: return BusinessHours::OFFICIAL_HOLIDAY;
-    case _ONLY_WEEKEND_: return BusinessHours::ONLY_WEEKEND;
-    case _ONLY_OPEN_FOR_BUSINESS_DAYS_: return BusinessHours::ONLY_OPEN_FOR_BUSINESS_DAYS;
-    case _NOT_DEFINED_: return BusinessHours::NOT_DEFINED;
     }
     return BusinessHours::NoBusinessHoursDefined;
 }
@@ -474,82 +447,3 @@ double Utilities::computeWeekDaysDurationUnit(Configuration const *cfg, PaymentM
     int durationId = cfg->PaymentRate.find(pop_id)->second.pra_payment_unit_id;
     return (double)(cfg->Duration.find(durationId)->second.pun_duration);
 }
-
-bool Utilities::isDayIncluded(uint64_t businessHours, QDateTime const &dt) {
-    int dayOfWeek = dt.date().dayOfWeek();
-    switch (dayOfWeek) {
-    case Qt::Monday:
-        return ((businessHours & BusinessHours::MON) == BusinessHours::MON);
-    case Qt::Tuesday:
-        return ((businessHours & BusinessHours::TUE) == BusinessHours::TUE);
-    case Qt::Wednesday:
-        return ((businessHours & BusinessHours::WED) == BusinessHours::WED);
-    case Qt::Thursday:
-        return ((businessHours & BusinessHours::THU) == BusinessHours::THU);
-    case Qt::Friday:
-        return ((businessHours & BusinessHours::FRI) == BusinessHours::FRI);
-    case Qt::Saturday:
-        return ((businessHours & BusinessHours::SAT) == BusinessHours::SAT);
-    case Qt::Sunday:
-        return ((businessHours & BusinessHours::SUN) == BusinessHours::SUN);
-    default:;
-    }
-
-    return false;
-}
-
-QStringList Utilities::dumpBusinessHours(uint64_t businessHours) {
-    QStringList s;
-
-    if ((businessHours & BusinessHours::MON) == BusinessHours::MON) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "MON (Holiday)";
-        } else {
-            s << "MON";
-        }
-    }
-    if ((businessHours & BusinessHours::TUE) == BusinessHours::TUE) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "TUE (Holiday)";
-        } else {
-            s << "TUE";
-        }
-    }
-    if ((businessHours & BusinessHours::WED) == BusinessHours::WED) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "WED (Holiday)";
-        } else {
-            s << "WED";
-        }
-    }
-    if ((businessHours & BusinessHours::THU) == BusinessHours::THU) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "THU (Holiday)";
-        } else {
-            s << "THU";
-        }
-    }
-    if ((businessHours & BusinessHours::FRI) == BusinessHours::FRI) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "FRI (Holiday)";
-        } else {
-            s << "FRI";
-        }
-    }
-    if ((businessHours & BusinessHours::SAT) == BusinessHours::SAT) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "SAT (Holiday)";
-        } else {
-            s << "SAT";
-        }
-    }
-    if ((businessHours & BusinessHours::SUN) == BusinessHours::SUN) {
-        if ((businessHours & BusinessHours::OFFICIAL_HOLIDAY) == BusinessHours::OFFICIAL_HOLIDAY) {
-            s << "SUN (Holiday)";
-        } else {
-            s << "SUN";
-        }
-    }
-
-    return s;
-}