library/include/mobilisis/tariff_carryover.h

@@ -37,7 +37,7 @@ struct ATBTariffCarryOver {
         if (coif == "always") {
             m_carryOverIf = ApplyCarryOver::ALWAYS;
         } else {
-           qCritical() << __func__ << ":" << __LINE__ << "ERROR unknown carry over application" << coif;
+           qCritical() << "ERROR unknown carry over application" << coif;
         }
     }
 
@@ -61,37 +61,6 @@ 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);
 

library/include/mobilisis/tariff_prepaid.h

@@ -38,7 +38,7 @@ struct ATBTariffPrepaid {
         if (ppif == "always") {
             m_prepaidIf = ApplyPrepaid::ALWAYS;
         } else {
-           qCritical() << __func__ << ":" << __LINE__ << "ERROR unknown carry over application" << ppif;
+           qCritical() << "ERROR unknown carry over application" << ppif;
         }
     }
 

library/include/mobilisis/time_range.h

@@ -34,13 +34,6 @@ 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

library/src/calculate_price.cpp

@@ -396,14 +396,16 @@ int CALCULATE_LIBRARY_API get_zone_nr(int zone)
     if(zone > -1) return zone;
     else
     {
-        QFile zone("/mnt/system_data/zone_nr");
+        QFile zone("/etc/zone_nr");
         if (zone.exists()) {
             QFileInfo finfo(zone);
+            if (finfo.size() <= 4) { // decimal 000\n
                 if (zone.open(QIODevice::ReadOnly | QIODevice::Text)) {
                     QTextStream in(&zone);
                     return in.readLine(100).toInt();
                 }
             }
+        }
         return -1;
     }
 }
@@ -780,7 +782,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
     double maxMin = tariff->getPaymentOptions(paymentOptionIndex).pop_max_time;
 
     // DEBUG
-    qCritical() << __func__ << ":" << __LINE__ << endl
+    qCritical() << "compute_price_for_parking_ticket() " << endl
                 << "          paymentOptionIndex: " << paymentOptionIndex << endl
                 << "          start_parking_time: " << start_parking_time << endl
                 << "          netto_parking_time: " << netto_parking_time << endl
@@ -912,12 +914,10 @@ 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__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
-                qCritical() << __func__ << ":" << __LINE__ << "     carryOverEnd:" << carryOverEnd.toString(Qt::ISODate);
+                qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;
-                qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration:" << carryOverDuration;
 
                 // handle carry over
                 int minutesUntilCarryOver = effectiveStartTime.time().secsTo(carryOverStart) / 60;
