Fix: if start-time is out-of-range (after valid time for sell), switch

to next valid time, taking into account if next valid time is on next day.
Minor: added/changed debug messages.
2025-04-23 11:00:33 +02:00 · 2025-04-23 10:59:39 +02:00 · 2025-04-17 13:33:22 +02:00 · 2025-04-17 13:09:53 +02:00 · 2025-04-16 11:32:20 +02:00 · 2025-04-16 11:31:05 +02:00
7 changed files with 262 additions and 60 deletions
--- a/library/include/mobilisis/tariff_carryover.h
+++ b/library/include/mobilisis/tariff_carryover.h
@@ -37,7 +37,7 @@ struct ATBTariffCarryOver {
        if (coif == "always") {
            m_carryOverIf = ApplyCarryOver::ALWAYS;
        } else {
-           qCritical() << "ERROR unknown carry over application" << coif;
+           qCritical() << __func__ << ":" << __LINE__ << "ERROR unknown carry over application" << coif;
        }
    }

@@ -61,6 +61,37 @@ struct ATBTariffCarryOver {
        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);

--- a/library/include/mobilisis/tariff_prepaid.h
+++ b/library/include/mobilisis/tariff_prepaid.h
@@ -38,7 +38,7 @@ struct ATBTariffPrepaid {
        if (ppif == "always") {
            m_prepaidIf = ApplyPrepaid::ALWAYS;
        } else {
-           qCritical() << "ERROR unknown carry over application" << ppif;
+           qCritical() << __func__ << ":" << __LINE__ << "ERROR unknown carry over application" << ppif;
        }
    }

--- a/library/include/mobilisis/time_range.h
+++ b/library/include/mobilisis/time_range.h
@@ -34,6 +34,13 @@ struct TimeRange {
        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
--- a/library/src/calculate_price.cpp
+++ b/library/src/calculate_price.cpp
@@ -396,16 +396,14 @@ int CALCULATE_LIBRARY_API get_zone_nr(int zone)
    if(zone > -1) return zone;
    else
    {
-        QFile zone("/etc/zone_nr");
+        QFile zone("/mnt/system_data/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;
    }
 }
@@ -782,7 +780,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
    double maxMin = tariff->getPaymentOptions(paymentOptionIndex).pop_max_time;

    // DEBUG
-    qCritical() << "compute_price_for_parking_ticket() " << endl
+    qCritical() << __func__ << ":" << __LINE__ << endl
                << "          paymentOptionIndex: " << paymentOptionIndex << endl
                << "          start_parking_time: " << start_parking_time << endl
                << "          netto_parking_time: " << netto_parking_time << endl
@@ -852,6 +850,8 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(


            QDateTime effectiveStartTime(start_parking_time);
+            qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:"
+                        << effectiveStartTime.toString(Qt::ISODate);

            // handle special days
            int const specialDayId = tariff->specialDayId(start_parking_time);
@@ -882,6 +882,9 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
                }
            }

+            qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:"
+                        << effectiveStartTime.toString(Qt::ISODate);
+
            // handle prepaid option
            int const prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
            std::optional<ATBPrepaid> prepaidOption = tariff->getPrepaidType(prepaid_option_id);
