Zeitrechnung mit Verschiedenen Zeitzonen

[SlayNox]

Hallo Community,
dies ist mein erster Post in diesem Forum, deshalb bitte ich um etwas Nachsicht.

Mein Problem ist folgendes.

Aktuell schreibe ich eine Anwendung für einen Abschleppdienst in dem ich selbst Tätig bin. Ich schreibe eine Auftragsverwaltung-App die unteranderem einen Kostenrechner beinhaltet um verscheidene Preise in Verschiedenen Zeitzonen zu errechnen. Leider komme ich grade in diesem Thema immer wieder an meine Grenzen.

Ich benötige einen Code der zB prüft ob:

Eine Zeitspanne (zB 17-18 Uhr) sich ein einer "Zuschlags-Zeitspanne befindet".

Beispiel:

Zuschlag-Zone A: 12:00 - 15:00 Uhr > Preis 10€
Zuschlag-Zone B: 15:00 - 18:00 Uhr > Preis 20€
Zuschlag-Zone C: 18:00 - 21:00 Uhr > Preis 30€

nun müsste der Code automatisch erkennen in welcher Zone er sich befindet. Dies ist auch nicht weiter das problem. Problematisch wird es leider wenn die "Einsatzzeit" zb 14:30 - 15:30 ist. Anteilig müsste also eine Halbe Stunde des Zuschlags B aufgerechnet werden. in diesem Fall wäre der Gesamte Zuschlag 15€.

Ebenso problematisch ist es ZB wenn die Einsatzzeit von 14:30 - 18:30 ist.

Ich hoffe ich habe es einigermaßen verständlich rübergebracht und freue mich schon auf einige Antworten.

Liebe Grüße aus Hanau

 

[swa00]

Hallo Slay und willkommen im Forum ...

Bitte sei so lieb und stelle mal den Part des Source codes ein , den du schon umgesetzt hast, dann können wir dir auch gezielter helfen .
Es gibt nämlich mehrere Wege zum Ziel ( entweder mit einer CalendarKlasse , oder mit einem long Wert an Sekunden )

Oder hast du gar nichts und fängst erst an ?

 

[SlayNox]

Hallo swa00 und vielen Dank.
Ich habe viele Wege probiert jedoch alles wider entfernt. Ich habe mich einfach zu oft verstrickt und wieder von vorne angefangen. Demnach stehe ich im moment wieder bei 0 und habe auch aktuell keinen. Ich wollte mir ausnahmsweise mal erst die Meinung anderer anhören bevor ich wieder drauf los schreibe xD.
Grundsetzlich habe ich es aber immer mit vielen if/else versucht zu lösen... xD

 

[swa00]

Hiermit kann man so ziemlich alles Umsetzen, was du benötigst
Time | Android Developers (deprecated)

resp.
GregorianCalendar | Android Developers



Ein bisschen rechnen musst du schon selbst

 

[SlayNox]

Super vielen Dank schonmal dafür. Könnest du mir villeicht, sagen wir mal, einen Grunstein legen? Ein muster an das ich mich halten kann?

Wie die Erfahrung gezeigt hat schaffe ich es alleine einfach nicht. Außerdem treibt mich das zu Weißglut

 

[deek]

Ich bin mir nicht ganz sicher ob dein Problem jetzt das Rechnen mit den Zeiten ist oder ein Algorithmus um die Zuschläge zu berechnen. Ich gehe mal von letzterem aus und versuche mich an etwas PseudoCode. Mit Fleisch füllen müsstest du das dann.

class Surcharge {
    TimeSpan timeSpan;
    int amount;
}

class TimeSpans {
    Time startTime;
    Time endTime;

    fun isIn(Time time) {
        // TODO calculate if the given time is within this timeSpan 
    }
}

