Merge pull request 'pagination-table' (#33) from pagination-table into master

Reviewed-on: #33

api/html/openapi.json

@@ -4,7 +4,7 @@
     "title": "Zeiterfassung App",
     "contact": {
       "name": "Torsten Lücke",
-      "url": "http://torsten-hettstedt.de",
+      "url": "https://torsten-hettstedt.de",
       "email": "arbeit@torsten-hettstedt.de"
     },
     "license": {
@@ -188,6 +188,10 @@
             "type": "string",
             "pattern": "[0-5]\\d:[0-5]\\d:[0-5]\\d",
             "example": "08:01:00"
+          },
+          "isHomeOffice": {
+            "description": "Wurde an diesem Tag zuhause gearbeitet?",
+            "type": "boolean"
           }
         }
       },
@@ -217,6 +221,10 @@
             "description": "Arbeitstage im Zeitraum",
             "type": "integer"
           },
+          "homeOfficeDays": {
+            "description": "Anzahl der Tage, an denen zuhause gearbeitet wurde.",
+            "type": "number"
+          },
           "overtime": {
             "description": "Überstunden im Zeitraum",
             "type": "string",

api/src/Controller/WorkingHoursController.php

@@ -21,12 +21,6 @@ class WorkingHoursController extends AbstractController
 {
 
     /**
-     * @param Request              $request
-     * @param Response             $response
-     * @param array<string, mixed> $args
-     *
-     * @return Response
-     *
      * @throws HttpBadRequestException
      * @throws HttpNotFoundException
      */
@@ -34,7 +28,7 @@ class WorkingHoursController extends AbstractController
     {
         $body = $request->getParsedBody();
         $repository = new WorkingHoursRepository($this->databases);
-        $model = $this->buildModel($request, $args['id'], $body['workingTime']);
+        $model = $this->buildModel($request, $args['id'], $body['workingTime'], $body['isHomeOffice'] ?? false);
         try {
             $repository->update($model);
         } catch (RepositoryRecordNotFoundException $exception) {
@@ -44,12 +38,6 @@ class WorkingHoursController extends AbstractController
     }
 
     /**
-     * @param Request              $request
-     * @param Response             $response
-     * @param array<string, mixed> $args
-     *
-     * @return Response
-     *
      * @throws HttpInternalServerErrorException
      * @throws HttpBadRequestException
      * @noinspection PhpUnusedParameterInspection
@@ -79,12 +67,6 @@ class WorkingHoursController extends AbstractController
     }
 
     /**
-     * @param Request              $request
-     * @param Response             $response
-     * @param array<string, mixed> $args
-     *
-     * @return Response
-     *
      * @throws HttpNotFoundException
      * @throws HttpInternalServerErrorException
      */
@@ -105,12 +87,6 @@ class WorkingHoursController extends AbstractController
     }
 
     /**
-     * @param Request              $request
-     * @param Response             $response
-     * @param array<string, mixed> $args
-     *
-     * @return Response
-     *
      * @throws HttpBadRequestException
      * @throws HttpConflictRequestException
      * @throws HttpInternalServerErrorException
@@ -120,7 +96,12 @@ class WorkingHoursController extends AbstractController
     {
         $body = $request->getParsedBody();
         $repository = new WorkingHoursRepository($this->databases);
-        $model = $this->buildModel($request, $body['workingDay'], $body['workingTime']);
+        $model = $this->buildModel(
+            $request,
+            $body['workingDay'],
+            $body['workingTime'],
+            $body['isHomeOffice'] ?? false
+        );
         try {
             $repository->insert($model);
         } catch (RepositoryRecordAlreadyExistException $exception) {
@@ -136,14 +117,9 @@ class WorkingHoursController extends AbstractController
     }
 
     /**
-     * @param Request $request
-     * @param string  $date
-     * @param string  $time
-     *
-     * @return WorkingHours
      * @throws HttpBadRequestException
      */
-    protected function buildModel(Request $request, string $date, string $time): WorkingHours
+    protected function buildModel(Request $request, string $date, string $time, bool $isHomeOffice): WorkingHours
     {
         try {
             $workingDay = new DateTime($date);
@@ -155,7 +131,10 @@ class WorkingHoursController extends AbstractController
         } catch (Exception $exception) {
             throw new HttpBadRequestException($request, 'Der Wert für die Zeit ist falsch', $exception);
         }
-        return (new WorkingHours())->setWorkingDay($workingDay)->setWorkingTime($workingTime);
+        return (new WorkingHours())
+            ->setWorkingDay($workingDay)
+            ->setWorkingTime($workingTime)
+            ->setIsHomeOffice($isHomeOffice);
     }
 
 }

api/src/Models/WorkingHours.php

@@ -12,6 +12,7 @@ class WorkingHours implements ModelInterface
 {
     protected ?DateTime $workingDay = null;
     protected ?DateInterval $workingTime = null;
+    protected bool $isHomeOffice = false;
 
     public function getWorkingDay(): ?DateTime
     {
@@ -35,15 +36,27 @@ class WorkingHours implements ModelInterface
         return $this;
     }
 
+    public function isHomeOffice(): bool
+    {
+        return $this->isHomeOffice;
+    }
+
+    public function setIsHomeOffice(bool $isHomeOffice): WorkingHours
+    {
+        $this->isHomeOffice = $isHomeOffice;
+        return $this;
+    }
+
     /**
      * @return array<string, string>
      */
-    #[ArrayShape(['workingDay' => "string", 'workingTime' => "string"])]
+    #[ArrayShape(['workingDay' => "string", 'workingTime' => "string", 'isHomeOffice' => "boolean"])]
     public function jsonSerialize(): array
     {
         return [
             'workingDay' => $this->getWorkingDay()->format('Y-m-d'),
-            'workingTime' => $this->getWorkingTime()->format('%H:%I:%S')
+            'workingTime' => $this->getWorkingTime()->format('%H:%I:%S'),
+            'isHomeOffice' => $this->isHomeOffice(),
         ];
     }
 }

api/src/Models/WorkingHoursView.php

@@ -16,6 +16,7 @@ class WorkingHoursView implements ModelInterface
         protected PeriodDesignationEnum $periodDesignation,
         protected int $workingDays,
         protected DateInterval $totalHours,
+        private int $homeOfficeDays,
         protected DateInterval $overtime
     ) {
     }
@@ -35,6 +36,11 @@ class WorkingHoursView implements ModelInterface
         return $this->workingDays;
     }
 
+    public function getHomeOfficeDays(): int
+    {
+        return $this->homeOfficeDays;
+    }
+
     public function getTotalHours(): DateInterval
     {
         return $this->totalHours;
@@ -45,19 +51,13 @@ class WorkingHoursView implements ModelInterface
         return $this->overtime;
     }
 
-    /**
+    #[ArrayShape(['period'            => "string",
-     * @inheritDoc
-     *
-     * @return array<string, mixed>
-     */
-    #[ArrayShape([
-        'period'            => "string",
                   'periodDesignation' => "string",
                   'totalHours'        => "string",
                   'workingDays'       => "int",
+                  'homeOfficeDays'    => "int",
                   'overtime'          => "string"
-    ])]
+    ])] public function jsonSerialize(): array
-    public function jsonSerialize(): array
     {
         $formatOvertime = (($this->getOvertime()->invert === 1) ? '-' : '') . '%H:%I:%S';
         return [
@@ -65,6 +65,7 @@ class WorkingHoursView implements ModelInterface
             'periodDesignation' => strtolower($this->getPeriodDesignation()->name),
             'workingDays'       => $this->getWorkingDays(),
             'totalHours'        => $this->getTotalHours()->format('%H:%I:%S'),
+            'homeOfficeDays'    => $this->getHomeOfficeDays(),
             'overtime'          => $this->getOvertime()->format($formatOvertime)
         ];
     }

api/src/Repositories/AbstractWorkingHoursViewRepository.php