@@ -896,17 +899,36 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(

                    if (start_parking_time.time() < p.prepaid[weekDay].static_end) {     // static_end: e.g. 08:00:00
                        effectiveStartTime.setTime(p.prepaid[weekDay].static_end);
+                        qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:"
+                                    << effectiveStartTime.toString(Qt::ISODate);
                    } else
                    if (start_parking_time.time() > p.prepaid[weekDay].static_start) {   // static_start: e.g. 22:00:00
-                        effectiveStartTime.setTime(p.prepaid[weekDay].static_start);
+                        QTime const midnight(23, 59, 59);
+                        QTime const midnight24(0, 0, 0);
+
+                        if ((p.prepaid[weekDay].static_start <= midnight && midnight24 <= p.prepaid[weekDay].static_end)
+                         || (p.prepaid[weekDay].static_start == midnight && midnight == p.prepaid[weekDay].static_end)
+                         || (p.prepaid[weekDay].static_start == midnight24 && midnight24 == p.prepaid[weekDay].static_end)) {
+                            effectiveStartTime = effectiveStartTime.addDays(1);
+                            weekDay = effectiveStartTime.date().dayOfWeek();
+                            qCritical() << __func__ << ":" << __LINE__
+                                        << "effectiveStartTime: new week day [" << weekDay << "] (Mon=1, Tue=2, ..., Sun=7)";
+                        }
+                        effectiveStartTime.setTime(p.prepaid[weekDay].static_end);
+                        qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:"
+                                    << effectiveStartTime.toString(Qt::ISODate);
                    }
                }
+            } else {
+                qCritical() << __func__ << ":" << __LINE__ << "no prepaid option set";
            }

+            // set seconds to 0
            effectiveStartTime.setTime(QTime(effectiveStartTime.time().hour(),
                                             effectiveStartTime.time().minute(), 0));

-            qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:" << effectiveStartTime.toString(Qt::ISODate);
+            qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:"
+                        << effectiveStartTime.toString(Qt::ISODate);

            int const carryOver = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over;

@@ -914,10 +936,12 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(

            if (carryOver == 1) {
                QTime carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
+                QTime carryOverEnd = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_end;
                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;
+                qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart:" << carryOverStart.toString(Qt::ISODate);
+                qCritical() << __func__ << ":" << __LINE__ << "     carryOverEnd:" << carryOverEnd.toString(Qt::ISODate);
+                qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration:" << carryOverDuration;

                // handle carry over
                int minutesUntilCarryOver = effectiveStartTime.time().secsTo(carryOverStart) / 60;
@@ -927,11 +951,11 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
                    s = s.addSecs(minutesUntilCarryOver * 60);
                    s = s.addSecs(carryOverDuration * 60);
                    end_parking_time = s.addSecs(rest * 60);
+                    qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
                } else {
                    end_parking_time = effectiveStartTime.addSecs(netto_parking_time*60);
-                }
-
                    qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
+                }

                weekDay = end_parking_time.date().dayOfWeek();