fun getSurcharge(TimeSpan timeSpan) : int {
    for (Surcharge in surcharges) {
        if (timeSpan.startTime.isIn(surcharge.timeSpan)) {
            if (timeSpan.endTime.isIn(surcharge.timeSpan)) {
                // current timeSpan is completely within this surcharge timeSpan
                // we return the amount of surcharge per timeunit
                return surcharge.amount * timeSpan.duration
            } else {
                // timeSpan spans multiple surcharge spans
                // we return the surcharge of the interval start to end of surchage plus the surcharge of the interval from end of the surcharge time to end of the given timespan
                return getSurcharge(new TimeSpan(timeSpan.start, surcharge.timeSpan.endTime)) + getSurcharge(new TimeSpan(surchage.timeSpan.endTime, timeSpan.endTime))
            }
        }
    }
}

Die Idee ist divide & conquer mit Rekursion. Wenn eine gegebene Zeitspanne über eine Grenze hinweg geht zerlegen wir das Problem in zwei Teilprobleme, nämlich start bis Aufschlagendzeit und Aufschlagendzeit bis end und addieren das Ergebnis.

 

[SlayNox]

Okay das ist mir schonmal eine große hilfe. Mein Problem besteht hauptsächich darin eine Date zu teilen. Also zu ermitteln wie viel Minuten dieser Stunde nun in einer anderen Zeitzone sind. Ebenso über 2 zonen hinweg dies zu ermitteln. Übringens wäre dies das erste mal das ich mit einem TimeSpan arbeite. Habe das bis jetzt alles versucht mit Date.after() bzw Date.befor() zu lösen.

divide & conquer mit Rekursion ist mir ehrlich gesagt auch ein Fremdbegriff :S

Wie ihr merkt ist Zeitrechnung nicht meine Stärke xD

Übrings habe ich, falls der Code oben Kotlin sein sollte, absolut keine ahnung von Kotlin. Bitte nur das gute alte Java
[doublepost=1541772290,1541769321][/doublepost]Villeicht habe ich mich auch blöd ausgedrückt.
Ich fange nochmal von vorne an.

Ich schreibe eine App in der ein Kostenrechner intigriert ist. Ziel des Rechners Preise verschiedener Leistungen zusammenzurechnen. Unteranderem zB das Abschleppen. Dies wird bei uns nach Zeit abgerechnet. Dabei gibt es diverse Zuschläge. Abhänngig der Arbeitszeit und des Wochentages kommen also verschiedene Zuschläge drauf. Sagen wir mal das Abschleppen kostet 100€ und nach 15:00 Uhr kommen 10€ pro Stunde dazu. Nach 18 Uhr kommen 20€ pro Stunde dazu und nach 21:00 Uhr kommen 30€ pro Stunde dazu.

Jetzt ist es aber möglich das wir 1 Stunde und 15 Minuten schleppen. Also würde das ohne irgendeinen Zuschlag 125€ kosten, da wir einen Abrechnungstakt von 15 minuten haben.

In der App wird nun also die Startzeit und die Endzeit des Auftrags erfasst. Jetzt ist es Aufgabe der App automatsich zu ermitteln durch welche Zeitzonen sich der Auftrag bewegt hat und somit den Preis für das Abschleppen zu errechnen. Sollte also Zb Die Startzeit des Auftrags 14:30 Uhr sein und die Endzeit 18:30 Uhr haben wir eine Auftagszeit von 4 Stunden. Aber es kommen verschiedene Zuschläge drauf, eventuell auch keine Zuschläge. Ich brauche nun eine Codefolge die genau diese Angaben prüft und die Preise dafür addiert.

Alleine bekomme ich das aber nicht hin. Ich denke muss mal einer an die Hand nehmen und hoffe das Ihr das könnt

 

[deek]

Der grobe Fahrplan steht ja oben. Ist jetzt weder Java noch Kotlin, eher Pseudocode aus beidem gemischt.
TimeSpan habe ich gerade erfunden, da habe ich keine bestehende Datenstruktur zugrunde gelegt. Ich definieren TimeSpan einfach als zwei Uhrzeiten. Wie du das darstellst, ist ja deine Sache.