@@ -17,8 +17,8 @@ use TorstenHettstedt\TimekeepingApi\Models\WorkingHoursView;
 abstract class AbstractWorkingHoursViewRepository implements RepositoryReaderInterface
 {
 
-    protected const SQL_SELECT = '';
+    protected const string SQL_SELECT = '';
-    protected const SQL_WHERE  = '';
+    protected const string SQL_WHERE  = '';
 
     protected PeriodDesignationEnum $periodDesignation;
 
@@ -49,8 +49,9 @@ abstract class AbstractWorkingHoursViewRepository implements RepositoryReaderInt
             $model = new WorkingHoursView(
                 $this->buildDateFromPeriod($row['period']),
                 $this->periodDesignation,
-                (int)$row['workingDays'],
+                (int) $row['workingDays'],
                 $this->buildDateInterval($row['totalHours']),
+                (int) $row['homeOfficeDays'],
                 $this->buildDateInterval($row['overtime'])
             );
             $models[] = $model;
@@ -82,6 +83,7 @@ abstract class AbstractWorkingHoursViewRepository implements RepositoryReaderInt
             $this->periodDesignation,
             (int)$row['workingDays'],
             $this->buildDateInterval($row['totalHours']),
+            (int)$row['homeOfficeDays'],
             $this->buildDateInterval($row['overtime'])
         );
     }

api/src/Repositories/WorkingHoursMonthlyViewRepository.php

@@ -17,6 +17,7 @@ class WorkingHoursMonthlyViewRepository extends AbstractWorkingHoursViewReposito
             "Monat" as "period",
             "Gesamtarbeitszeit" as "totalHours",
             "Arbeitstage" as "workingDays",
+            "Home-Office-Tage" as "homeOfficeDays",
             "Überstunden" as "overtime"
         from "Arbeitszeiten - Monat"
 SQL;

api/src/Repositories/WorkingHoursRepository.php

@@ -23,7 +23,8 @@ class WorkingHoursRepository implements RepositoryReaderInterface, RepositoryWri
     protected const string SQL_SELECT = <<<'SQL'
 select
     "Datum" as "workingDay",
-    "Arbeitszeit" as "workingTime"
+    "Arbeitszeit" as "workingTime",
+    "HomeOffice" as "isHomeOfficeDay"
 from public."Arbeitszeiten"
 SQL;
 
@@ -73,7 +74,8 @@ SQL;
             $model = new WorkingHours();
             $model
                 ->setWorkingDay(new DateTime($row['workingDay']))
-                ->setWorkingTime(new DateInterval('P0000-00-00T' . $row['workingTime']));
+                ->setWorkingTime(new DateInterval('P0000-00-00T' . $row['workingTime']))
+                ->setIsHomeOffice($row['isHomeOfficeDay']);
             $models[] = $model;
         }
         return $models;
@@ -130,7 +132,8 @@ SQL;
         $model = new WorkingHours();
         $model
             ->setWorkingDay(new DateTime($row['workingDay']))
-            ->setWorkingTime(new DateInterval('P0000-00-00T' . $row['workingTime']));
+            ->setWorkingTime(new DateInterval('P0000-00-00T' . $row['workingTime']))
+            ->setIsHomeOffice($row['isHomeOfficeDay']);
         return $model;
     }
 
@@ -145,6 +148,7 @@ SQL;
         if ($model instanceof WorkingHours) {
             $workingDay = $model->getWorkingDay()->format('Y-m-d');
             $workingTime = $model->getWorkingTime()->format('%H:%I:%S');
+            $isHomeOffice = $model->isHomeOffice();
         } else {
             throw new InvalidArgumentException('Es wird ein Modell der Klasse "' . WorkingHours::class . '" verlangt.');
         }
@@ -154,11 +158,15 @@ SQL;
             throw new RepositoryRecordAlreadyExistException();
         } /** @noinspection PhpUnusedLocalVariableInspection */
         catch (RepositoryRecordNotFoundException $exception) {
-            $stmt = $this->database->prepare(
+            $stmt = $this->database->prepare(<<<'SQL'
-                'insert into  public."Arbeitszeiten" ("Datum", "Arbeitszeit") values (?, ?) on conflict do nothing'
+insert into  public."Arbeitszeiten" ("Datum", "Arbeitszeit", "HomeOffice")
-            );
+values (?, ?, ?)
+on conflict do nothing
+SQL
+);
             $stmt->bindParam(1, $workingDay);
             $stmt->bindParam(2, $workingTime);
+            $stmt->bindParam(3, $isHomeOffice, PDO::PARAM_BOOL);
             $stmt->execute();
         }
     }
@@ -173,12 +181,19 @@ SQL;
         if ($model instanceof WorkingHours) {
             $workingDay = $model->getWorkingDay()->format('Y-m-d');
             $workingTime = $model->getWorkingTime()->format('%H:%I:%S');
+            $isHomeOffice = $model->isHomeOffice();
         } else {
             throw new InvalidArgumentException('Es wird ein Modell der Klasse "' . WorkingHours::class . '" verlangt.');
         }
-        $stmt = $this->database->prepare('update public."Arbeitszeiten" set "Arbeitszeit" = ? where "Datum" = ?');
+        $stmt = $this->database->prepare(<<<'SQL'
+update public."Arbeitszeiten"
+set "Arbeitszeit" = ?, "HomeOffice" = ?
+where "Datum" = ?
+SQL
+);
         $stmt->bindParam(1, $workingTime);
-        $stmt->bindParam(2, $workingDay);
+        $stmt->bindParam(2, $isHomeOffice, PDO::PARAM_BOOL);
+        $stmt->bindParam(3, $workingDay);
         $stmt->execute();
         if ($stmt->rowCount() < 1) {
             throw new RepositoryRecordNotFoundException();

api/src/Repositories/WorkingHoursWeeklyViewRepository.php

@@ -16,6 +16,7 @@ class WorkingHoursWeeklyViewRepository extends AbstractWorkingHoursViewRepositor
             "Woche" as "period",
             "Gesamtarbeitszeit" as "totalHours",
             "Arbeitstage" as "workingDays",
+            "Home-Office-Tage" as "homeOfficeDays",
             "Überstunden" as "overtime"
         from "Arbeitszeiten - Woche"
 SQL;

api/src/Repositories/WorkingHoursYearlyViewRepository.php

@@ -16,6 +16,7 @@ class WorkingHoursYearlyViewRepository extends AbstractWorkingHoursViewRepositor
             "Jahr" as "period",
             "Gesamtarbeitszeit" as "totalHours",
             "Arbeitstage" as "workingDays",
+            "Home-Office-Tage" as "homeOfficeDays",
             "Überstunden" as "overtime"
         from "Arbeitszeiten - Jahr"
 SQL;

api/tests/_data/dump.sql

@@ -22,127 +22,144 @@ DROP TABLE IF EXISTS public."Arbeitszeiten";
 -- Name: Arbeitszeiten; Type: TABLE; Schema: public; Owner: torsten
 --
 
-CREATE TABLE public."Arbeitszeiten" (
+CREATE TABLE public."Arbeitszeiten"
+(
     "Datum"       date                  not null,
     "Arbeitszeit" interval(6)           null,
+    "HomeOffice"  boolean default FALSE not null,
     constraint "Arbeitszeiten_pkey" primary key ("Datum")
 );
 
 
-ALTER TABLE public."Arbeitszeiten" OWNER TO bruce;
+ALTER TABLE public."Arbeitszeiten"
+    OWNER TO bruce;
 
 --
 -- Name: Arbeitszeiten - Jahr; Type: VIEW; Schema: public; Owner: torsten
 --
 
 CREATE OR REPLACE VIEW public."Arbeitszeiten - Jahr" AS
-    SELECT (date_part('year'::text, "Arbeitszeiten"."Datum"))::text AS "Jahr",
+SELECT (date_part('year'::text, "Arbeitszeiten"."Datum"))::text                      AS "Jahr",
-           sum("Arbeitszeiten"."Arbeitszeit") AS "Gesamtarbeitszeit",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-           count("Arbeitszeiten"."Datum") AS "Arbeitstage",
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-           (sum("Arbeitszeiten"."Arbeitszeit") - ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden"
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-    FROM public."Arbeitszeiten"
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    GROUP BY (date_part('year'::text, "Arbeitszeiten"."Datum"))
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
-    ORDER BY (date_part('year'::text, "Arbeitszeiten"."Datum"));
+FROM public."Arbeitszeiten"
+GROUP BY (date_part('year'::text, "Arbeitszeiten"."Datum"))
+ORDER BY (date_part('year'::text, "Arbeitszeiten"."Datum"));
 
 
-ALTER TABLE public."Arbeitszeiten - Jahr" OWNER TO bruce;
+ALTER TABLE public."Arbeitszeiten - Jahr"
+    OWNER TO bruce;
 
 --
 -- Name: Arbeitszeiten - Monat; Type: VIEW; Schema: public; Owner: torsten
 --
 
 CREATE OR REPLACE VIEW public."Arbeitszeiten - Monat" AS
-    SELECT to_char(date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone), 'TMYYYY TMMonth'::text) AS "Monat",
+SELECT to_char(date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone),
-           sum("Arbeitszeiten"."Arbeitszeit") AS "Gesamtarbeitszeit",
+               'TMYYYY TMMonth'::text)                                               AS "Monat",
-           count("Arbeitszeiten"."Datum") AS "Arbeitstage",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-           (sum("Arbeitszeiten"."Arbeitszeit") - ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden"
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-    FROM public."Arbeitszeiten"
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-    GROUP BY (date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone))
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    ORDER BY (date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone));
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
+FROM public."Arbeitszeiten"
+GROUP BY (date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone))
+ORDER BY (date_trunc('month'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone));
 
 
-ALTER TABLE public."Arbeitszeiten - Monat" OWNER TO bruce;
+ALTER TABLE public."Arbeitszeiten - Monat"
+    OWNER TO bruce;
 
 --
 -- Name: Arbeitszeiten - Woche; Type: VIEW; Schema: public; Owner: torsten
 --
 
 CREATE OR REPLACE VIEW public."Arbeitszeiten - Woche" AS