@@ -944,11 +968,20 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
                } else
                if (end_parking_time.time() == carryOverStart) {
                    qCritical() << __func__ << ":" << __LINE__ << "        end-parking-time:" << end_parking_time.toString(Qt::ISODate);
-                    qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
+                    qCritical() << __func__ << ":" << __LINE__ << "          carryOverStart:" << carryOverStart.toString(Qt::ISODate);
                    ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
                    if (po.pop_apply_carry_over_to_ticket_endtime) {
                        end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
+                        qCritical() << __func__ << ":" << __LINE__ << "adapted end-parking-time:" << end_parking_time.toString(Qt::ISODate);
+                    }
+                } else
+                if (end_parking_time.time() == carryOverEnd) {
                    qCritical() << __func__ << ":" << __LINE__ << "        end-parking-time:" << end_parking_time.toString(Qt::ISODate);
+                    qCritical() << __func__ << ":" << __LINE__ << "            carryOverEnd:" << carryOverEnd.toString(Qt::ISODate);
+                    ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
+                    if (po.pop_apply_carry_over_to_ticket_endtime == false) {
+                        end_parking_time = end_parking_time.addSecs(-carryOverDuration * 60);
+                        qCritical() << __func__ << ":" << __LINE__ << "adapted end-parking-time:" << end_parking_time.toString(Qt::ISODate);
                    }
                }
            } else {
--- a/library/src/calculator_functions.cpp
+++ b/library/src/calculator_functions.cpp
@@ -379,7 +379,8 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,

    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_price = cfg->getPaymentOptions(paymentOptionIndex).pop_max_price =
+                                cfg->getPaymentOptions(paymentOptionIndex).pop_max_price_save;
    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;
@@ -452,13 +453,50 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
    netto_parking_time_in_minutes = 0;
    brutto_parking_time_in_minutes = 0;
    free_parking_time_in_minutes = 0;
+    int nettoParktimeForCost = 0;

-    int const nettoParktimeForCost = priceNettoParktime[int(cost)];
+    if (priceNettoParktime.contains(int(cost))) {
+        nettoParktimeForCost = priceNettoParktime[int(cost)];
        qCritical() << __func__ << ":" << __LINE__ << QString("cost=%1 nettoParkTimeForCost=%2").
                                                            arg(cost).arg(nettoParktimeForCost);
+    } else {
+
+        // cannot find netto-parking time for cost (=price)
+        // this happens for direct coin input and should not happen otherwise
+        // take the value for the nearest value of cost and mark result as overpaid
+
+        QList <int> keys = priceNettoParktime.keys();   // keys (=prices) are sorted in ascending order
+        QSet<int> s; // make keys unique
+        for (int k = 0; k < keys.size(); ++k) {
+            if (keys[k] < cost) {
+                s << keys[k];
+            }
+        }
+        keys = s.values();
+        // sort in descending order
+        std::sort(std::begin(keys), std::end(keys), std::greater<>());
+        // qCritical() << __func__ << ":" << __LINE__ << "keys=" << keys;
+        if (!keys.isEmpty()) {
+            int const maxCost = keys[0];
+            auto const p = priceNettoParktime.equal_range(maxCost);
+            for (auto it = p.first; it != p.second; ++it) {
+                nettoParktimeForCost = std::max(nettoParktimeForCost, it.value());
+            }
+            ATBPaymentOption &po = cfg->getPaymentOptions(paymentOptionIndex);
+            po.pop_max_price = maxCost;
+            cfg->getPaymentOptions(paymentOptionIndex).pop_max_price = maxCost;
+            if (pop_allow_overpay) {
+                overPaid = true;
+            }
+            qCritical() << __func__ << ":" << __LINE__ << QString("cost=%1 -> maxCost=%2 nettoParkTimeForCost=%3").
+                                                            arg(cost).arg(maxCost).arg(nettoParktimeForCost);
+        } else {
+            qCritical() << __func__ << ":" << __LINE__ << "ERROR empty keys -> check tariff file";
+        }
+    }

    int cnt = 0;
-    while (++cnt < 1000 && netto_parking_time_in_minutes < nettoParktimeForCost) {
+    while (++cnt < 20 && 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;
@@ -555,8 +593,9 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
                       .arg(free_parking_time_in_minutes);

        if (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
-            TimeRange const &carryOverTimeRange = co.value().m_range;
-            free_parking_time_in_minutes += carryOverTimeRange.m_duration;
+            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);
@@ -569,6 +608,7 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
                               .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;
@@ -577,6 +617,8 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
                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;
@@ -601,20 +643,41 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
        // qCritical() << __func__ << ":" << __LINE__ << "cnt" << cnt << "]";
    }

-    if (cnt >= 1000) {
+    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;
-    while (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, inputDate.addSecs(brutto_parking_time_in_minutes * 60))) {
-        if (++cnt > 5) {
-            qCritical() << __func__ << ":" << __LINE__ << "BREAK";
+    QVector<TimeRange> timeRanges;
+    while (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
+        if (++cnt > 10) {
            break;
        }
        TimeRange const &carryOverTimeRange = co.value().m_range;
-        free_parking_time_in_minutes += carryOverTimeRange.m_duration;
+        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;
@@ -887,7 +950,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_price = cfg->getPaymentOptions(paymentOptionIndex).pop_max_price
+                                            = cfg->getPaymentOptions(paymentOptionIndex).pop_max_price_save;
                //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;
@@ -3559,7 +3623,9 @@ uint32_t Calculator::GetPriceForTimeStep(Configuration *cfg, int timeStep, int p
            qCritical() << "(" << __func__ << ":" << __LINE__ << ") timeStep" << timeStep;
        }

-        if (timeStep == pun_duration) {
+        // allow some tolerance when searching for [timeStep == pun_duration]:
+        // this might happen when crossing minute boundaries
+        if (std::abs(timeStep - pun_duration) < 4) {
            qCritical() << "(" << __func__ << ":" << __LINE__ << ") return price" << price;
            return price;
        }
--- a/library/src/configuration.cpp
+++ b/library/src/configuration.cpp
@@ -171,8 +171,9 @@ ATBWeekDay parseWeekDay(Configuration &cfg,
                                                                if (!d.isNull() && d.isValid()) {
                                                                    TariffPrepaid.m_date = d;
                                                                }
+                                                                if (!prepaidIf.isNull() && !prepaidIf.trimmed().isEmpty()) {
                                                                    TariffPrepaid.setPrepaidIf(prepaidIf);
-
+                                                                }
                                                                qCritical() << TariffPrepaid;

                                                                cfg.TariffPrepaids.insert(std::pair<int, ATBTariffPrepaid>(weekDay, TariffPrepaid));
@@ -258,7 +259,7 @@ ATBWeekDay parseWeekDay(Configuration &cfg,
                                                                if (!d.isNull() && d.isValid()) {
                                                                    TariffCarryOver.m_date = d;
                                                                }
-                                                                if (!carryOverIf.isEmpty()) {
+                                                                if (!carryOverIf.isNull() && !carryOverIf.trimmed().isEmpty()) {
                                                                    TariffCarryOver.setCarryOverIf(carryOverIf);
                                                                }

--- a/main/main.cpp
+++ b/main/main.cpp
@@ -39,11 +39,11 @@ extern "C" char* strptime(const char* s,

 #define SZEGED                                  (0)
 #define SCHOENAU_KOENIGSEE                      (0)
-#define NEUHAUSER_KORNEUBURG                    (0)
+#define NEUHAUSER_KORNEUBURG                    (1)
 #define NEUHAUSER_LINSINGER_MASCHINENBAU        (0)
 #define NEUHAUSER_NORDISCHES_AUSBILDUNGSZENTRUM (0)
 #define NEUHAUSER_BILEXA_GALTUER                (0)
-#define BAD_NEUENAHR_AHRWEILER                  (1)
+#define BAD_NEUENAHR_AHRWEILER                  (0)
 #define NEUHAUSER_CHRISTOPH_REISEN              (0)
 #define NEUHAUSER_PERNEGG_AN_DER_MUR            (0)
 #define NEUHAUSER_STOCKERAU                     (0)
@@ -52,6 +52,7 @@ 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) {
@@ -1386,6 +1387,29 @@ 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;
@@ -2780,24 +2804,62 @@ int main() {
            bool nextDay = false;
            bool prePaid = true;
            // zone 1 (lila)
-            QDateTime s(QDate(2023, 11, 30), QTime());
+            QDateTime s(QDate(2024, 10, 8), 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) {
-                for (int offset = 420; offset < 1140; ++offset) {
-                    if (offset > 720 && offset < 840) {
-                        continue;
-                    }
+                int offset = 600;
+                //for (int offset = 720; offset < 601; ++offset) {
+                    //if (offset > 720 && offset < 840) {
+                    //    continue;
+                    //}
                    QDateTime start = s.addSecs(offset * 60);
                    //qCritical() << "start" << start.toString(Qt::ISODate);

-                    double cost = Calculator::GetInstance().GetCostFromDuration(&cfg, 3, start, end, duration, nextDay, prePaid);
+                    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);
                    //Q_ASSERT(cost == duration*2.5);
                    //qCritical() << "";
-                    qCritical() << "start" << start.toString(Qt::ISODate)
-                                << "end" << end.toString(Qt::ISODate)
-                                << "duration" << duration
-                                << "cost" << cost;
-
+                    //qCritical() << "start" << start.toString(Qt::ISODate)
+                    //            << "end" << end.toString(Qt::ISODate)
+                    //            << "duration" << duration
+                    //            << "cost" << cost;
+#if 0
                    switch(duration) {
                    case 30:
                        if (cost == 60.0) {
@@ -2961,15 +3023,17 @@ 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) {
@@ -2990,7 +3054,7 @@ int main() {
                            << "duration" << duration
                            << "cost" << cost;
            }
-
+#endif
        }
    }
    return 0;
Author	SHA1	Message	Date
Gerhard Hoffmann	78cae24389	Fix: if start-time is out-of-range (after valid time for sell), switch to next valid time, taking into account if next valid time is on next day.	2025-04-23 11:00:33 +02:00
Gerhard Hoffmann	de0be1d19b	Minor: added/changed debug messages.	2025-04-23 10:59:39 +02:00
Gerhard Hoffmann	54921f0e85	If price (=key) is not found, compute the next smaller valid price (=key) and use this as maxPrice. Usage: (Innichen (508) with) direct coin input.	2025-04-17 13:33:22 +02:00
Gerhard Hoffmann	077c2334ca	Restore pop_max_price in case it has been changed (for certain settings).	2025-04-17 13:09:53 +02:00
Gerhard Hoffmann	d605af5c5a	Check prepaidIf and carryOverIf for null and emptyness.	2025-04-16 11:32:20 +02:00
Gerhard Hoffmann	c5900f9f2b	Minor: extend debug output	2025-04-16 11:31:05 +02:00
Gerhard Hoffmann	9b137c2873	Fix in Calculator::GetPriceForTimeStep(): Allow some tolerance (of 3 minutes) when looking up the current time-step value in the duration-array. Otherwise, when corossing a minute-boundary, it can happen to not find the match and returning a price of 0 (which is almost always wrong).	2025-04-03 11:53:47 +02:00
Gerhard Hoffmann	dd249a87d5	Set cnt-limit to 20. This allows a bigger time-range for tariff, which have in principle no time-limit.	2025-04-02 15:28:46 +02:00
Gerhard Hoffmann	575885c19e	Merge branch 'master' into kleipeda-experimental	2025-04-02 09:44:20 +02:00
Gerhard Hoffmann	d82a732a8d	if end of parking time equals carry-over-end, then, if configured, go back to carry-over-start.	2025-04-01 14:26:21 +02:00
Gerhard Hoffmann	99dbd7c194	Minor: debug output.	2025-04-01 14:24:42 +02:00
Siegfried Siegert	ae985d25ce	Merge branch 'kleipeda-experimental'	2025-02-04 14:58:58 +01:00
Siegfried Siegert	6a215d4cf9	Allow zone_nr > 999	2025-02-04 14:47:07 +01:00
Siegfried Siegert	a3f4a742ce	Read zone_nr from system_data	2025-02-04 14:44:28 +01:00
Gerhard Hoffmann	e6d8c04076	Fix: for time change summer -> winter term. Compute minutes until midnight manually.	2024-10-30 15:56:58 +01:00
Gerhard Hoffmann	1f6606f382	Add some tests for Forchach (749)	2024-10-10 11:40:29 +02:00
Gerhard Hoffmann	4b9a4319b3	ComputeDurationFromCost(): Fix: take into account that there may be more than just two carry-over-ranges. For instance, in Korneuburg (714), there are three as they have a break from 12:00-14:00.	2024-10-10 11:38:14 +02:00
Gerhard Hoffmann	5e673788b4	ComputeDurationFromCost(): Use helper function computeMinutesUntilCarryOverEnd() to compute the offset until the end of the carry-over-range.	2024-10-10 11:36:14 +02:00
Gerhard Hoffmann	7e2f40a7b5	Add assigment-operator (otherwise compilation error).	2024-10-10 11:33:33 +02:00
Gerhard Hoffmann	44e2ce24a3	Add helper computeMinutesUntilCarryOverEnd(). Used in new tariff-calculator. Replace of previous wrong approach of using m_range.duration.	2024-10-10 11:30:53 +02:00