Feature: Es wird beachtet, dass es schon vorhandene Daten geben kann

ui/src/components/Repositories.svelte

@@ -1,28 +1,10 @@
 <script context="module">
     const MyFetch = {
         'post': async (rest_url, request_body) => {
-            return MyFetch._fetch(rest_url, {
+            return MyFetch._fetch(rest_url, MyFetch._buildRequestOptions(request_body), {})
-                method: 'POST',
-                mode: 'cors',
-                cache: 'no-cache',
-                credentials: 'omit',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: request_body,
-            }, {})
         },
         'put': async (rest_url, http_body) => {
-            return MyFetch._fetch(rest_url, {
+            return MyFetch._fetch(rest_url, MyFetch._buildRequestOptions(http_body, true), {})
-                method: 'PUT',
-                mode: 'cors',
-                cache: 'no-cache',
-                credentials: 'omit',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: http_body,
-            }, {})
         },
         'get': async (rest_url, query_parameters) => {
             if (query_parameters !== null) {
@@ -38,14 +20,30 @@
         },
         '_fetch': async (rest_url, request_options) => {
             // noinspection JSUnresolvedVariable
-            let response = await fetch(env.API_URL + rest_url, request_options).catch(err => {
+            let response = await MyFetch._pureFetch(rest_url, request_options)
-                console.error(err)
-                return null
-            })
             if (!response.ok) {
                 throw new Error('Fail!')
             }
             return response.json()
+        },
+        '_buildRequestOptions': (request_body, needPut) => {
+            return {
+                method: (needPut === true) ? 'PUT' : 'POST',
+                mode: 'cors',
+                cache: 'no-cache',
+                credentials: 'omit',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: request_body,
+            }
+        },
+        '_pureFetch': async (rest_url, request_options) => {
+            // noinspection JSUnresolvedVariable
+            return await fetch(env.API_URL + rest_url, request_options).catch(err => {
+                console.error(err)
+                return null
+            })
         }
     }
 
@@ -58,6 +56,16 @@
             return MyFetch.get('/working-hours/' + date)
         },
 
+        'readOrNew': async date => {
+            let response = await MyFetch._pureFetch('/working-hours/' + date)
+            if (response.status === 404) {
+                return {workingTime: '00:00:00', workingDay: date}
+            } else if (!response.ok) {
+                throw new Error('Fail!')
+            }
+            return response.json()
+        },
+
         'add': async (record) => {
             console.debug(record);
             return MyFetch.post('/working-hours', JSON.stringify(record))
@@ -66,6 +74,18 @@
         'update': async (date, record) => {
             console.debug(record);
             return MyFetch.put('/working-hours/' + date, JSON.stringify(record))
+        },
+
+        'addOrUpdate': async (date, record) => {
+            console.debug(record);
+            let request_options = MyFetch._buildRequestOptions(JSON.stringify(record))
+            let response = await MyFetch._pureFetch('/working-hours', request_options)
+            if (response.status === 409) {
+                return WorkingHoursRepository.update(date, record)
+            } else if (!response.ok) {
+                throw new Error('Fail!')
+            }
+            return response.json()
         }
     }
 

ui/src/routes/WorkingHours/Formular.svelte

@@ -9,20 +9,14 @@
     export let newRecord = false
     const Controller = {
         'saveRecord': () => {
-            if (newRecord === true) {
+            WorkingHoursRepository.addOrUpdate(activeRecord.workingDay, activeRecord).then(() => {
-                WorkingHoursRepository.add(activeRecord).then(() => {
                 Controller.nextDay()
             });
-            } else {
-                WorkingHoursRepository.update(activeRecord.workingDay, activeRecord).then(() => {
-                    Controller.nextDay()
-                });
-            }
         },
         'nextDay': () => {
             let actDate = new TimekeepingDate(activeRecord.workingDay)
             let nextDay = actDate.getNextDay()
-            activeRecord = {workingTime: '00:00:00', workingDay: nextDay.getDateString()}
+            activeRecord = WorkingHoursRepository.readOrNew(nextDay.getDateString())
         },
         'cancelActiveRecord': () => {
             activeRecord = null;

ui/src/routes/WorkingHours/List.svelte

@@ -21,8 +21,7 @@
         },
         'newRecord': () => {
             const actDate = new TimekeepingDate()
-            activeRecord = {workingTime: '00:00:00', workingDay: actDate.getDateString()}
+            activeRecord = WorkingHoursRepository.readOrNew(actDate.getDateString())
-            newRecord = true;
         },
         'selectActiveRecord': record => WorkingHoursRepository.read(record.workingDay).then(data => {
             if (data === null) {