-    SELECT to_char(date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone), 'TMYYYY#WW'::text) AS "Woche",
+SELECT to_char(date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone),
-           sum("Arbeitszeiten"."Arbeitszeit") AS "Gesamtarbeitszeit",
+               'TMYYYY#WW'::text)                                                    AS "Woche",
-           count("Arbeitszeiten"."Datum") AS "Arbeitstage",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-           (sum("Arbeitszeiten"."Arbeitszeit") - ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden"
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-    FROM public."Arbeitszeiten"
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-    GROUP BY (date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone))
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    ORDER BY (date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone));
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
+FROM public."Arbeitszeiten"
+GROUP BY (date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone))
+ORDER BY (date_trunc('week'::text, ("Arbeitszeiten"."Datum")::timestamp with time zone));
 
 
-ALTER TABLE public."Arbeitszeiten - Woche" OWNER TO bruce;
+ALTER TABLE public."Arbeitszeiten - Woche"
+    OWNER TO bruce;
 
 --
 -- Data for Name: Arbeitszeiten; Type: TABLE DATA; Schema: public; Owner: torsten
 --
 
-INSERT INTO public."Arbeitszeiten" ("Datum", "Arbeitszeit") VALUES
+INSERT INTO public."Arbeitszeiten" ("Datum", "Arbeitszeit")
-('2020-01-07','08:06:00'),
+VALUES ('2020-01-07', '08:06:00'),
-('2020-01-08','08:16:00'),
+       ('2020-01-08', '08:16:00'),
-('2020-01-09','07:49:00'),
+       ('2020-01-09', '07:49:00'),
-('2020-01-10','07:30:00'),
+       ('2020-01-10', '07:30:00'),
-('2020-01-13','08:06:00'),
+       ('2020-01-13', '08:06:00'),
-('2020-01-14','08:04:00'),
+       ('2020-01-14', '08:04:00'),
-('2020-01-15','08:20:00'),
+       ('2020-01-15', '08:20:00'),
-('2020-01-16','07:13:00'),
+       ('2020-01-16', '07:13:00'),
-('2020-01-17','07:57:00'),
+       ('2020-01-17', '07:57:00'),
-('2020-01-20','07:53:00'),
+       ('2020-01-20', '07:53:00'),
-('2020-01-21','07:49:00'),
+       ('2020-01-21', '07:49:00'),
-('2020-01-22','07:56:00'),
+       ('2020-01-22', '07:56:00'),
-('2020-01-23','07:55:00'),
+       ('2020-01-23', '07:55:00'),
-('2020-01-24','07:08:00'),
+       ('2020-01-24', '07:08:00'),
-('2020-01-27','08:23:00'),
+       ('2020-01-27', '08:23:00'),
-('2020-01-28','07:20:00'),
+       ('2020-01-28', '07:20:00'),
-('2020-01-29','08:13:00'),
+       ('2020-01-29', '08:13:00'),
-('2020-01-30','08:43:00'),
+       ('2020-01-30', '08:43:00'),
-('2020-01-31','07:21:00'),
+       ('2020-01-31', '07:21:00'),
-('2020-02-03','07:56:00'),
+       ('2020-02-03', '07:56:00'),
-('2020-02-04','08:05:00'),
+       ('2020-02-04', '08:05:00'),
-('2020-02-05','07:58:00'),
+       ('2020-02-05', '07:58:00'),
-('2020-02-06','08:01:00'),
+       ('2020-02-06', '08:01:00')
-('2020-02-07','07:59:00'),
+;
-('2020-02-10','07:50:00'),
+
-('2020-02-11','08:01:00'),
+INSERT INTO public."Arbeitszeiten" ("Datum", "Arbeitszeit", "HomeOffice")
-('2020-02-12','08:14:00'),
+VALUES ('2020-02-07', '07:59:00', FALSE),
-('2020-02-13','08:12:00'),
+       ('2020-02-10', '07:50:00', FALSE),
-('2020-02-14','07:51:00'),
+       ('2020-02-11', '08:01:00', FALSE),
-('2020-02-17','07:59:00'),
+       ('2020-02-12', '08:14:00', FALSE),
-('2020-02-18','08:05:00'),
+       ('2020-02-13', '08:12:00', FALSE),
-('2020-02-19','07:34:00'),
+       ('2020-02-14', '07:51:00', FALSE),
-('2020-02-20','07:33:00'),
+       ('2020-02-17', '07:59:00', FALSE),
-('2020-02-21','07:56:00'),
+       ('2020-02-18', '08:05:00', FALSE),
-('2020-02-24','08:02:00'),
+       ('2020-02-19', '07:34:00', FALSE),
-('2020-02-25','08:13:00'),
+       ('2020-02-20', '07:33:00', FALSE),
-('2020-02-26','08:42:00'),
+       ('2020-02-21', '07:56:00', FALSE),
-('2020-02-27','07:49:00'),
+       ('2020-02-24', '08:02:00', FALSE),
-('2020-02-28','08:16:00'),
+       ('2020-02-25', '08:13:00', FALSE),
-('2020-03-02','08:22:00'),
+       ('2020-02-26', '08:42:00', FALSE),
-('2020-03-03','08:20:00'),
+       ('2020-02-27', '07:49:00', TRUE),
-('2020-03-04','08:12:00'),
+       ('2020-02-28', '08:16:00', FALSE),
-('2020-03-05','08:32:00'),
+       ('2020-03-02', '08:22:00', FALSE),
-('2020-03-06','04:41:00'),
+       ('2020-03-03', '08:20:00', FALSE),
-('2020-03-09','07:05:00'),
+       ('2020-03-04', '08:12:00', FALSE),
-('2020-03-10','07:34:00'),
+       ('2020-03-05', '08:32:00', FALSE),
-('2020-03-11','07:39:00'),
+       ('2020-03-06', '04:41:00', FALSE),
-('2020-03-12','07:50:00'),
+       ('2020-03-09', '07:05:00', FALSE),
-('2020-03-13','08:26:00'),
+       ('2020-03-10', '07:34:00', FALSE),
-('2020-03-16','07:51:00'),
+       ('2020-03-11', '07:39:00', TRUE),
-('2020-03-17','07:50:00'),
+       ('2020-03-12', '07:50:00', FALSE),
-('2020-03-18','07:19:00'),
+       ('2020-03-13', '08:26:00', FALSE),
-('2020-03-19','07:55:00'),
+       ('2020-03-16', '07:51:00', FALSE),
-('2020-03-20','05:43:00'),
+       ('2020-03-17', '07:50:00', FALSE),
-('2020-03-23','08:05:00'),
+       ('2020-03-18', '07:19:00', FALSE),
-('2020-03-24','08:21:00'),
+       ('2020-03-19', '07:55:00', FALSE),
-('2020-03-25','08:10:00'),
+       ('2020-03-20', '05:43:00', TRUE),
-('2020-03-26','10:31:00'),
+       ('2020-03-23', '08:05:00', FALSE),
-('2020-03-27','04:55:00'),
+       ('2020-03-24', '08:21:00', FALSE),
-('2020-03-30','08:21:00'),
+       ('2020-03-25', '08:10:00', FALSE),
-('2020-03-31','08:01:00')
+       ('2020-03-26', '10:31:00', FALSE),
+       ('2020-03-27', '04:55:00', FALSE),
+       ('2020-03-30', '08:21:00', FALSE),
+       ('2020-03-31', '08:01:00', FALSE)
 ;

