[gelöst] Zeitberechnung einer Stempeluhr

[NoCee]

Hallo zusammen,
ich schreib mir gerade ein kleines Tool mit dem ich
Kommen/Gehen im Geschäft anhand des PC Hoch/Runterfahrens
auf Platte schreiben. Nach viel lesen im Internet hab ich es geschafft
mit Uhrzeiten zu rechnen und formatiert zu speichern.
Jetzt wollte ich das so erweitern, daß beim Gehen die reine Arbeitszeit
berechnet und auch gespeichert wird. Paßt soweit auch alles nur mit Einem
komm ich nicht wirklich weiter: Die Pausen müssen rausgerechnet werden.
Mittags ne halbe Stunde und Vormittag 20 Minuten sind kein Problem aber
was passiert wenn ich während der Pause komme. Die Pausen werden bei uns
zu festen Zeiten berücksichtigt. Z.B. von 9:00 bis 9:20 wird nicht als Arbeitszeit gerechnet.
Und hier fehlt mir jetzt der Ansatz das anteilig zu berücksichtigen.
Also wenn ich 9:05 komme dürfen nur 15 Minuten abgezogen werden und nicht 20.
Momentan hab ich das so am Laufen. Ich melde mich an, Kommen wird gespeichert.
PC wird runtergefahren, Uhrzeit wird gespeichert mit Kommen wird die Differenz gebildet
und gespeichert. Die Pausenrechnung ist noch nicht verwirklicht.

Hat jemand eine Idee für einen Ansatz?
Ich hab z.B. überlegt, einen Minutentimer zu nehmen und einen Minutenwert hochzuzählen
und die Pausenzeiten beim Zählen zu blockieren. Aber mit der Systemzeit zu arbeiten erschien
mir sinnvoller und genauer.

Bin für jede Idee dankbar
Gruß
NoCee

[Socke]

zu festen Zeiten berücksichtigt. Z.B. von 9:00 bis 9:20 wird nicht als Arbeitszeit gerechnet.
Und hier fehlt mir jetzt der Ansatz das anteilig zu berücksichtigen.
Also wenn ich 9:05 komme dürfen nur 15 Minuten abgezogen werden und nicht 20.
Momentan hab ich das so am Laufen. Ich melde mich an, Kommen wird gespeichert.
PC wird runtergefahren, Uhrzeit wird gespeichert mit Kommen wird die Differenz gebildet
und gespeichert. Die Pausenrechnung ist noch nicht verwirklicht.

Du solltest die Pausenzeiten separat ausweisen. Dann kannst du und deine Mitarbeitende die Berechnung im Nachhinein besser überprüfen.

Bei der Berechnung musst du also bei Kommen und Gehen immer alle Überschneidungskombinationen prüfen

• Wenn Kommen < 9:00 Uhr und Gehen > 9:20 Uhr, dann Pause 20 Minuten
• Wenn Kommen zwischen 9:00 Uhr und 9:20 Uhr und Gehen > 9:20 Uhr, dann Pause 20 Minuten
• Wenn Kommen >= 9:00 Uhr und Gehen <= 9:20 Uhr, dann Pause Gehen - Kommen Minuten
• ...

Beide Werte (Kommen und Gehen) können auch während einer Pause oder auch über Nacht verlaufen (vergessen, den PC auszuschalten).

[Ally]

So könnte es auch gehen:

Code: Alles auswählen

var
  Arbeitszeit 
  PauseAnfang
  PauseEnde

if (Stempelzeit >= PauseAnfang) or (Stempelzeit < PauseEnde) then
  Arbeitszeit := Arbeitszeit - (PauseEnde - Stempelzeit);

[wp_xyz]

Den folgenden Code habe ich gerade getestet. Wenn ich mich nicht vertan habe, müsste es funktionieren. Pausen mit partieller Anwesenheit werden so berücksichtigt, dass eine "effektive" KOMMT und GEHT-Zeit eingeführt wird, die am Ende (bei KOMMT) bzw. Anfang (bei GEHT) einer solchen Pause liegen. In einem weiteren Durchgang werden dann alle Pausen, die zwischen der effektiven KOMMT und GEHT Zeit liegen (diese sind nach nun ganz), subtrahiert.

Code: Alles auswählen

program Project1;

uses
  SysUtils, DateUtils;

type 
  TPause = record
    Beginn: TTime;
    Ende: TTime;
  end;
var 
  Pausen: array[0..1] of TPause;
  tKommt, tGeht: TTime;
  tKommtEff, tGehtEff: TTime;
  tPausen: TTime;
  tArbeitszeit: TTime;
  i: Integer;
const
  KOMMT = '9:10';
  GEHT = '12:05';