@@ -943,21 +943,12 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
                     end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
                 } else
                 if (end_parking_time.time() == carryOverStart) {
-                    qCritical() << __func__ << ":" << __LINE__ << "        end-parking-time:" << end_parking_time.toString(Qt::ISODate);
+                    qCritical() << __func__ << ":" << __LINE__ << "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);
+                        qCritical() << __func__ << ":" << __LINE__ << "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 {

library/src/calculator_functions.cpp

@@ -379,8 +379,7 @@ 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;
@@ -453,50 +452,13 @@ 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;
 
-    if (priceNettoParktime.contains(int(cost))) {
+    int const nettoParktimeForCost = priceNettoParktime[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 < 20 && netto_parking_time_in_minutes < nettoParktimeForCost) {
+    while (++cnt < 1000 && 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;
@@ -593,9 +555,8 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
                        .arg(free_parking_time_in_minutes);
 
         if (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
-            int minutes = co.value().computeMinutesUntilCarryOverEnd(dt);
+            TimeRange const &carryOverTimeRange = co.value().m_range;
-            if (minutes > 0) {
+            free_parking_time_in_minutes += carryOverTimeRange.m_duration;
-                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);
@@ -608,7 +569,6 @@ 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;
@@ -617,8 +577,6 @@ 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;
@@ -643,41 +601,20 @@ Calculator::ComputeDurationFromCost(Configuration *cfg,
         // qCritical() << __func__ << ":" << __LINE__ << "cnt" << cnt << "]";
     }
 
-    if (cnt >= 10) {
+    if (cnt >= 1000) {
         qCritical() << __func__ << ":" << __LINE__ << "BREAK";
     }
 
     // configure if last carry-over ranges shall be added to ticket-end-time
-    dt = inputDate.addSecs(brutto_parking_time_in_minutes * 60);
-
     cnt = 0;
-    QVector<TimeRange> timeRanges;
+    while (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, inputDate.addSecs(brutto_parking_time_in_minutes * 60))) {
-    while (std::optional<ATBTariffCarryOver> co = getCarryOver(cfg, dt)) {
+        if (++cnt > 5) {
-        if (++cnt > 10) {
+            qCritical() << __func__ << ":" << __LINE__ << "BREAK";
             break;
         }
         TimeRange const &carryOverTimeRange = co.value().m_range;
-        if (!timeRanges.isEmpty()) {
+        free_parking_time_in_minutes += carryOverTimeRange.m_duration;
-            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;
@@ -950,8 +887,7 @@ 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;
@@ -3623,9 +3559,7 @@ uint32_t Calculator::GetPriceForTimeStep(Configuration *cfg, int timeStep, int p
             qCritical() << "(" << __func__ << ":" << __LINE__ << ") timeStep" << timeStep;
         }
 
-        // allow some tolerance when searching for [timeStep == pun_duration]:
+        if (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;
         }

library/src/configuration.cpp

@@ -171,9 +171,8 @@ 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));
@@ -259,7 +258,7 @@ ATBWeekDay parseWeekDay(Configuration &cfg,
                                                                 if (!d.isNull() && d.isValid()) {
                                                                     TariffCarryOver.m_date = d;
                                                                 }
-                                                                if (!carryOverIf.isNull() && !carryOverIf.trimmed().isEmpty()) {
+                                                                if (!carryOverIf.isEmpty()) {
                                                                     TariffCarryOver.setCarryOverIf(carryOverIf);
                                                                 }
 

main/main.cpp

@@ -39,11 +39,11 @@ extern "C" char* strptime(const char* s,
 
 #define SZEGED                                  (0)
 #define SCHOENAU_KOENIGSEE                      (0)
-#define NEUHAUSER_KORNEUBURG                    (1)
+#define NEUHAUSER_KORNEUBURG                    (0)
 #define NEUHAUSER_LINSINGER_MASCHINENBAU        (0)
 #define NEUHAUSER_NORDISCHES_AUSBILDUNGSZENTRUM (0)
 #define NEUHAUSER_BILEXA_GALTUER                (0)
-#define BAD_NEUENAHR_AHRWEILER                  (0)
+#define BAD_NEUENAHR_AHRWEILER                  (1)
 #define NEUHAUSER_CHRISTOPH_REISEN              (0)
 #define NEUHAUSER_PERNEGG_AN_DER_MUR            (0)
 #define NEUHAUSER_STOCKERAU                     (0)
@@ -52,7 +52,6 @@ extern "C" char* strptime(const char* s,
 #define SCHNALS_LEITER_KIRCHL                   (0)
 #define SCHNALS_STAUMAUER                       (SCHNALS_LEITER_KIRCHL)
 #define VALSER_ALM                              (0)
-#define NEUHAUSER_FORCHACH                      (0)
 
 #if NEUHAUSER_KIRCHDORF==1
 static bool test_neuhauser_kirchdorf(int step, double cost) {
@@ -1387,29 +1386,6 @@ int main() {
             }
         }
 
-#endif
-#if NEUHAUSER_FORCHACH==1
-    std::ifstream input;
-    input.open("/opt/ptu5/opt/customer_749/etc/psa_tariff/tariff01.json");
-
-    std::stringstream sstr;
-    while(input >> sstr.rdbuf());
-    std::string json(sstr.str());
-
-    Configuration cfg;
-
-    bool isParsed = cfg.ParseJson(&cfg, json.c_str());
-    cout << endl;
-
-    if (isParsed) {
-        compute_product_price(&cfg, PermitType(PERMIT_TYPE::DAY_TICKET_PKW));
-        compute_product_price(&cfg, PermitType(PERMIT_TYPE::DAY_TICKET_CAMPER));
-
-        QDateTime start = QDateTime::currentDateTime();
-        QDateTime ticketEndTime;
-        compute_duration_for_daily_ticket(&cfg, start, ticketEndTime, PermitType(PERMIT_TYPE::DAY_TICKET));
-    }
-
 #endif
 #if BAD_NEUENAHR_AHRWEILER==1
     std::ifstream input;
@@ -2804,62 +2780,24 @@ int main() {
             bool nextDay = false;
             bool prePaid = true;
             // zone 1 (lila)
-            QDateTime s(QDate(2024, 10, 8), QTime());
+            QDateTime s(QDate(2023, 11, 30), QTime());
             QDateTime end;
-
-            static QList<int> const timeSteps = Calculator::GetInstance().GetTimeSteps(&cfg);
-            qCritical() << "TimeSteps" << timeSteps;
-
             for (int duration = 30; duration <= pop_max_time; duration += 5) {
-                int offset = 600;
+                for (int offset = 420; offset < 1140; ++offset) {
-                //for (int offset = 720; offset < 601; ++offset) {
+                    if (offset > 720 && offset < 840) {
-                    //if (offset > 720 && offset < 840) {
+                        continue;
-                    //    continue;
+                    }
-                    //}
                     QDateTime start = s.addSecs(offset * 60);
                     //qCritical() << "start" << start.toString(Qt::ISODate);
 
-                    CalcState cs;
+                    double cost = Calculator::GetInstance().GetCostFromDuration(&cfg, 3, start, end, duration, nextDay, prePaid);
-#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)
+                    qCritical() << "start" << start.toString(Qt::ISODate)
-                    //            << "end" << end.toString(Qt::ISODate)
+                                << "end" << end.toString(Qt::ISODate)
-                    //            << "duration" << duration
+                                << "duration" << duration
-                    //            << "cost" << cost;
+                                << "cost" << cost;
-#if 0
+
                     switch(duration) {
                     case 30:
                         if (cost == 60.0) {
@@ -3023,17 +2961,15 @@ int main() {
                                     << "cost" << cost;
                         exit(-1);
                     }
-#endif
 
                     //std::string duration = Calculator::GetInstance().GetDurationFromCost(&cfg, 3, start.toString(Qt::ISODate).toStdString().c_str(), cost);
                     //Q_ASSERT(cost == duration*2.5);
                     //qCritical() << "start" << start.toString(Qt::ISODate)
                     //            << "cost" << cost
                     //            << "until" << duration.c_str() << start.secsTo(QDateTime::fromString(duration.c_str(), Qt::ISODate)) / 60;
-                //}
+                }
             }
 
-#if 0
             Configuration::SpecialDaysType specialDays = cfg.SpecialDays;
             for (Configuration::SpecialDaysType::const_iterator it = specialDays.cbegin();
                  it != specialDays.cend(); ++it) {
@@ -3054,7 +2990,7 @@ int main() {
                             << "duration" << duration
                             << "cost" << cost;
             }
-#endif
+
         }
     }
     return 0;