api/tests/_support/Helper/Api.php

@@ -1,4 +1,5 @@
 <?php
+
 namespace Helper;
 
 // here you can define custom actions
@@ -15,6 +16,7 @@ class Api extends Module
     const WORKING_HOURS_JSON_FORMAT = [
         'workingDay'   => self::FORMAT_DATE,
         'workingTime'  => self::FORMAT_TIME,
+        'isHomeOffice' => 'boolean',
     ];
 
     const WORKING_HOURS_VIEW_JSON_FORMAT = [
@@ -22,6 +24,7 @@ class Api extends Module
         "periodDesignation" => "string",
         "totalHours"        => self::FORMAT_TIME,
         "workingDays"       => 'integer:>0',
+        'homeOfficeDays'    => 'integer:>=0',
         "overtime"          => self::FORMAT_TIME,
     ];
 

api/tests/api/WorkingHours/CreateWorkingHoursCest.php

@@ -21,6 +21,22 @@ class CreateWorkingHoursCest
     }
 
     public function createWorkingHoursWithNewValidRecord(ApiTester $I): void
+    {
+        $I->haveHttpHeader('accept', 'application/json');
+        $I->haveHttpHeader('content-type', 'application/json');
+        $I->haveHttpHeader('Origin', Api::TEST_ORIGIN);
+        $I->sendPost('/working-hours', [
+            'workingDay'  => '2020-04-01',
+            'workingTime' => '08:00:00',
+            'isHomeOffice' => false,
+        ]);
+        $I->seeResponseCodeIs(HttpCode::CREATED);
+        $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);
+        $I->seeResponseIsJson();
+        $I->seeResponseMatchesJsonType(Api::WORKING_HOURS_JSON_FORMAT);
+    }
+
+    public function createWorkingHoursWithNewValidRecordWithoutHomeOffice(ApiTester $I): void
     {
         $I->haveHttpHeader('accept', 'application/json');
         $I->haveHttpHeader('content-type', 'application/json');
@@ -44,6 +60,7 @@ class CreateWorkingHoursCest
         $I->sendPost('/working-hours', [
             'workingDay'  => '2020-04-01',
             'workingTime' => 8.0,
+            'isHomeOffice' => false,
         ]);
         $I->seeResponseCodeIs(HttpCode::BAD_REQUEST);
         $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);
@@ -60,6 +77,7 @@ class CreateWorkingHoursCest
         $I->sendPost('/working-hours', [
             'workingDay'  => '2020-01-15',
             'workingTime' => '08:00:00',
+            'isHomeOffice' => false,
         ]);
         $I->seeResponseCodeIs(HttpCode::CONFLICT);
         $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);

api/tests/api/WorkingHours/UpdateWorkingHoursCest.php

@@ -1,4 +1,5 @@
-<?php /** @noinspection PhpUnused */
+<?php
+/** @noinspection PhpUnused */
 
 namespace TorstenHettstedt\TimekeepingApi\Tests\Api\WorkingHours;
 
@@ -28,6 +29,7 @@ class UpdateWorkingHoursCest
         $I->sendPut('/working-hours/2020-01-15', [
             'workingDay'   => '2020-01-15',
             'workingTime'  => '10:00:00',
+            'isHomeOffice' => false,
         ]);
         $I->seeResponseCodeIs(HttpCode::OK);
         $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);
@@ -43,6 +45,7 @@ class UpdateWorkingHoursCest
         $I->sendPut('/working-hours/2020-04-15', [
             'workingDay'  => '2020-04-15',
             'workingTime' => '10:00:00',
+            'isHomeOffice' => false,
         ]);
         $I->seeResponseCodeIs(HttpCode::NOT_FOUND);
         $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);
@@ -58,6 +61,7 @@ class UpdateWorkingHoursCest
         $I->sendPut('/working-hours/2020-01-15', [
             'workingDay'  => '2020-01-15',
             'workingTime' => 8.0,
+            'isHomeOffice' => false,
         ]);
         $I->seeResponseCodeIs(HttpCode::BAD_REQUEST);
         $I->canSeeHttpHeader('Access-Control-Allow-Origin', Api::TEST_ORIGIN);

api/tests/unit/Controller/WorkingHoursControllerTest.php

@@ -4,6 +4,7 @@ namespace TorstenHettstedt\TimekeepingApi\Tests\Unit\Controller;
 
 use Codeception\Attribute\DataProvider;
 use Exception;
+use PHPUnit\Framework\MockObject\Exception as MockException;
 use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
 use Psr\Container\NotFoundExceptionInterface;
@@ -25,7 +26,7 @@ class WorkingHoursControllerTest extends AbstractControllerTest
 
     /**
      * @throws Exception
-     * @throws \PHPUnit\Framework\MockObject\Exception
+     * @throws MockException
      */
     protected function _before(): void
     {
@@ -34,6 +35,7 @@ class WorkingHoursControllerTest extends AbstractControllerTest
             'getParsedBody' => [
                 'workingDay'   => self::EXISTING_DATE,
                 'workingTime'  => self::EXISTING_INTERVAL,
+                'isHomeOffice' => true,
             ],
         ]);
     }
@@ -260,6 +262,28 @@ class WorkingHoursControllerTest extends AbstractControllerTest
         $this->assertNotEmpty($response->getBody()->getContents());
     }
 
+    /**
+     * @throws ContainerExceptionInterface
+     * @throws NotDatabasesException
+     * @throws NotFoundExceptionInterface
+     * @throws Exception
+     */
+    public function testUpdateExistRecordWithoutHomeOffice(): void
+    {
+        $this->request = $this->makeEmpty(Request::class, [
+            'getParsedBody' => [
+                'workingDay'  => self::EXISTING_DATE,
+                'workingTime' => self::EXISTING_INTERVAL,
+            ],
+        ]);
+        $controller = new WorkingHoursController($this->container);
+        $response = $controller->update($this->request, $this->response, [
+            'id' => self::EXISTING_DATE,
+        ]);
+        $this->assertEquals(self::FICTIONAL_STATUS_CODE, $response->getStatusCode());
+        $this->assertNotEmpty($response->getBody()->getContents());
+    }
+
     /**
      * @throws ContainerExceptionInterface
      * @throws NotDatabasesException
@@ -293,21 +317,19 @@ class WorkingHoursControllerTest extends AbstractControllerTest
     }
 
     /**
-     * @param string $date
-     * @param string $time
-     *
      * @throws ContainerExceptionInterface
      * @throws NotDatabasesException
      * @throws NotFoundExceptionInterface
      * @throws Exception
      */
     #[DataProvider('invalidCreatDataProvider')]