Der Gedanke ist jetzt zu prüfen ob die Startzeit deiner Span innerhalb einer der Zuschlagszeiten liegt. Falls ja testet man ob die Endzeit innerhalb derselben Zuschalgszeit liegt.
1) Ja. Der einfache Fall. Man berechnet dann einfach den Zuschlag für diese Zeit
2) Die Endzeit liegt nicht innerhalb der Zuschlagszeit. Wir teilen die bisherige Zeitspanne auf in eine Zeitspanne mit der ursprünglichen Startzeit bis zur Endzeit unserer gefundenen Zuschlagszeit und eine Zeitspanne mit der Endzeit der Zuschlagszeit als Startzeit und der ursprünglichen Endzeit. Für diese beiden Zeitspannen rufen wir jetzt einfach nochmal dieselbe Funktion auf. (Das ist Rekursion)

Das Prinzip divide&conquer teilt ein Problem in kleinere Teilprobleme und löst diese. Danach wird das Ergenis zusammengefasst.
In unserem Fall teilen wir Zeitspannen und addieren die berechneten Zuschläge.o

Ich könnte dir das jetzt einmal komplett in Code runterprogrammieren, aber ehrlich gesagt bin ich dazu gerade zu faul j
Mit der Idee an sich und etwas Nachdenken sollte es jetzt aber machbar sein.
Du musst dir überlegen wie du Uhrzeiten sinnvoll repräsentierst, ein Date ist da vielleicht gar nicht so schlau, weil die Uhrzeit eigentlich reicht.

 

[SlayNox]

Dein Wort in Gottes Gehör!
Vielen Dank erstmal ich werde dies schnellstmöglich versuchen und meine Ergebnisse mit euch teilen! Ich versuche es jetzt auch erstmal mit der Time Klasse.

Aber falls du doch lust hast etwas zu Tippen um ein Beispiel zu erstellen dann tu dir bloß keinen Zwang an

Danke

 

[deek]

Für die Rechnung mit Zeiten schau dir mal joda Time an. Joda-Time - Home
In deinem Fall insbesondere LocalTime als Repräsentation einer einfachen Uhrzeit. Das ist Comparable, daraus sollte man also seine TimeSpan bauen können.

Die Library hab ich immer geliebt früher. (die Entwickler sagen man solle jetzt die Java8 APIs verwenden, aber unter Android macht joda noch Sinn, weil dir ja erst seit API 26 verfügbar sind)

 

[SlayNox]

Vielen dank für den Tipp, werde es mal durchgehen

 

[SlayNox]

Guten Morgen,
also ich habe es hinbekommen. Vielen Dank nachmal für die Hilfe

public class Zuschlag {

    private DateTime Einsatz_Start;
    private DateTime Einsatz_Ende;

    public void setStart(DateTime start) {
        this.Einsatz_Start = start;
    }
    public void setEnde(DateTime ende) {
        this.Einsatz_Ende = ende;
    }
    public void setSpan(DateTime start, DateTime ende) {this.Einsatz_Start = start; this.Einsatz_Ende = ende;}

    public DateTime getStart() {
        return Einsatz_Start;
    }
    public DateTime getEnde() {
        return Einsatz_Ende;
    }

}