begin
  Pausen[0].Beginn := EncodeTime(9, 0, 0, 0);
  Pausen[0].Ende := EncodeTime(9, 15, 0, 0);
  Pausen[1].Beginn := EncodeTime(12, 0, 0, 0);
  Pausen[1].Ende := EncodeTime(13, 0, 0, 0);
  // Nach Belieben erweitern, zeitlich sortiert...

  // KOMMT-Zeit
  tKommt := ScanDateTime('h:nn', KOMMT);
 
  // GEHT-Zeit
  tGeht := ScanDateTime('h:nn', GEHT);
  if tGeht < tKommt then
  begin
    WriteLn('Das kann eigentlich nicht sein. Kann man hier auch über Mitternacht hinaus arbeiten?');
    halt;
  end;
  
  // Effektive KOMMT-Zeit berechnen: das ist das Ende der letzten Pause,
  // während der man gekommen ist, bzw. wenn man vor der ersten Pause kam, die
  // "echte" KOMMT-Zeit.
  tKommtEff := tKommt;
  for i := High(Pausen) downto 0 do
  begin
    if tKommt > Pausen[i].Ende then
      break;
    if tKommt > Pausen[i].Beginn then
    begin
      tKommtEff := Pausen[i].Ende;
      break;
    end;
  end;
  
  // Nun dasselbe mit der GEHT-Zeit
  tGehtEff := tGeht;
  for i := 0 to High(Pausen) do
  begin
    if tGeht < Pausen[i].Beginn then
      break;
    if tGeht < Pausen[i].Ende then
    begin
      tGehtEff := Pausen[i].Beginn;
      break;
    end;
  end;
  
  // Arbeitszeit mit Pausen
  tArbeitszeit := tGehtEff - tKommtEff;
  // Volle Pausen abziehen (tKommtEff und tGehtEff stellen sicher, dass keine
  // "angefangenen" Pausen meht vorhanden sind
  for i := 0 to High(Pausen) do
    if (Pausen[i].Beginn > tKommtEff) and (Pausen[i].Ende < tGehtEff) then
      tArbeitszeit := tArbeitszeit - (Pausen[i].Ende - Pausen[i].Beginn);

  WriteLn('Physische KOMMT-Zeit: ', FormatDateTime('hh:nn', tKommt));
  WriteLn('Physische GEHT-Zeit: ', FormatDateTime('hh:nn', tGeht));
  WriteLn('Physische Anwesenheit: ', FormatDateTime('hh:nn', tGeht - tKommt));
  tPausen := 0;
  for i := 0 to High(Pausen) do
  begin
    WriteLn(i+1, '. Pause: von ', FormatDateTime('hh:nn', Pausen[i].Beginn), 
      ' bis ', FormatDateTime('hh:nn', Pausen[i].Ende), 
      ', Dauer: ', FormatDateTime('hh:nn', Pausen[i].Ende - Pausen[i].Beginn));
    tPausen := tPausen + Pausen[i].Ende - Pausen[i].Beginn;
  end;
  WriteLn('Gesamte Pausenzeit: ', FormatDateTime('hh:nn', tPausen));
  WriteLn('Effektive KOMMT-Zeit: ', FormatDateTime('hh:nn', tKommtEff));
  WriteLn('Effektive GEHT-Zeit: ', FormatDateTime('hh:nn', tGehtEff));
  WriteLn;
  WriteLn('Arbeitszeit: ', FormatDateTime('hh:nn', tArbeitszeit));
  WriteLn;  
  WriteLn('Mit ENTER beenden...');
  ReadLn;
end.

Eine Besonderheit, die wir hatten, ist noch nicht berücksichtig: "KOMMT dienstlich" und "GEHT dienstlich" (man war vorher schon bzw. nachher noch dienstlich unterwegs). Hier werden als effektive KOMMT- bzw GEHT-Zeit der Beginn/das Ende der "normalen" Arbeitszeit eingetragen.

[gladio]

Du mußt beim Abzug von Pausenzeiten auch das Arbeitszeitgesetz berücksichtigen.
Das mit den Pausenzeiten sollte noch immer so sein:

Code: Alles auswählen

        if ZeitDiff <= 3 then Pausenzeit := 0;
        if ZeitDiff > 3 then Pausenzeit := 0.25;
        if ZeitDiff > 6 then Pausenzeit := 0.5;
        if ZeitDiff > 9 then Pausenzeit := 0.75;

Und irgendwo ab 12 Stunden wird es kriminell.
Was ist, wenn der PC sich zum großen Update entschließt in der Arbeitszeit?

[NoCee]

Vielen Dank für eure Unterstützung.
Den Code hab ich mir genauer angeschaut und auch getestet.
Die Ergebnisse hab ich dann mit meinem Zeitnachweis verglichen, daß paßt soweit.
(Und ich kann die Funktion nachvollziehen. )

Die rechtlichen Vorgaben hab ich nicht im Fokus gehabt, da das ja nicht
zum Abrechnen genommen wird sondern für mich nur eine Gedankenstütze sein soll.
Abrechnen tut bei uns ja ein Zeit System, welches auch immer.
Was jetzt interessant ist, ist das Verhalten des Systems wenn ich außerhalb
der normalen Pausen da bin. Z.B. von 14:00 bis x Uhr.
Da dann keine fixen Pausen da sind, wird mit den Zahlen von gladio gerechnet.
Bin ich aber von 9:00 bis 13:00 also nur 4h anwesend werden mir 50 Minuten abgezogen
weil man halt davon ausgehen kann, daß jeder zu Mittag geht.

Ich werde das jetzt so erweitern daß da beides eingebaut ist.


Noch mal Danke für die Infos, vor allem für den Code.
Da bin ich viele Stunden vor einem leeren Blatt gesessen und hab einfach
keinen Ansatz gesehen.

Gruß
NoCee