-    public function testCreatInvalidData(string $date, string $time): void
+    public function testCreatInvalidData(string $date, string $time, bool $isHomeOffice = false): void
     {
         $this->request = $this->makeEmpty(Request::class, [
             'getParsedBody' => [
                 'workingDay'   => $date,
                 'workingTime'  => $time,
+                'isHomeOffice' => $isHomeOffice,
             ],
         ]);
         $controller = new WorkingHoursController($this->container);
@@ -322,6 +344,27 @@ class WorkingHoursControllerTest extends AbstractControllerTest
      * @throws Exception
      */
     public function testCreatNewRecord(): void
+    {
+        $this->request = $this->makeEmpty(Request::class, [
+            'getParsedBody' => [
+                'workingDay'   => self::NEW_DATE,
+                'workingTime'  => self::NEW_INTERVAL,
+                'isHomeOffice' => true,
+            ],
+        ]);
+        $controller = new WorkingHoursController($this->container);
+        $response = $controller->creat($this->request, $this->response, []);
+        $this->assertEquals(self::FICTIONAL_STATUS_CODE, $response->getStatusCode());
+        $this->assertNotEmpty($response->getBody()->getContents());
+    }
+
+    /**
+     * @throws ContainerExceptionInterface
+     * @throws NotDatabasesException
+     * @throws NotFoundExceptionInterface
+     * @throws Exception
+     */
+    public function testCreatNewRecordWithoutHomeOffice(): void
     {
         $this->request = $this->makeEmpty(Request::class, [
             'getParsedBody' => [
@@ -347,6 +390,7 @@ class WorkingHoursControllerTest extends AbstractControllerTest
             'getParsedBody' => [
                 'workingDay'   => self::EXISTING_DATE,
                 'workingTime'  => self::EXISTING_INTERVAL,
+                'isHomeOffice' => true,
             ],
         ]);
         $controller = new WorkingHoursController($this->container);

api/tests/unit/Models/WorkingHoursTest.php

@@ -17,6 +17,7 @@ class WorkingHoursTest extends Unit
         $obj = new WorkingHours();
         $this->assertNull($obj->getWorkingDay());
         $this->assertNull($obj->getWorkingTime());
+        $this->assertFalse($obj->isHomeOffice());
 
         $this->expectException(Error::class);
         $obj->jsonSerialize();
@@ -34,7 +35,9 @@ class WorkingHoursTest extends Unit
                 [
                     'workingDay'   => '2020-11-30',
                     'workingTime'  => '08:00:00',
+                    'isHomeOffice' => true,
                 ],
+                true,
             ],
             [
                 new DateTime('2021-05-03'),
@@ -42,7 +45,9 @@ class WorkingHoursTest extends Unit
                 [
                     'workingDay'   => '2021-05-03',
                     'workingTime'  => '07:45:00',
+                    'isHomeOffice' => false,
                 ],
+                false,
             ],
         ];
     }
@@ -51,10 +56,38 @@ class WorkingHoursTest extends Unit
      * @param DateTime              $date
      * @param DateInterval          $interval
      * @param array<string, string> $shouldJson
+     * @param bool                  $isHomeOffice
      */
     #[DataProvider('workingHoursProvider')]
-    public function testWorkingHoursWithContent(DateTime $date, DateInterval $interval, array $shouldJson): void
+    public function testWorkingHoursWithContent(DateTime $date, DateInterval $interval, array $shouldJson, bool $isHomeOffice): void
     {
+        $obj = new WorkingHours();
+        $obj->setWorkingDay($date)->setWorkingTime($interval)->setIsHomeOffice($isHomeOffice);
+
+        $this->assertNotNull($obj->getWorkingDay());
+        $this->assertInstanceOf(DateTime::class, $obj->getWorkingDay());
+        $this->assertEquals($date, $obj->getWorkingDay());
+
+        $this->assertNotNull($obj->getWorkingTime());
+        $this->assertInstanceOf(DateInterval::class, $obj->getWorkingTime());
+        $this->assertEquals($interval, $obj->getWorkingTime());
+
+        $this->assertIsBool($obj->isHomeOffice());
+        $this->assertEquals($isHomeOffice, $obj->isHomeOffice());
+
+        $json = $obj->jsonSerialize();
+        $this->assertEquals($shouldJson, $json);
+    }
+
+    /**
+     * @param DateTime              $date
+     * @param DateInterval          $interval
+     * @param array<string, string> $shouldJson
+     */
+    #[DataProvider('workingHoursProvider')]
+    public function testWorkingHoursWithContentWithoutHomeOfficeInformation(DateTime $date, DateInterval $interval, array $shouldJson): void
+    {
+        $shouldJson['isHomeOffice'] = false;
         $obj = new WorkingHours();
         $obj->setWorkingDay($date)->setWorkingTime($interval);
 
@@ -66,6 +99,9 @@ class WorkingHoursTest extends Unit
         $this->assertInstanceOf(DateInterval::class, $obj->getWorkingTime());
         $this->assertEquals($interval, $obj->getWorkingTime());
 
+        $this->assertIsBool($obj->isHomeOffice());
+        $this->assertFalse($obj->isHomeOffice());
+
         $json = $obj->jsonSerialize();
         $this->assertEquals($shouldJson, $json);
     }

api/tests/unit/Models/WorkingHoursViewTest.php

@@ -20,6 +20,7 @@ class WorkingHoursViewTest extends Unit
     {
         $date = new DateTime('2020-11-30');
         $work_days = 15;
+        $home_work_days = 12;
         $total_hours = new DateInterval("PT32H22M");
         $overtime = new DateInterval("PT22M");
         $absence_time = clone $overtime;
@@ -30,12 +31,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::WEEKLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $overtime,
                 [
                     'period'            => '2020#49',
                     'periodDesignation' => 'weekly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '00:22:00'
                 ],
             ],
@@ -44,12 +47,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::WEEKLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $absence_time,
                 [
                     'period'            => '2020#49',
                     'periodDesignation' => 'weekly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '-00:22:00'
                 ],
             ],
@@ -58,12 +63,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::MONTHLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $overtime,
                 [
                     'period'            => '2020-11',
                     'periodDesignation' => 'monthly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '00:22:00'
                 ],
             ],
@@ -72,12 +79,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::MONTHLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $absence_time,
                 [
                     'period'            => '2020-11',
                     'periodDesignation' => 'monthly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '-00:22:00'
                 ],
             ],
@@ -86,12 +95,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::YEARLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $overtime,
                 [
                     'period'            => '2020',
                     'periodDesignation' => 'yearly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '00:22:00'
                 ],
             ],
@@ -100,12 +111,14 @@ class WorkingHoursViewTest extends Unit
                 PeriodDesignationEnum::YEARLY,
                 $work_days,
                 $total_hours,
+                $home_work_days,
                 $absence_time,
                 [
                     'period'            => '2020',
                     'periodDesignation' => 'yearly',
                     'workingDays'       => 15,
                     'totalHours'        => '32:22:00',
+                    'homeOfficeDays'    => $home_work_days,
                     'overtime'          => '-00:22:00'
                 ],
             ],
@@ -117,6 +130,7 @@ class WorkingHoursViewTest extends Unit
      * @param PeriodDesignationEnum $periodDesignation
      * @param int                   $workingDays
      * @param DateInterval          $totalHours
+     * @param int                   $homeWorkDays ,
      * @param DateInterval          $overtime
      * @param array<string, string> $shouldJson
      */
@@ -126,10 +140,11 @@ class WorkingHoursViewTest extends Unit
         PeriodDesignationEnum $periodDesignation,
         int $workingDays,
         DateInterval $totalHours,