private static Double[] getWeekday(DateTime EINSATZ_START, DateTime EINSATZ_STOP, Double[] results, int dayDifference){

       Zuschlag TS_ZUSCHLAG_WERKTAG_1 = new Zuschlag();
       Zuschlag TS_ZUSCHLAG_WERKTAG_2 = new Zuschlag();
       Zuschlag TS_ZUSCHLAG_WERKTAG_3 = new Zuschlag();
       Zuschlag TS_ZUSCHLAG_WERKTAG_4 = new Zuschlag();

       EINSATZ_STOP.plusDays(dayDifference);

       DateTime ZUSCHLAG_WERKTAG_1_START = new DateTime(getTimeFromCalendar(2,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_1_STOP  = new DateTime(getTimeFromCalendar(4,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_2_START = new DateTime(getTimeFromCalendar(6,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_2_STOP  = new DateTime(getTimeFromCalendar(8,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_3_START = new DateTime(getTimeFromCalendar(10,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_3_STOP  = new DateTime(getTimeFromCalendar(12,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_4_START = new DateTime(getTimeFromCalendar(14,0)).plusDays(dayDifference);
       DateTime ZUSCHLAG_WERKTAG_4_STOP  = new DateTime(getTimeFromCalendar(16,0)).plusDays(dayDifference);

       TS_ZUSCHLAG_WERKTAG_1.setSpan(ZUSCHLAG_WERKTAG_1_START, ZUSCHLAG_WERKTAG_1_STOP);
       TS_ZUSCHLAG_WERKTAG_2.setSpan(ZUSCHLAG_WERKTAG_2_START, ZUSCHLAG_WERKTAG_2_STOP);
       TS_ZUSCHLAG_WERKTAG_3.setSpan(ZUSCHLAG_WERKTAG_3_START, ZUSCHLAG_WERKTAG_3_STOP);
       TS_ZUSCHLAG_WERKTAG_4.setSpan(ZUSCHLAG_WERKTAG_4_START, ZUSCHLAG_WERKTAG_4_STOP);

       //Prüfung auf Zuschlag Zone 1
       if (TS_ZUSCHLAG_WERKTAG_1.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isAfter(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_1.getStart(), EINSATZ_STOP);
       }else if (TS_ZUSCHLAG_WERKTAG_1.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isBefore(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_1.getStart(), TS_ZUSCHLAG_WERKTAG_1.getEnde());
       }else if(TS_ZUSCHLAG_WERKTAG_1.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().equals(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_1.getStart(), EINSATZ_STOP);
       }else if (TS_ZUSCHLAG_WERKTAG_1.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isAfter(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
       }else if (TS_ZUSCHLAG_WERKTAG_1.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isBefore(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_1.getEnde());
       }else if(TS_ZUSCHLAG_WERKTAG_1.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().equals(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_1.getEnde());
       }else if (TS_ZUSCHLAG_WERKTAG_1.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isAfter(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
       }else if (TS_ZUSCHLAG_WERKTAG_1.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().isBefore(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_1.getEnde());
       }else if(TS_ZUSCHLAG_WERKTAG_1.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_1.getEnde().equals(EINSATZ_STOP)){
           results[0] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
       }

        //Prüfung auf Zuschlag Zone 2
        if (TS_ZUSCHLAG_WERKTAG_2.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isAfter(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_2.getStart(), EINSATZ_STOP);
        }else if (TS_ZUSCHLAG_WERKTAG_2.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isBefore(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_2.getStart(), TS_ZUSCHLAG_WERKTAG_2.getEnde());
        }else if(TS_ZUSCHLAG_WERKTAG_2.getStart().isAfter(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().equals(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(TS_ZUSCHLAG_WERKTAG_2.getStart(), EINSATZ_STOP);
        }else if (TS_ZUSCHLAG_WERKTAG_2.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isAfter(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
        }else if (TS_ZUSCHLAG_WERKTAG_2.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isBefore(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_2.getEnde());
        }else if(TS_ZUSCHLAG_WERKTAG_2.getStart().isBefore(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().equals(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_2.getEnde());
        }else if (TS_ZUSCHLAG_WERKTAG_2.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isAfter(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
        }else if (TS_ZUSCHLAG_WERKTAG_2.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().isBefore(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, TS_ZUSCHLAG_WERKTAG_2.getEnde());
        }else if(TS_ZUSCHLAG_WERKTAG_2.getStart().equals(EINSATZ_START) && TS_ZUSCHLAG_WERKTAG_2.getEnde().equals(EINSATZ_STOP)){
            results[1] += getSpanMultiplicator(EINSATZ_START, EINSATZ_STOP);
        }

         .......
        
}