+        int $homeWorkDays,
         DateInterval $overtime,
         array $shouldJson
     ): void {
-        $obj = new WorkingHoursView($period, $periodDesignation, $workingDays, $totalHours, $overtime);
+        $obj = new WorkingHoursView($period, $periodDesignation, $workingDays, $totalHours, $homeWorkDays, $overtime);
 
         $this->assertInstanceOf(DateTimeInterface::class, $obj->getPeriod());
         $this->assertEquals($period, $obj->getPeriod());
@@ -142,6 +157,9 @@ class WorkingHoursViewTest extends Unit
         $this->assertInstanceOf(DateInterval::class, $obj->getTotalHours());
         $this->assertEquals($totalHours, $obj->getTotalHours());
 
+        $this->assertIsInt($obj->getHomeOfficeDays());
+        $this->assertEquals($homeWorkDays, $obj->getHomeOfficeDays());
+
         $this->assertInstanceOf(DateInterval::class, $obj->getOvertime());
         $this->assertEquals($overtime, $obj->getOvertime());
 

api/tests/unit/Repositories/WorkingHoursRepositoryTest.php

@@ -159,6 +159,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::NEW_DATE),
             'workingTime'  => new DateInterval(self::NEW_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $repository->insert($model);
         $model = $repository->findByKey(self::NEW_DATE);
@@ -176,6 +177,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::EXISTING_DATE),
             'workingTime'  => new DateInterval(self::NEW_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $this->expectException(RepositoryRecordAlreadyExistException::class);
         $repository->insert($model);
@@ -203,6 +205,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::EXISTING_DATE),
             'workingTime'  => new DateInterval(self::EXISTING_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $repository->delete($model);
         $this->expectException(RepositoryRecordNotFoundException::class);
@@ -219,6 +222,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::NEW_DATE),
             'workingTime'  => new DateInterval(self::NEW_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $this->expectException(RepositoryRecordNotFoundException::class);
         $repository->delete($model);
@@ -246,6 +250,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::EXISTING_DATE),
             'workingTime'  => new DateInterval(self::NEW_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $repository->update($model);
         $model_db = $repository->findByKey(self::EXISTING_DATE);
@@ -261,6 +266,7 @@ class WorkingHoursRepositoryTest extends Unit
         $model = $this->make(WorkingHours::class, [
             'workingDay'   => new DateTime(self::NEW_DATE),
             'workingTime'  => new DateInterval(self::NEW_INTERVAL),
+            'isHomeOffice' => false,
         ]);
         $this->expectException(RepositoryRecordNotFoundException::class);
         $repository->update($model);

api/tests/unit/Repositories/WorkingHoursViewRepositoryTest.php

@@ -6,7 +6,8 @@ use Codeception\Attribute\DataProvider;
 use Codeception\Test\Unit;
 use DateTime;
 use DateTimeZone;
-use PDO;use TorstenHettstedt\TimekeepingApi\Models\WorkingHoursView;
+use PDO;
+use TorstenHettstedt\TimekeepingApi\Models\WorkingHoursView;
 use TorstenHettstedt\TimekeepingApi\Repositories\RepositoryRecordNotFoundException;
 use TorstenHettstedt\TimekeepingApi\Repositories\WorkingHoursWeeklyViewRepository;
 use TorstenHettstedt\TimekeepingApi\Repositories\WorkingHoursMonthlyViewRepository;
@@ -19,7 +20,9 @@ class WorkingHoursViewRepositoryTest extends Unit
     protected function _before(): void
     {
         /** @noinspection SpellCheckingInspection */
-        $this->pdoObject = new PDO('pgsql:host=psql.torsten-hettstedt.net;port=5432;dbname=testdb;user=bruce;password=mypass');
+        $this->pdoObject = new PDO(
+            'pgsql:host=psql.torsten-hettstedt.net;port=5432;dbname=testdb;user=bruce;password=mypass'
+        );
         parent::_before();
     }
 
@@ -41,9 +44,27 @@ class WorkingHoursViewRepositoryTest extends Unit
     public function existingObjectProvider(): array
     {
         return [
-            [WorkingHoursYearlyViewRepository::class,  '2020',          61, date_create('2020-01-01', new DateTimeZone('UCT'))],
+            [
-            [WorkingHoursMonthlyViewRepository::class, '2020 February', 20, date_create('2020-02-01', new DateTimeZone('UCT'))],
+                WorkingHoursYearlyViewRepository::class,
-            [WorkingHoursWeeklyViewRepository::class,  '2020#03',        5, date_create('2020-01-13', new DateTimeZone('UCT'))],
+                '2020',
+                61,
+                date_create('2020-01-01', new DateTimeZone('UCT')),
+                3,
+            ],
+            [
+                WorkingHoursMonthlyViewRepository::class,
+                '2020 February',
+                20,
+                date_create('2020-02-01', new DateTimeZone('UCT')),
+                1,
+            ],
+            [
+                WorkingHoursWeeklyViewRepository::class,
+                '2020#03',
+                5,
+                date_create('2020-01-13', new DateTimeZone('UCT')),
+                0,
+            ],
         ];
     }
 
@@ -70,13 +91,19 @@ class WorkingHoursViewRepositoryTest extends Unit
     }
 
     #[DataProvider(('existingObjectProvider'))]
-    public function testExistingFindByKey(string $periodClass, string $search, int $workingDays, DateTime $period): void
+    public function testExistingFindByKey(
-    {
+        string $periodClass,
+        string $search,
+        int $workingDays,
+        DateTime $period,
+        int $homeOfficeDays
+    ): void {
         $repository = new $periodClass($this->pdoObject);
         $model = $repository->findByKey($search);
         $this->assertInstanceOf(WorkingHoursView::class, $model);
         $this->assertEquals($workingDays, $model->getWorkingDays());
         $this->assertEquals($period->format('Ymd'), $model->getPeriod()->format('Ymd'));
+        $this->assertEquals($homeOfficeDays, $model->getHomeOfficeDays());
     }
 
     #[DataProvider(('notExistingObjectProvider'))]

resources/sql/postgresql.sql

@@ -4,42 +4,46 @@ create table public."Arbeitszeiten"
 (
     "Datum"       date                  not null,
     "Arbeitszeit" interval(6)           null,
+    "HomeOffice"  boolean default FALSE not null,
     constraint "Arbeitszeiten_pkey" primary key ("Datum")
 );
 
 
 -- # Definition der Ansichten
 -- ## Wöchentlich
-create view "Arbeitszeiten - Woche" ("Woche", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden") as
+create view "Arbeitszeiten - Woche" ("Woche", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden", "Home-Office-Tage") as
-    select
+select to_char(date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone),
-        to_char(date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone),
                'TMYYYY#WW'::text)                                                    as "Woche",
-        sum("Arbeitszeiten"."Arbeitszeit") as "Gesamtarbeitszeit",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-        count("Arbeitszeiten"."Datum")     as "Arbeitstage",
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-        sum("Arbeitszeiten"."Arbeitszeit") - count("Arbeitszeiten"."Datum") ::double precision * '08:00:00'::interval as "Überstunden"
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-    from "Arbeitszeiten"
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    group by (date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone))
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
-    order by (date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone));
+from "Arbeitszeiten"
+group by (date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone))
+order by (date_trunc('week'::text, "Arbeitszeiten"."Datum"::timestamp with time zone));
 
 -- ## Monatlich
-create view "Arbeitszeiten - Monat" ("Monat", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden") as
+create view "Arbeitszeiten - Monat" ("Monat", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden", "Home-Office-Tage") as
-    select
+select to_char(date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone),
-        to_char(date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone),
                'TMYYYY TMMonth'::text)                                               as "Monat",
-        sum("Arbeitszeiten"."Arbeitszeit") as "Gesamtarbeitszeit",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-        count("Arbeitszeiten"."Datum")     as "Arbeitstage",
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-        sum("Arbeitszeiten"."Arbeitszeit") - count("Arbeitszeiten"."Datum") ::double precision * '08:00:00'::interval as "Überstunden"
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-    from "Arbeitszeiten"
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    group by (date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone))
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
-    order by (date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone));
+from "Arbeitszeiten"
+group by (date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone))
+order by (date_trunc('month'::text, "Arbeitszeiten"."Datum"::timestamp with time zone));
 
 -- ## Jährlich
-create view "Arbeitszeiten - Jahr"("Jahr", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden") as
+create view "Arbeitszeiten - Jahr"("Jahr", "Gesamtarbeitszeit", "Arbeitstage", "Überstunden", "Home-Office-Tage") as
-    select
+select date_part('year'::text, "Arbeitszeiten"."Datum")::text                        as "Jahr",
-        date_part('year'::text, "Arbeitszeiten"."Datum")::text   as "Jahr",
+       sum("Arbeitszeiten"."Arbeitszeit")::interval                                  AS "Gesamtarbeitszeit",
-        sum("Arbeitszeiten"."Arbeitszeit") as "Gesamtarbeitszeit",
+       count("Arbeitszeiten"."Datum")::bigint                                        AS "Arbeitstage",
-        count("Arbeitszeiten"."Datum")     as "Arbeitstage",
+       (sum("Arbeitszeiten"."Arbeitszeit") -
-        sum("Arbeitszeiten"."Arbeitszeit") - count("Arbeitszeiten"."Datum") ::double precision * '08:00:00'::interval as "Überstunden"
+        ((count("Arbeitszeiten"."Datum"))::double precision * '08:00:00'::interval)) AS "Überstunden",
-    from "Arbeitszeiten"
+       (count(*) filter (where "Arbeitszeiten"."HomeOffice"))::int                   as "Home-Office-Tage"
-    group by (date_part('year'::text, "Arbeitszeiten"."Datum"))
+from "Arbeitszeiten"
-    order by (date_part('year'::text, "Arbeitszeiten"."Datum"));
+group by (date_part('year'::text, "Arbeitszeiten"."Datum"))
+order by (date_part('year'::text, "Arbeitszeiten"."Datum"));

resources/test-data/report-1672928012.CSV

@@ -23,7 +23,7 @@ Arbeit;04:16;2021-07-22 07:55;2021-07-22 12:11;
 Arbeit;03:11;2021-07-21 13:37;2021-07-21 16:48;
 Mittagspause ;01:07;2021-07-21 12:29;2021-07-21 13:37;
 Arbeit;04:58;2021-07-21 07:31;2021-07-21 12:29;
-Arbeit;01:17;2021-07-20 18:44;2021-07-20 20:02;
+Verkehr;01:17;2021-07-20 18:44;2021-07-20 20:02;
 Arbeit;03:50;2021-07-20 13:14;2021-07-20 17:04;
 Mittagspause ;00:41;2021-07-20 12:32;2021-07-20 13:14;
 Arbeit;04:55;2021-07-20 07:37;2021-07-20 12:32;

ui/src/lib/Models.svelte.js

@@ -1,9 +1,10 @@
 export class PeriodRecord {
     /**
-     * @param {{ workingDays: Number; totalHours: any; overtime: string; period: string; }} record
+     * @param {{ workingDays: Number; totalHours: any; overtime: string; period: string; homeOfficeDays: Number }} record
      */
     constructor(record) {
         this.workingDays = Number(record.workingDays)
+        this.homeOfficeDays = Number(record.homeOfficeDays)
         this.totalHours = String(record.totalHours)
         this.period = String(record.period)
         this.overtime = String('##:##:##')

ui/src/lib/TablePagination.svelte

@@ -0,0 +1,72 @@
+<script lang="ts">
+    let {promise_data, actual_records= $bindable(), page_count = 10} = $props();
+    let records: Array<any[]> = $state([])
+    let page_number = $state(0)
+    let max_page_number = $state(0)
+    const setPage = (new_page: number) => {
+        page_number = new_page
+        actual_records = records[page_number - 1]
+    }
+    const init = async () => {
+        let page_records: any[] = []
+        console.log(promise_data, actual_records)
+        for (let index in promise_data) {
+            page_records.push(promise_data[index])
+            if (page_records.length >= page_count) {
+                records.push(page_records.values().toArray())
+                page_records = []
+            }
+        }
+        if (page_records.length > 0) {
+            records.push(page_records.values().toArray())
+        }
+        max_page_number = records.length
+        setPage(1)
+    }
+    init()
+</script>
+<style>
+    div.table-pagination {
+        text-align: center;
+    }
+
+    div.table-pagination > button {
+        display: inline-block;
+        width: 2rem;
+    }
+
+    div.table-pagination > button[disabled] {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+
+    div.table-pagination > span {
+        display: inline-block;
+        width: 5rem;
+        text-align: center;
+    }
+</style>
+
+<div class="table-pagination">
+    <button
+        type="button"
+        disabled={page_number === 1}
+        onclick={() => setPage(1)}>&ll;
+    </button>
+    <button
+        type="button"
+        disabled={page_number === 1}
+        onclick={() => setPage(page_number - 1)}>&lt;
+    </button>
+    <span>{page_number} von {max_page_number}</span>
+    <button
+        type="button"
+        disabled={page_number === max_page_number}
+        onclick={() => setPage(page_number + 1)}>&gt;
+    </button>
+    <button
+        type="button"
+        disabled={page_number === max_page_number}
+        onclick={() => setPage(max_page_number)}>&gg;
+    </button>
+</div>

ui/src/lib/Views.svelte

@@ -1,16 +1,16 @@
 <script>
     import {PeriodRecord} from './Models.svelte.js'
+    import TablePagination from "$lib/TablePagination.svelte";
 
-    /**
+    let { promise, title } = $props();
-     * @type {{ promise: Promise<object>; title: string;}}
-     */
-    let {params} = $props();
     /** @type PeriodRecord[] **/
     let records = $state([])
+    /** @type PeriodRecord[] **/
+    let actual_records = $state([])
     let isLoading = $state(true)
-    const init = async () => await params.promise.then(
+    const init = async () => await promise.then(
         /**
-         * @param {Array<object>} data
+         * @param {Array<{ workingDays: Number; totalHours: any; overtime: string; period: string; homeOfficeDays: Number; }>} data
          */
         data => {
             records = data.map(row => new PeriodRecord(row))
@@ -21,12 +21,12 @@
 </script>
 
 <svelte:head>
-    <title>{params.title}</title>
+    <title>{title}</title>
 </svelte:head>
 
 <section id="list-records">
     <header>
-        <h1>{params.title}</h1>
+        <h1>{title}</h1>
     </header>
     <article>
         {#if isLoading === true}
@@ -43,20 +43,29 @@
                 <tr>
                     <th>Zeitraum</th>
                     <th>Arbeitstage</th>
+                    <th>davon HomeOffice</th>
                     <th>Arbeitsstunden</th>
                     <th>Über- / Unterstunden</th>
                 </tr>
                 </thead>
                 <tbody>
-                {#each records as record}
+                {#each actual_records as record}
                     <tr>
                         <td>{record.period}</td>
                         <td>{record.workingDays}</td>
+                        <td>{record.homeOfficeDays}</td>
                         <td>{record.totalHours}</td>
                         <td class="{record.isMinus ? 'absence-time' : ''}">{record.overtime}</td>
                     </tr>
                 {/each}
                 </tbody>
+                <tfoot>
+                    <tr>
+                        <td colspan="4">
+                            <TablePagination promise_data={records} bind:actual_records={actual_records}/>
+                        </td>
+                    </tr>
+                </tfoot>
             </table>
         {/if}
     </article>

ui/src/routes/views/monthly/+page.svelte

@@ -3,5 +3,5 @@
     let { data } = $props();
 </script>
 
-<Views params={data}/>
+<Views {...data}/>
 

ui/src/routes/views/weekly/+page.svelte

@@ -3,5 +3,5 @@
     let { data } = $props();
 </script>
 
-<Views params={data}/>
+<Views {...data}/>
 

ui/src/routes/views/yearly/+page.svelte

@@ -3,5 +3,5 @@
     let { data } = $props();
 </script>
 
-<Views params={data}/>
+<Views {...data}/>
 

ui/src/routes/working-hours/+page.server.js

@@ -34,6 +34,7 @@ export const actions = {
         const body_data = {
             workingDay: data.get('workingDay'),
             workingTime: data.get('workingTime'),
+            isHomeOffice: data.get('isHomeOffice'),
         }
         await WorkingHoursRepository.update(env.API_URL, data.get('workingDay'), body_data);
     },
@@ -42,6 +43,7 @@ export const actions = {
         const body_data = {
             workingDay: form_data.get('workingDay'),
             workingTime: form_data.get('workingTime'),
+            isHomeOffice: form_data.get('isHomeOffice'),
         }
         await WorkingHoursRepository.add(env.API_URL, body_data);
     },
@@ -56,13 +58,19 @@ export const actions = {
             actualDayObject.setDate(actualDayObject.getDate() + 1)
         })
         for (const pair of form_data.entries()) {
-            const working_day = day_list[pair[0]] ?? null
+            let key = /(?<day>\w+)\[time]/.exec(pair[0])
-            if (working_day === null) {
+            if (key === null) {
+                continue
+            }
+            let day = key?.groups?.day ?? ''
+            const working_day = day_list[day] ?? null
+            if (working_day === null || pair[1] === '00:00:00' || pair[1] === '00:00') {
                 continue
             }
             const body_data = {
                 workingDay: working_day,
                 workingTime: pair[1],
+                isHomeOffice: form_data.has(day + '[isHomeOffice]')
             }
             await WorkingHoursRepository.addOrUpdate(env.API_URL, working_day, body_data);
         }
@@ -70,10 +78,15 @@ export const actions = {
     'import-csv': async ({ request }) => {
         const form_data = await request.formData();
         for (const pair of form_data.entries()) {
-            const working_day = pair[0]
+            let key = /^(?<day>\d{4}-\d{2}-\d{2})\[time]$/.exec(pair[0])
+            if (key === null) {
+                continue
+            }
+            let working_day = key?.groups?.day ?? ''
             const body_data = {
                 workingDay: working_day,
                 workingTime: pair[1],
+                isHomeOffice: form_data.has(working_day + '[isHomeOffice]')
             }
             await WorkingHoursRepository.addOrUpdate(env.API_URL, working_day, body_data);
         }

ui/src/routes/working-hours/+page.svelte

@@ -2,13 +2,16 @@
     import documentIcon from "@iconify-icons/oi/document.js";
     import wrenchIcon from "@iconify-icons/oi/wrench.js";
     import IconifyIcon from "@iconify/svelte";
+    import TablePagination from "$lib/TablePagination.svelte";
     let { data } = $props();
     const TITLE = "Bearbeitung Einträge"
-    /** @type {{workingDay: String, workingTime: String, }[]|null} **/
+    /** @type {{workingDay: String, workingTime: String, isHomeOffice: Boolean, }[]|null} **/
-    let records = $state([])
+    let records = $state(null)
+    /** @type {{workingDay: String, workingTime: String, isHomeOffice: Boolean, }[]} **/
+    let actual_records = $state([])
     const init = async () => await data.promise.then(
         /**
-         * @param {{workingDay: String, workingTime: String, }[]} data
+         * @param {{workingDay: String, workingTime: String, isHomeOffice: Boolean, }[]} data
          */
         data => {
             records = data
@@ -53,14 +56,16 @@
                     <tr>
                         <th>Datum</th>
                         <th>Arbeitsstunden</th>
+                        <th>Zu Hause gearbeitet?</th>
                         <th>Aktionen</th>
                     </tr>
                     </thead>
                     <tbody>
-                    {#each records as record}
+                    {#each actual_records as record}
-                        <tr>
+                        <tr style="{record.isHomeOffice ? 'background: aqua' : ''}">
                             <td>{record.workingDay}</td>
                             <td>{record.workingTime}</td>
+                            <td>{record.isHomeOffice ? 'ja' : ''}</td>
                             <td>
                                 <button formaction={'/working-hours/' + record.workingDay} type="submit">Bearbeiten
                                     <IconifyIcon icon={wrenchIcon}/>
@@ -69,6 +74,13 @@
                         </tr>
                     {/each}
                     </tbody>
+                    <tfoot>
+                    <tr>
+                        <td colspan="4">
+                            <TablePagination promise_data={records} bind:actual_records={actual_records} page_count={15}/>
+                        </td>
+                    </tr>
+                    </tfoot>
                 </table>
             {/if}
         </form>

ui/src/routes/working-hours/[working_day]/+page.svelte

@@ -4,11 +4,11 @@
     import xIcon from "@iconify-icons/oi/x";
     let { data } = $props();
     const TITLE = "Bearbeitung eines Eintrags"
-    /** @type {{workingDay: String, workingTime: String, }|null} **/
+    /** @type {{workingDay: String, workingTime: String, isHomeOffice: Boolean, }|null} **/
     let activeDate = $state(null)
     const init = async () => await data.promise.then(
         /**
-         * @param {{workingDay: String, workingTime: String, }} data
+         * @param {{workingDay: String, workingTime: String, isHomeOffice: Boolean, }} data
          */
         data => {
             activeDate = data
@@ -42,6 +42,10 @@
                                value="{activeDate.workingTime}"
                                id="workingTime" required pattern="[0-5]\d:[0-5]\d:[0-5]\d">
                     </div>
+                    <div>
+                        <label for="isHomeOffice">Arbeitszeit</label>
+                        <input name="isHomeOffice" type="checkbox" checked={activeDate.isHomeOffice} id="isHomeOffice">
+                    </div>
                 </fieldset>
             {/if}
             <fieldset name="buttons">

ui/src/routes/working-hours/create-by-day/+page.svelte

@@ -29,6 +29,10 @@
                     <input name="workingTime" placeholder="Arbeitszeit" type="time" step="1" value=""
                            id="workingTime" required pattern="[0-5]\d:[0-5]\d:[0-5]\d">
                 </div>
+                <div>
+                    <label for="isHomeOffice">Arbeitszeit</label>
+                    <input name="isHomeOffice" type="checkbox" id="isHomeOffice">
+                </div>
             </fieldset>
             <fieldset name="buttons">
                 <button type="submit">Übernehmen und Weiter

ui/src/routes/working-hours/create-by-week/+page.svelte

@@ -14,6 +14,22 @@
     tbody.weekend td input, tbody.weekend td {
         color: red;
     }
+    tbody.weekend label {
+        color: initial;
+    }
+
+    section form fieldset div input {
+        display: inline-block;
+        padding: 0.25rem;
+        border-style: solid;
+        border-width: thin;
+    }
+
+    section form fieldset div input[type=checkbox] {
+        display: inline-block;
+        width: auto;
+        margin: 0 1rem 1.0rem;
+    }
 </style>
 
 
@@ -39,10 +55,19 @@
                                     {day}
                                 </td>
                                 <td>
-                                    <input name="{day}" value="08:00:00" type="time" step="1"
+                                    <input name="{day}[time]" value="08:00:00" type="time" step="1"
                                            required pattern="[0-5]\d:[0-5]\d:[0-5]\d">
                                 </td>
                             </tr>
+                            <tr>
+                                <td>
+                                </td>
+                                <td>
+                                    <label>wurde zu Hause gearbeitet?
+                                        <input name="{day}[isHomeOffice]" type="checkbox">
+                                    </label>
+                                </td>
+                            </tr>
                         {/each}
                         </tbody>
                         <tbody class="weekend">
@@ -52,10 +77,19 @@
                                     {day}
                                 </td>
                                 <td>
-                                    <input name="{day}" value="00:00:00" type="time" step="1"
+                                    <input name="{day}[time]" value="00:00:00" type="time" step="1"
                                            required pattern="[0-5]\d:[0-5]\d:[0-5]\d">
                                 </td>
                             </tr>
+                            <tr>
+                                <td>
+                                </td>
+                                <td>
+                                    <label>wurde zu Hause gearbeitet?
+                                        <input name="{day}[isHomeOffice]" type="checkbox">
+                                    </label>
+                                </td>
+                            </tr>
                         {/each}
                         </tbody>
                     </table>

ui/src/routes/working-hours/import-csv/+page.svelte

@@ -8,7 +8,7 @@
 
     const TITLE = "Erstellung neuer Einträge für eine Woche"
 
-    /** @type {{ workingTime: String, workingDay: String, }[]} **/
+    /** @type {{ workingTime: String, workingDay: String, isHomeOffice: Boolean, }[]} **/
     let imported_data = $state([])
 
 
@@ -30,6 +30,8 @@
             complete: results => {
                 /** @type {Object<String, Number>} **/
                 let cash_work_days = {}
+                /** @type {Object<String, Boolean>} **/
+                let home_office_days = {}
                 results.data.forEach(
                     /** @param {Object<String, any>} item **/
                     item => {
@@ -42,6 +44,9 @@
                         let work_to = new Date(item['Bis'])
                         let actual_day = work_from.toISOString().substring(0, 10)
                         let actual_work_hours = (work_to.getTime() - work_from.getTime()) / (1000 * 60 * 60)
+                        if (activity.trim() === 'Verkehr') {
+                            home_office_days[actual_day] = true
+                        }
                         cash_work_days[actual_day] ??= 0
                         cash_work_days[actual_day] += actual_work_hours
                     }
@@ -52,7 +57,11 @@
                     let minutes_digits = Math.round((hours - hours_digits) * 60)
                     let working_time = String(hours_digits).padStart(2, '0') + ':'
                         + String(minutes_digits).padStart(2, '0') + ':00'
-                    imported_data.push({workingTime: working_time, workingDay: day})
+                    imported_data.push({
+                        workingTime: working_time,
+                        workingDay: day,
+                        isHomeOffice: home_office_days[day] ?? false,
+                    })
                 }
             },
         })
@@ -90,7 +99,10 @@
                                         {item.workingDay}
                                     </td>
                                     <td>
-                                        <input type="time" readonly name="{item.workingDay}" value="{item.workingTime}">
+                                        <input type="time" readonly name="{item.workingDay}[time]" value="{item.workingTime}">
+                                    </td>
+                                    <td>
+                                        <input type="checkbox" readonly name="{item.workingDay}[isHomeOffice]" checked={item.isHomeOffice}>
                                     </td>
                                 </tr>
                             {/each}