diff --git a/zmsadmin/js/page/availabilityDay/form/conflicts.js b/zmsadmin/js/page/availabilityDay/form/conflicts.js
index 6b088d16d..00285a2a7 100644
--- a/zmsadmin/js/page/availabilityDay/form/conflicts.js
+++ b/zmsadmin/js/page/availabilityDay/form/conflicts.js
@@ -11,26 +11,31 @@ const renderConflictList = (conflictList) => {
     let conflictDatesByMessage = [];
     conflictList.map(collection => {
         collection.conflicts.map((conflict) => {
-            if (! conflictDatesByMessage[conflict.message]) {
-                Object.assign({}, conflictDatesByMessage[conflict.message] = []);
+            const existingConflict = conflictDatesByMessage.find(
+                item => item.message === conflict.message
+            );
+
+            if (existingConflict) {
+                existingConflict.dates.push(formatDate(collection.date));
+            } else {
+                conflictDatesByMessage.push({
+                    message: conflict.message,
+                    dates: [formatDate(collection.date)]
+                });
             }
-            conflictDatesByMessage[conflict.message].push(formatDate(collection.date))
-        })
-    })
+        });
+    });
 
     return (
-        Object.keys(conflictDatesByMessage).map((key, index) => {
-            return (
-                <div key={index}>
-                    <div><strong>{ conflictDatesByMessage[key].join(", ")  }</strong></div>
-                    <div key={index}>- {key}</div>
-                </div>
-            )
-        })
-    )
-    
-    
-}
+        conflictDatesByMessage.map((item, index) => (
+            <div key={index} style={{ marginBottom: '1rem' }}>
+                {/* Convert newlines in the message to <br /> tags */}
+                <div dangerouslySetInnerHTML={{ __html: item.message.replace(/\n/g, '<br />') }} />
+            </div>
+        ))
+    );
+};
+
 
 const Conflicts = (props) => {
     const conflicts = Object.keys(props.conflictList).map(key => {
diff --git a/zmsadmin/js/page/availabilityDay/form/content.js b/zmsadmin/js/page/availabilityDay/form/content.js
index fa34800e7..9583deb40 100644
--- a/zmsadmin/js/page/availabilityDay/form/content.js
+++ b/zmsadmin/js/page/availabilityDay/form/content.js
@@ -9,50 +9,121 @@ import ErrorBar from '../errorBar'
 
 const FormContent = (props) => {
     const {
-        availabilityList, 
-        data, 
-        errorList, 
+        availabilityList,
+        data,
+        errorList,
         conflictList,
-        onChange, 
-        today, 
+        onChange,
+        today,
         setErrorRef
     } = props;
-    
+
+    const hasEndTimePastError = Object.values(errorList)
+        .some(error => error.itemList?.[0]?.[0]?.type === 'endTimePast');
     const calenderDisabled = data.type && data.slotTimeInMinutes ? false : true;
+    const inputDisabled = hasEndTimePastError || calenderDisabled;
+
     const isUnsafedSpontaneous = data.id == 0;
 
+    const filteredErrorList = Object.values(errorList)
+        .filter(error => error.itemList?.[0]?.[0]?.type !== 'endTimePast')
+        .reduce((acc, error) => {
+            acc[error.id] = error;
+            return acc;
+        }, {});
+
     return (
         <div>
-            <ErrorBar errorList={errorList} conflictList={conflictList} setErrorRef={setErrorRef} />
             <form className="form--base">
+                <ErrorBar errorList={filteredErrorList} conflictList={conflictList} setErrorRef={setErrorRef} />
                 <fieldset>
-                    {isUnsafedSpontaneous ? 
-                    <div className="message message-info">
-                        Diese Öffnungszeit ist eine mit einer Termin-Öffnungszeit verbundenen Spontankunden-Öffnungszeit und hat noch keine eigene ID. Sie können diese Öffnungszeit erst einzeln aktualisieren, wenn sie die dazugehörige Termin-Öffnungszeit mit einmal initial aktualisiert haben.
-                    </div> : null
+                    {isUnsafedSpontaneous ?
+                        <section
+                            style={{
+                                position: 'relative',
+                                borderColor: '#cccccc',
+                                margin: '20px auto'
+                            }}
+                            className="dialog message"
+                            role="alert"
+                        >
+                            <div style={{
+                                position: 'absolute',
+                                top: '-15px',
+                                left: '7px',
+                                backgroundColor: '#fcaa67',
+                                width: '30px',
+                                height: '30px',
+                                display: 'flex',
+                                justifyContent: 'center',
+                                alignItems: 'center'
+                            }}>
+                                <i className="fas fa-exclamation-circle" title="Wichtiger Hinweis" aria-hidden="true" style={{ color: 'white' }} />
+                            </div>
+                            <h2 className="message__heading">Hinweis zur Termin-Öffnungszeit</h2>
+                            <div className="message__body">
+                                Diese Öffnungszeit ist eine mit einer Termin-Öffnungszeit verbundenen Spontankunden-Öffnungszeit und hat noch keine eigene ID. Sie können diese Öffnungszeit erst einzeln aktualisieren, wenn sie die dazugehörige Termin-Öffnungszeit mit einmal initial aktualisiert haben.
+                            </div>
+                        </section> : null
                     }
+                    {hasEndTimePastError && Object.values(errorList).map(error => {
+                        const endTimePastError = error.itemList?.[0]?.[0];
+                        if (endTimePastError?.type === 'endTimePast') {
+                            return (
+                                <section
+                                    key={error.id}
+                                    style={{
+                                        position: 'relative',
+                                        borderColor: '#cccccc',
+                                        margin: '20px auto'
+                                    }}
+                                    className="dialog message"
+                                    role="alert"
+                                >
+                                    <div style={{
+                                        position: 'absolute',
+                                        top: '-15px',
+                                        left: '7px',
+                                        backgroundColor: '#fcaa67',
+                                        width: '30px',
+                                        height: '30px',
+                                        display: 'flex',
+                                        justifyContent: 'center',
+                                        alignItems: 'center'
+                                    }}>
+                                        <i className="fas fa-exclamation-circle" title="Wichtiger Hinweis" aria-hidden="true" style={{ color: 'white' }} />
+                                    </div>
+                                    <h2 className="message__heading">Öffnungszeit liegt in der Vergangenheit</h2>
+                                    <div className="message__body">
+                                        {endTimePastError.message}
+                                    </div>
+                                </section>
+                            );
+                        }
+                        return null;
+                    })}
                     <div className="panel--heavy">
                         <FormGroup>
-                            <Label attributes={{"htmlFor": "AvDayDescription"}}>Anmerkung</Label> 
+                            <Label attributes={{ "htmlFor": "AvDayDescription" }}>Anmerkung</Label>
                             <Controls>
-                                <Inputs.Text 
-                                    attributes={{ "id": "AvDayDescription", "aria-describedby": "help_AvDayDescription" }}
-                                    name="description" 
-                                    value={data.description} 
-                                    {...{ onChange }} 
+                                <Inputs.Text
+                                    attributes={{ "id": "AvDayDescription", "aria-describedby": "help_AvDayDescription", "disabled": inputDisabled }}
+                                    name="description"
+                                    value={data.description}
+                                    {...{ onChange }}
                                 />
                                 <Description attributes={{ "id": "help_AvDayDescription" }}>Optionale Angabe zur Kennzeichnung des Termins. {data.id > 0 ? "Die ID der Öffnungszeit ist " + data.id : " Die Öffnungszeit hat noch keine ID"}.
                                 </Description>
                             </Controls>
                         </FormGroup>
                         <FormGroup>
-                            <Label attributes={{"htmlFor": "AvDayType"}}>Typ</Label>
+                            <Label attributes={{ "htmlFor": "AvDayType" }}>Typ</Label>
                             <Controls>
                                 <Inputs.Select name="type"
                                     attributes={{ disabled: data.id ? 'disabled' : null, "id": "AvDayType" }}
                                     value={data.type ? data.type : "appointment"} {...{ onChange }}
                                     options={availabilityTypes} />
-                                    <Description attributes={{ "id": "help_AvDayTypDescription" }}>Typ der Öffnungszeit.
+                                <Description attributes={{ "id": "help_AvDayTypDescription" }}>Typ der Öffnungszeit.
                                 </Description>
                             </Controls>
                         </FormGroup>
@@ -62,23 +133,24 @@ const FormContent = (props) => {
                     <div className="panel--heavy">
                         <legend className="label">Serie und Wochentage</legend>
                         <FormGroup>
-                            <Label attributes={{"htmlFor": "AvDaySeries", "className": "light"}}>Serie</Label>
+                            <Label attributes={{ "htmlFor": "AvDaySeries", "className": "light" }}>Serie</Label>
                             <Controls>
-                                <Inputs.Select 
+                                <Inputs.Select
                                     name="repeat"
-                                    attributes={{ "id": "AvDaySeries" }} 
+                                    attributes={{ "id": "AvDaySeries", "disabled": inputDisabled }}
                                     value={data.repeat} {...{ onChange }}
                                     options={availabilitySeries} />
                             </Controls>
                         </FormGroup>
                         <FormGroup>
-                            <Label attributes={{"className": "light"}}>Wochentage</Label>
+                            <Label attributes={{ "className": "light" }}>Wochentage</Label>
                             <Controls>
                                 <Inputs.CheckboxGroup name="weekday"
                                     value={data.weekday}
                                     inline={true}
                                     {...{ onChange }}
                                     boxes={weekDayList}
+                                    attributes={{ "disabled": inputDisabled }}
                                     disabled={!data.repeat ? true : false}
                                 />
                             </Controls>
@@ -88,47 +160,47 @@ const FormContent = (props) => {
                 <fieldset>
                     <div className="panel--heavy">
                         <legend className="label">Terminabstand</legend>
-                        <FormGroup inline={true}>    
+                        <FormGroup inline={true}>
                             <Controls>
                                 <Inputs.Text name="slotTimeInMinutes"
                                     value={data.slotTimeInMinutes}
                                     width="2"
                                     attributes={{ disabled: 'disabled', maxLength: 3, "id": "AvDaySlottime" }}
                                     {...{ onChange }} />
-                                <Label attributes={{"htmlFor": "AvDaySlottime", "className": "light"}}>&nbsp;Minuten Abstand zweier aufeinander folgender Termine</Label>
+                                <Label attributes={{ "htmlFor": "AvDaySlottime", "className": "light" }}>&nbsp;Minuten Abstand zweier aufeinander folgender Termine</Label>
                             </Controls>
                         </FormGroup>
-                        <FormGroup inline={true}>    
+                        <FormGroup inline={true}>
                             <Controls>
                                 <Inputs.Checkbox name="multipleSlotsAllowed"
-                                    checked={"1" == data.multipleSlotsAllowed} {...{ onChange }} 
+                                    checked={"1" == data.multipleSlotsAllowed} {...{ onChange }}
                                     value="1"
-                                    attributes={{ "id": "AvDayMultipleSlots" }}
+                                    attributes={{ "id": "AvDayMultipleSlots", "disabled": inputDisabled }}
                                 />
-                                <Label attributes={{"htmlFor": "AvDayMultipleSlots", "className": "light"}}>Die Dienstleistungen dürfen mehr als einen Zeitschlitz beanspruchen</Label>
+                                <Label attributes={{ "htmlFor": "AvDayMultipleSlots", "className": "light" }}>Die Dienstleistungen dürfen mehr als einen Zeitschlitz beanspruchen</Label>
                             </Controls>
                         </FormGroup>
                     </div>
                 </fieldset>
-                
+
                 <fieldset>
                     <div className="panel--heavy">
                         <legend className="label">Öffnungszeit</legend>
                         <AvailabilityDatePicker attributes={{
-                            "id": "AvDatesStart", 
+                            "id": "AvDatesStart",
                             "availabilitylist": availabilityList,
                             "availability": getDataValuesFromForm(data, data.scope),
                             "today": today,
                             "kind": data.kind,
-                            "disabled": calenderDisabled
+                            "disabled": inputDisabled
                         }} name="startDate" {...{ onChange }} />
                         <AvailabilityDatePicker attributes={{
-                            "id": "AvDatesEnd", 
+                            "id": "AvDatesEnd",
                             "availabilitylist": availabilityList,
                             "availability": getDataValuesFromForm(data, data.scope),
                             "today": today,
                             "kind": data.kind,
-                            "disabled": calenderDisabled
+                            "disabled": inputDisabled
                         }} name="endDate" {...{ onChange }} />
                     </div>
                 </fieldset>
@@ -138,20 +210,20 @@ const FormContent = (props) => {
                         <legend className="label">Buchbar</legend>
                         <FormGroup inline={true}>
                             <Controls>
-                                <Label attributes={{"htmlFor": "AvDayOpenfrom", "className": "light"}}>von</Label> 
+                                <Label attributes={{ "htmlFor": "AvDayOpenfrom", "className": "light" }}>von</Label>
                                 <Inputs.Text name="open_from"
-                                    width="2"
+                                    width="3"
                                     value={data.open_from}
-                                    attributes={{ placeholder: data.scope.preferences.appointment.startInDaysDefault, "id": "AvDayOpenfrom", "aria-describedby": "help_AvDayOpenfromto" }}
+                                    attributes={{ placeholder: data.scope.preferences.appointment.startInDaysDefault, "id": "AvDayOpenfrom", "aria-describedby": "help_AvDayOpenfromto", "disabled": inputDisabled }}
                                     {...{ onChange }}
                                 />
                             </Controls>
                             <Controls>
-                                <Label attributes={{"htmlFor": "AvDayOpento", "className": "light"}}>bis</Label> 
-                                    <Inputs.Text name="open_to"
-                                    width="2"
+                                <Label attributes={{ "htmlFor": "AvDayOpento", "className": "light" }}>bis</Label>
+                                <Inputs.Text name="open_to"
+                                    width="3"
                                     value={data.open_to}
-                                    attributes={{ placeholder: data.scope.preferences.appointment.endInDaysDefault, "id": "AvDayOpento", "aria-describedby": "help_AvDayOpenfromto" }}
+                                    attributes={{ placeholder: data.scope.preferences.appointment.endInDaysDefault, "id": "AvDayOpento", "aria-describedby": "help_AvDayOpenfromto", "disabled": inputDisabled }}
                                     {...{ onChange }}
                                 />
                                 <span aria-hidden="true"> Tage im voraus</span>
@@ -161,69 +233,69 @@ const FormContent = (props) => {
                     </div>
                 </fieldset>
                 {data.type !== 'openinghours' ?
-                <fieldset>
-                    <div className="panel--heavy">
-                        <legend>Terminarbeitsplätze</legend>
-                        <div>
-                            <FormGroup>
-                                <Label attributes={{"htmlFor": "WsCountIntern"}}>Insgesamt</Label>
-                                <Controls>
-                                    <Inputs.Select name="workstationCount_intern"
-                                        value={data.workstationCount_intern}
-                                        attributes={{"id": "WsCountIntern"}}
-                                        {...{ onChange }}
-                                        options={range(0, 50).map(n => {
-                                            let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
-                                            return {
-                                                title: `${n} ${workstation}`,
-                                                value: `${n}`,
-                                                name: `${n} ${workstation}`
-                                            }
-                                        })} />
-                                </Controls>
-                            </FormGroup>
+                    <fieldset>
+                        <div className="panel--heavy">
+                            <legend>Terminarbeitsplätze</legend>
+                            <div>
+                                <FormGroup>
+                                    <Label attributes={{ "htmlFor": "WsCountIntern" }}>Insgesamt</Label>
+                                    <Controls>
+                                        <Inputs.Select name="workstationCount_intern"
+                                            value={data.workstationCount_intern}
+                                            attributes={{ "id": "WsCountIntern", "disabled": inputDisabled }}
+                                            {...{ onChange }}
+                                            options={range(0, 50).map(n => {
+                                                let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
+                                                return {
+                                                    title: `${n} ${workstation}`,
+                                                    value: `${n}`,
+                                                    name: `${n} ${workstation}`
+                                                }
+                                            })} />
+                                    </Controls>
+                                </FormGroup>
 
-                            <FormGroup>
-                                <Label attributes={{"htmlFor": "WsCountCallcenter"}}>Callcenter</Label>
-                                <Controls>
-                                    <Inputs.Select name="workstationCount_callcenter"
-                                        value={data.workstationCount_callcenter}
-                                        attributes={{"id": "WsCountCallcenter", "aria-describedby": "help_WsCountCallcenter"}}
-                                        {...{ onChange }}
-                                        options={range(0, data.workstationCount_intern).map(n => {
-                                            let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
-                                            return {
-                                                title: `${n} ${workstation}`,
-                                                value: `${n}`,
-                                                name: `${n} ${workstation}`
-                                            }
-                                        })} />
-                                    <Description attributes={{"id": "help_WsCountCallcenter"}}>Wieviele der insgesamt verfügbaren Terminarbeitsplätze sollen für das Callcenter zur Verfügung gestellt werden.</Description>
-                                </Controls>
-                            </FormGroup>
+                                <FormGroup>
+                                    <Label attributes={{ "htmlFor": "WsCountCallcenter" }}>Callcenter</Label>
+                                    <Controls>
+                                        <Inputs.Select name="workstationCount_callcenter"
+                                            value={data.workstationCount_callcenter}
+                                            attributes={{ "id": "WsCountCallcenter", "aria-describedby": "help_WsCountCallcenter", "disabled": inputDisabled }}
+                                            {...{ onChange }}
+                                            options={range(0, data.workstationCount_intern).map(n => {
+                                                let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
+                                                return {
+                                                    title: `${n} ${workstation}`,
+                                                    value: `${n}`,
+                                                    name: `${n} ${workstation}`
+                                                }
+                                            })} />
+                                        <Description attributes={{ "id": "help_WsCountCallcenter" }}>Wieviele der insgesamt verfügbaren Terminarbeitsplätze sollen für das Callcenter zur Verfügung gestellt werden.</Description>
+                                    </Controls>
+                                </FormGroup>
 
-                            <FormGroup>
-                                <Label attributes={{"htmlFor": "WsCountPublic"}}>Internet</Label>
-                                <Controls>
-                                    <Inputs.Select name="workstationCount_public"
-                                        value={data.workstationCount_public}
-                                        attributes={{"id": "WsCountPublic", "aria-describedby": "help_WsCountPublic"}}
-                                        {...{ onChange }}
-                                        options={range(0, data.workstationCount_intern).map(n => {
-                                            let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
-                                            return {
-                                                title: `${n} ${workstation}`,
-                                                value: `${n}`,
-                                                name: `${n} ${workstation}`
-                                            }
-                                        })} />
-                                    <Description attributes={{"htmlFor": "help_WsCountPublic"}}>Wieviele der insgesamt verfügbaren Terminarbeitsplätze sollen für das Internet zur Verfügung gestellt werden.</Description>
-                                </Controls>
-                            </FormGroup>
+                                <FormGroup>
+                                    <Label attributes={{ "htmlFor": "WsCountPublic" }}>Internet</Label>
+                                    <Controls>
+                                        <Inputs.Select name="workstationCount_public"
+                                            value={data.workstationCount_public}
+                                            attributes={{ "id": "WsCountPublic", "aria-describedby": "help_WsCountPublic", "disabled": inputDisabled }}
+                                            {...{ onChange }}
+                                            options={range(0, data.workstationCount_intern).map(n => {
+                                                let workstation = (n == 1) ? "Arbeitsplatz" : "Arbeitsplätze";
+                                                return {
+                                                    title: `${n} ${workstation}`,
+                                                    value: `${n}`,
+                                                    name: `${n} ${workstation}`
+                                                }
+                                            })} />
+                                        <Description attributes={{ "htmlFor": "help_WsCountPublic" }}>Wieviele der insgesamt verfügbaren Terminarbeitsplätze sollen für das Internet zur Verfügung gestellt werden.</Description>
+                                    </Controls>
+                                </FormGroup>
+                            </div>
                         </div>
-                    </div>
-                </fieldset>
-                : null}
+                    </fieldset>
+                    : null}
             </form>
         </div>
     )
diff --git a/zmsadmin/js/page/availabilityDay/form/datepicker.js b/zmsadmin/js/page/availabilityDay/form/datepicker.js
index 22b13c683..4e117a209 100644
--- a/zmsadmin/js/page/availabilityDay/form/datepicker.js
+++ b/zmsadmin/js/page/availabilityDay/form/datepicker.js
@@ -124,34 +124,72 @@ class AvailabilityDatePicker extends Component
         if (this.state.kind === 'exclusion') {
             return;
         }
-        var times = []
-        this.state.availabilityList.map(availability => {
-            if (availability.id !== this.state.availability.id &&
+        var times = [];
+        
+        // Add maintenance window times (23:00-01:00)
+        const selectedDate = moment(this.state.selectedDate);
+        for (let minute = 1; minute < 60; minute++) {
+            times.push(selectedDate.clone().hour(23).minute(minute).toDate());
+        }
+        for (let minute = 0; minute < 59; minute++) {
+            times.push(selectedDate.clone().hour(0).minute(minute).toDate());
+        }
+    
+        // Filter and sort availabilities
+        const availabilities = [...this.state.availabilityList]
+            .filter(availability => 
+                availability.id !== this.state.availability.id &&
                 availability.type == this.state.availability.type &&
                 this.isWeekDaySelected(this.state.selectedDate, availability)
-            ) {
-                const startTime = moment(availability.startTime, 'hh:mm')
-                    .add(this.state.availability.slotTimeInMinutes, "m");
-                const startOnDay = moment(this.state.selectedDate)
-                    .set({"h": startTime.hours(), "m": startTime.minutes()})
-                    .toDate()
-                
-                const endTime = moment(availability.endTime, 'hh:mm')
-                    .subtract(this.state.availability.slotTimeInMinutes, "m");
-                const endOnDay = moment(this.state.selectedDate)
-                    .set({"h": endTime.hours(), "m": endTime.minutes()})
-                    .toDate()
-               
-                var currentTime = new Date(startOnDay)
-                while (currentTime < endOnDay) {
-                    times = [...times, new Date(currentTime)]
-                    currentTime = moment(currentTime)
-                        .add(this.state.availability.slotTimeInMinutes, "m")
-                        .toDate()
-                }
-                times = [...times, endOnDay]
+            )
+            .sort((a, b) => {
+                const timeA = moment(a.startTime, 'HH:mm');
+                const timeB = moment(b.startTime, 'HH:mm');
+                return timeA.diff(timeB);
+            });
+    
+        // Add regular excluded times
+        availabilities.forEach(availability => {
+            const startTime = moment(availability.startTime, 'hh:mm')
+                .add(this.state.availability.slotTimeInMinutes, "m");
+            const startOnDay = moment(this.state.selectedDate)
+                .set({"h": startTime.hours(), "m": startTime.minutes()})
+                .toDate();
+            
+            const endTime = moment(availability.endTime, 'hh:mm')
+                .subtract(this.state.availability.slotTimeInMinutes, "m");
+            const endOnDay = moment(this.state.selectedDate)
+                .set({"h": endTime.hours(), "m": endTime.minutes()})
+                .toDate();
+            
+            var currentTime = new Date(startOnDay);
+            while (currentTime < endOnDay) {
+                times.push(new Date(currentTime));
+                currentTime = moment(currentTime)
+                    .add(this.state.availability.slotTimeInMinutes, "m")
+                    .toDate();
             }
+            times.push(endOnDay);
         });
+    
+        // Add boundary timestamps between adjacent availabilities
+        for (let i = 0; i < availabilities.length - 1; i++) {
+            const current = availabilities[i];
+            const next = availabilities[i + 1];
+            
+            const currentEnd = moment(current.endTime, 'HH:mm');
+            const nextStart = moment(next.startTime, 'HH:mm');
+            
+            // If they're adjacent (end time of one equals start time of next)
+            if (currentEnd.format('HH:mm') === nextStart.format('HH:mm')) {
+                // Add the boundary timestamp to excluded times
+                const boundaryTime = moment(this.state.selectedDate)
+                    .set({"h": currentEnd.hours(), "m": currentEnd.minutes()})
+                    .toDate();
+                times.push(boundaryTime);
+            }
+        }
+    
         this.setState({excludeTimeList: times});
     }
 
@@ -256,13 +294,23 @@ class AvailabilityDatePicker extends Component
             return className;
         }
 
-        /*
         const filterPassedTime = (time) => {
-            const currentDate = this.state.selectedDate;
-            const selectedDate = new Date(time);
-            return currentDate.getTime() < selectedDate.getTime();
-          };
+            if (!moment(this.state.selectedDate).isSame(moment.unix(this.props.attributes.today), 'day')) {
+                return true;
+            }
         
+            const BUFFER_MINUTES = 60; // Minimum minutes needed between current time and next slot
+            const currentTime = moment();
+            const timeToCheck = moment(time);
+            
+            // Calculate minutes difference between times
+            const minutesDiff = timeToCheck.diff(currentTime, 'minutes');
+            
+            // Disable if time is in past or too close to current time
+            return minutesDiff >= BUFFER_MINUTES;
+        };
+        
+        /*
         const isWeekday = date => {
             const day = date.getDay();
             return day !== 0 && day !== 6;
@@ -337,7 +385,7 @@ class AvailabilityDatePicker extends Component
                                 minTime={this.state.minTime}
                                 maxTime={this.state.maxTime}
                                 excludeTimes={this.state.excludeTimeList}
-                                //filterTime={filterPassedTime}
+                                filterTime={filterPassedTime}
                                 disabled={this.props.attributes.disabled}
                                 onInputClick={this.openTimePicker}
                                 onKeyDown={this.tpKeyDownHandler}
diff --git a/zmsadmin/js/page/availabilityDay/form/errors.js b/zmsadmin/js/page/availabilityDay/form/errors.js
index 67f225527..d0e93e5da 100644
--- a/zmsadmin/js/page/availabilityDay/form/errors.js
+++ b/zmsadmin/js/page/availabilityDay/form/errors.js
@@ -1,15 +1,20 @@
-import React from 'react'
-import PropTypes from 'prop-types'
+import React from 'react';
+import PropTypes from 'prop-types';
 
-const renderErrors = errors => Object.keys(errors).map(key => {
-    return (
+const renderErrors = (errors) => 
+    Object.keys(errors).map(key => (
         <div key={errors[key].id}>
             {errors[key].itemList.map((item, index) => {
-                return <div key={index}>{item[0].message}</div>
-            })}   
+                if (Array.isArray(item)) {
+                    return item.map((nestedItem, nestedIndex) => (
+                        <div key={`${index}-${nestedIndex}`}>{nestedItem.message}</div>
+                    ));
+                } else {
+                    return <div key={index}>{item.message}</div>;
+                }
+            })}
         </div>
-    )
-})
+    ));
 
 const Errors = (props) => {
     return (
@@ -18,15 +23,15 @@ const Errors = (props) => {
             <h3>Folgende Fehler sind bei der Prüfung Ihrer Eingaben aufgetreten:</h3>
             {renderErrors(props.errorList)}
         </div> : null
-    )
-}
+    );
+};
 
 Errors.defaultProps = {
     errorList: []
-}
+};
 
 Errors.propTypes = {
     errorList: PropTypes.object
-}
+};
 
-export default Errors
+export default Errors;
diff --git a/zmsadmin/js/page/availabilityDay/form/footerButtons.js b/zmsadmin/js/page/availabilityDay/form/footerButtons.js
index ca41c6c50..7f57b8e62 100644
--- a/zmsadmin/js/page/availabilityDay/form/footerButtons.js
+++ b/zmsadmin/js/page/availabilityDay/form/footerButtons.js
@@ -2,26 +2,55 @@ import React from 'react'
 import PropTypes from 'prop-types'
 
 const FooterButtons = (props) => {
-    const { hasConflicts, stateChanged, data, onNew, onPublish, onAbort, hasSlotCountError } = props
+    const { hasConflicts, hasErrors, stateChanged, data, onNew, onPublish, onAbort, hasSlotCountError, availabilitylist } = props;
+
+    const hasNewAvailabilities = availabilitylist?.some(
+        availability => availability?.tempId?.includes('__temp__')
+    );
+
     return (
-        <div className="form-actions" style={{"marginTop":"0", "padding":"0.75em"}}>    
-                 <button title="Neue Öffnungszeit anlegen und bearbeiten" className="button button--diamond button-new" onClick={onNew} disabled={(stateChanged || hasConflicts || data)}>neue Öffnungszeit</button> 
-                <button title="Alle Änderungen werden zurückgesetzt" className="button btn" type="abort" onClick={onAbort} disabled={(!stateChanged && !hasConflicts && !data)}>Abbrechen</button>
-                <button title="Alle Änderungen werden gespeichert" className="button button--positive button-save" type="save" value="publish" onClick={onPublish} disabled={(!stateChanged  || hasSlotCountError)}>Alle Änderungen aktivieren
-                </button>
-             
+        <div className="form-actions" style={{ "marginTop": "0", "padding": "0.75em" }}>
+            <button
+                title="Neue Öffnungszeit anlegen und bearbeiten"
+                className="button button--diamond button-new"
+                onClick={onNew}
+                disabled={( data || hasConflicts)}
+            >
+                neue Öffnungszeit
+            </button>
+            <button
+                title="Alle Änderungen werden zurückgesetzt"
+                className="button btn"
+                type="abort"
+                onClick={onAbort}
+                disabled={!stateChanged && !hasNewAvailabilities && !hasConflicts && !hasErrors}
+            >
+                Abbrechen
+            </button>
+            <button
+                title="Alle Änderungen werden gespeichert"
+                className="button button--positive button-save"
+                type="save"
+                value="publish"
+                onClick={onPublish}
+                disabled={(!stateChanged && !hasNewAvailabilities) || hasSlotCountError || hasConflicts || hasErrors}
+            >
+                Alle Änderungen aktivieren
+            </button>
         </div>
-       
     )
 }
 
 FooterButtons.propTypes = {
     data: PropTypes.object,
     hasConflicts: PropTypes.bool,
+    hasErrors: PropTypes.bool,
     stateChanged: PropTypes.bool,
     onNew: PropTypes.func,
     onPublish: PropTypes.func,
-    onAbort: PropTypes.func
+    onAbort: PropTypes.func,
+    hasSlotCountError: PropTypes.bool,
+    availabilitylist: PropTypes.array
 }
 
 export default FooterButtons
diff --git a/zmsadmin/js/page/availabilityDay/form/formButtons.js b/zmsadmin/js/page/availabilityDay/form/formButtons.js
index 95a394855..565398e3b 100644
--- a/zmsadmin/js/page/availabilityDay/form/formButtons.js
+++ b/zmsadmin/js/page/availabilityDay/form/formButtons.js
@@ -2,8 +2,8 @@ import React from 'react'
 import PropTypes from 'prop-types'
 
 const FormButtons = (props) => {
-    const { data, onCopy, onExclusion, onEditInFuture, onUpdateSingle, onDelete, selectedDate, hasConflicts } = props
-    const disabled = ((data && (! data.id || data.__modified === true)) || hasConflicts);
+    const { data, onCopy, onExclusion, onEditInFuture, onUpdateSingle, onDelete, selectedDate, hasConflicts, hasErrors, hasSlotCountError } = props
+    const disabled = ((data && (! data.id || data.__modified === true)) || hasConflicts || hasErrors || hasSlotCountError);
     return (
         <div className="body">
             <div className="form-actions">
@@ -21,7 +21,7 @@ const FormButtons = (props) => {
                     className="button button--diamond" disabled={disabled || data.startDate == selectedDate}>Ab diesem Tag ändern</button> 
                 <button onClick={onUpdateSingle}
                     title="Öffnungszeit aktualisieren"
-                    className="button button--diamond" disabled={(data && !data.id) || hasConflicts || props.isCreatingExclusion}>Aktualisieren</button>
+                    className="button button--diamond" disabled={disabled || props.isCreatingExclusion}>Aktualisieren</button>
             </div>
         </div>
     )
@@ -30,6 +30,7 @@ const FormButtons = (props) => {
 FormButtons.propTypes = {
     data: PropTypes.object,
     hasConflicts: PropTypes.bool,
+    hasErrors: PropTypes.bool,
     onCopy: PropTypes.func,
     onExclusion: PropTypes.func,
     onEditInFuture: PropTypes.func,
diff --git a/zmsadmin/js/page/availabilityDay/form/index.js b/zmsadmin/js/page/availabilityDay/form/index.js
index a851d9e8a..99a8c03ba 100644
--- a/zmsadmin/js/page/availabilityDay/form/index.js
+++ b/zmsadmin/js/page/availabilityDay/form/index.js
@@ -3,6 +3,7 @@ import PropTypes from 'prop-types'
 import FormButtons from './formButtons'
 import FormContent from './content'
 import { getDataValuesFromForm, cleanupFormData, getFormValuesFromData } from '../helpers'
+import { hasSlotCountError } from '../form/validate';
 
 class AvailabilityForm extends Component {
     constructor(props) {
@@ -38,36 +39,40 @@ class AvailabilityForm extends Component {
         }
 
         const hasConflicts = ((
-                this.props.conflictList.itemList && 
-                Object.keys(this.props.conflictList.itemList).length
-            ) || 
+            this.props.conflictList.itemList &&
+            Object.keys(this.props.conflictList.itemList).length
+        )) ? true : false
+
+        const hasErrors = (
             (
                 this.props.errorList &&
                 Object.keys(this.props.errorList).length
-        )) ? true : false
+            )) ? true : false
 
         return (
             <div>
-                {<FormContent 
-                    today = {this.props.today} 
+                {<FormContent
+                    today={this.props.today}
                     availabilityList={this.props.availabilityList}
                     setErrorRef={this.props.setErrorRef}
                     errorList={this.props.errorList}
                     conflictList={this.props.conflictList}
                     {... { data, onChange }} />}
-                {<FormButtons 
-                    data = {data}
-                    onCopy={this.props.onCopy} 
+                {<FormButtons
+                    data={data}
+                    onCopy={this.props.onCopy}
                     onExclusion={this.props.onExclusion}
-                    onEditInFuture={this.props.onEditInFuture} 
+                    onEditInFuture={this.props.onEditInFuture}
                     onDelete={this.props.onDelete}
                     onUpdateSingle={this.props.onUpdateSingle}
                     selectedDate={this.props.selectedDate}
                     hasConflicts={hasConflicts}
+                    hasErrors={hasErrors}
+                    hasSlotCountError={hasSlotCountError(this.props)}
                     isCreatingExclusion={this.props.isCreatingExclusion}
                 />}
             </div>
-        )   
+        )
     }
 }
 
diff --git a/zmsadmin/js/page/availabilityDay/form/validate.js b/zmsadmin/js/page/availabilityDay/form/validate.js
index bf3ad3353..ba4b9d3c3 100644
--- a/zmsadmin/js/page/availabilityDay/form/validate.js
+++ b/zmsadmin/js/page/availabilityDay/form/validate.js
@@ -1,34 +1,160 @@
-import moment from 'moment'
+import moment from 'moment';
 
 const validate = (data, props) => {
-    const currentTime = new Date()
-    const today = moment(props.today, 'X')
-    today.set('hour', currentTime.getHours())
-    today.set('minute', currentTime.getMinutes())
-    today.set('second', currentTime.getSeconds())
-
-    const selectedDate = moment(props.timestamp, 'X')
-    const yesterday = selectedDate.startOf('day').clone().subtract(1, 'days')
-    const tomorrow = selectedDate.startOf('day').clone().add(1, 'days')
-    
+    const currentTime = new Date();
+    const today = moment(props.today, 'X');
+    today.set('hour', currentTime.getHours());
+    today.set('minute', currentTime.getMinutes());
+    today.set('second', currentTime.getSeconds());
+
+    const selectedDate = moment(props.timestamp, 'X');
+    const yesterday = selectedDate.startOf('day').clone().subtract(1, 'days');
+    const tomorrow = selectedDate.startOf('day').clone().add(1, 'days');
+
     let errorList = {
         id: data.id || data.tempId,
         itemList: []
-    }
+    };
+
+    errorList.itemList.push(validateNullValues(data));
+    errorList.itemList.push(validateTimestampAndTimeFormats(data));
+    errorList.itemList.push(validateStartTime(today, tomorrow, selectedDate, data));
+    errorList.itemList.push(validateEndTime(today, yesterday, selectedDate, data));
+    errorList.itemList.push(validateOriginEndTime(today, yesterday, selectedDate, data));
+    errorList.itemList.push(validateType(data));
+    errorList.itemList.push(validateSlotTime(data));
+    errorList.itemList.push(validateBookableDayRange(data));
 
-    errorList.itemList.push(validateStartTime(today, tomorrow, selectedDate, data))
-    errorList.itemList.push(validateEndTime(today, yesterday, selectedDate, data))
-    errorList.itemList.push(validateOriginEndTime(today, yesterday, selectedDate, data))
-    errorList.itemList.push(validateType(data))
-    errorList.itemList.push(validateSlotTime(data))
-    
     errorList.itemList = errorList.itemList.filter(el => el.length);
-    let valid = (0 < errorList.itemList.length) ? false : true
+    let valid = (0 < errorList.itemList.length) ? false : true;
 
     return {
         valid,
         errorList
+    };
+};
+
+function validateNullValues(data) {
+    let errorList = [];
+
+    if (!data.startDate) {
+        errorList.push({
+            type: 'startDateNull',
+            message: 'Das Startdatum darf nicht leer sein.'
+        });
+    }
+
+    if (!data.endDate) {
+        errorList.push({
+            type: 'endDateNull',
+            message: 'Das Enddatum darf nicht leer sein.'
+        });
+    }
+
+    if (!data.startTime) {
+        errorList.push({
+            type: 'startTimeNull',
+            message: 'Die Startzeit darf nicht leer sein.'
+        });
+    }
+
+    if (!data.endTime) {
+        errorList.push({
+            type: 'endTimeNull',
+            message: 'Die Endzeit darf nicht leer sein.'
+        });
+    }
+
+    return errorList;
+}
+
+function validateBookableDayRange(data) {
+    const errorList = [];
+
+    const startInDays = parseInt(data.bookable.startInDays, 10);
+    const endInDays = parseInt(data.bookable.endInDays, 10);
+
+    if (startInDays > endInDays) {
+        errorList.push({
+            type: 'bookableDayRange',
+            message: 'Bitte geben Sie im Feld \'von\' eine kleinere Zahl ein als im Feld \'bis\', wenn Sie bei \'Buchbar\' sind.'
+        });
+    }
+
+    return errorList;
+}
+
+function validateTimestampAndTimeFormats(data) {
+    let errorList = [];
+    const timeRegex = /^\d{2}:\d{2}(:\d{2})?$/;
+
+    let isStartDateValid = isValidTimestamp(data.startDate);
+    let isEndDateValid = isValidTimestamp(data.endDate);
+
+    if (!isStartDateValid) {
+        errorList.push({
+            type: 'startDateInvalid',
+            message: 'Das Startdatum ist kein gültiger Zeitstempel.'
+        });
+    }
+
+    if (!isEndDateValid) {
+        errorList.push({
+            type: 'endDateInvalid',
+            message: 'Das Enddatum ist kein gültiger Zeitstempel.'
+        });
+    }
+
+    if (data.startTime) {
+        if (!timeRegex.test(data.startTime)) {
+            errorList.push({
+                type: 'startTimeFormat',
+                message: 'Die Startzeit muss im Format "HH:mm:ss" oder "HH:mm" vorliegen.'
+            });
+        }
+    } else {
+        errorList.push({
+            type: 'startTimeMissing',
+            message: 'Die Startzeit darf nicht leer sein.'
+        });
     }
+
+    if (data.endTime) {
+        if (!timeRegex.test(data.endTime)) {
+            errorList.push({
+                type: 'endTimeFormat',
+                message: 'Die Endzeit muss im Format "HH:mm:ss" oder "HH:mm" vorliegen.'
+            });
+        }
+    } else {
+        errorList.push({
+            type: 'endTimeMissing',
+            message: 'Die Endzeit darf nicht leer sein.'
+        });
+    }
+
+    if (isStartDateValid && isEndDateValid) {
+        if (new Date(data.startDate) > new Date(data.endDate)) {
+            errorList.push({
+                type: 'dateOrderInvalid',
+                message: 'Das Startdatum darf nicht nach dem Enddatum liegen.'
+            });
+        }
+    }
+
+    return errorList;
+}
+
+function isValidTimestamp(timestamp) {
+    return !Number.isNaN(Number(timestamp)) && moment.unix(timestamp).isValid();
+}
+
+function parseTimestampAndTime(dateTimestamp, timeStr) {
+    const date = moment.unix(dateTimestamp);
+    if (!date.isValid()) return null;
+
+    const [hours, minutes, seconds] = timeStr.split(':').map((val, index) => parseInt(val || 0));
+    return date.set({ hour: hours, minute: minutes, second: seconds });
 }
 
 function validateStartTime(today, tomorrow, selectedDate, data) {
@@ -42,26 +168,27 @@ function validateStartTime(today, tomorrow, selectedDate, data) {
     const isFuture = (data.kind && 'future' == data.kind);
     //const isOrigin = (data.kind && 'origin' == data.kind);
 
-    if (! isFuture && selectedDate.unix() > today.unix() && startTime.isAfter(selectedDate.startOf('day'), 'day')) {
+    if (!isFuture && selectedDate.unix() > today.unix() && startTime.isAfter(selectedDate.startOf('day'), 'day')) {
         errorList.push({
-            type: 'startTimeFuture', 
+            type: 'startTimeFuture',
             message: `Das Startdatum der Öffnungszeit muss vor dem ${tomorrow.format('DD.MM.YYYY')} liegen.`
         })
     }
-/*
-    if (isOrigin && startTime.isBefore(today.startOf('day'), 'day') && data.__modified) {
-        errorList.push({
-            type: 'startTimeOrigin', 
-            message: 'Öffnungszeiten in der Vergangenheit lassen sich nicht bearbeiten '
-            + '(Der Terminanfang am "'+startDateTime.format('DD.MM.YYYY')+' liegt vor dem heutigen Tag").'
-        })
-    }
-*/
-
-    if ((startHour == "00" && startMinute == "00") || (endHour == "00" && endMinute == "00")) {
+    /*
+        if (isOrigin && startTime.isBefore(today.startOf('day'), 'day') && data.__modified) {
+            errorList.push({
+                type: 'startTimeOrigin', 
+                message: 'Öffnungszeiten in der Vergangenheit lassen sich nicht bearbeiten '
+                + '(Der Terminanfang am "'+startDateTime.format('DD.MM.YYYY')+' liegt vor dem heutigen Tag").'
+            })
+        }
+    */
+    const startHourInt = parseInt(startHour);
+    const endHourInt = parseInt(endHour);
+    if (startHourInt >= 23 || startHourInt === 0 || endHourInt >= 23 || endHourInt === 0) {
         errorList.push({
             type: 'startOfDay',
-            message: 'Die Uhrzeit darf nicht "00:00" sein.'
+            message: 'Die Uhrzeit darf nicht zwischen 23:00 und 01:00 liegen, da in diesem Zeitraum der tägliche Cronjob ausgeführt wird.'
         })
     }
     return errorList;
@@ -82,15 +209,18 @@ function validateEndTime(today, yesterday, selectedDate, data) {
 
     if (dayMinutesEnd <= dayMinutesStart) {
         errorList.push({
-            type: 'endTime', 
-            message: 'Die Uhrzeit "von" muss kleiner der Uhrzeit "bis" sein.'
+            type: 'endTime',
+            message: 'Die Endzeit darf nicht vor der Startzeit liegen.'
         })
-    } else if (startTimestamp >= endTimestamp) {
+    }
+
+    if (startTimestamp >= endTimestamp) {
         errorList.push({
-            type: 'endTime', 
-            message: 'Das Startdatum muss nach dem Enddatum sein.'
+            type: 'endTime',
+            message: 'Das Enddatum darf nicht vor dem Startdatum liegen.'
         })
     }
+
     return errorList;
 }
 
@@ -103,7 +233,7 @@ function validateOriginEndTime(today, yesterday, selectedDate, data) {
     const endTimestamp = endTime.clone().set({ h: endHour, m: endMinute }).unix();
     const isOrigin = (data.kind && 'origin' == data.kind)
 
-    if (! isOrigin && selectedDate.unix() > today.unix() && endTime.isBefore(selectedDate.startOf('day'), 'day')) {
+    if (!isOrigin && selectedDate.unix() > today.unix() && endTime.isBefore(selectedDate.startOf('day'), 'day')) {
         errorList.push({
             type: 'endTimeFuture',
             message: `Das Enddatum der Öffnungszeit muss nach dem ${yesterday.format('DD.MM.YYYY')} liegen.`
@@ -111,12 +241,12 @@ function validateOriginEndTime(today, yesterday, selectedDate, data) {
     }
 
     if (
-        (! isOrigin && endTimestamp < today.unix()) 
+        (!isOrigin && endTimestamp < today.unix())
     ) {
         errorList.push({
-            type: 'endTimePast', 
+            type: 'endTimePast',
             message: 'Öffnungszeiten in der Vergangenheit lassen sich nicht bearbeiten '
-            + '(Die aktuelle Zeit "'+today.format('DD.MM.YYYY HH:mm')+' Uhr" liegt nach dem Terminende am "'+endDateTime.format('DD.MM.YYYY HH:mm')+' Uhr").'
+                + '(Die aktuelle Zeit "' + today.format('DD.MM.YYYY HH:mm') + ' Uhr" liegt nach dem Terminende am "' + endDateTime.format('DD.MM.YYYY HH:mm') + ' Uhr").'
         })
     }
     return errorList;
@@ -133,7 +263,7 @@ function validateType(data) {
     return errorList;
 }
 
-function validateSlotTime (data) {
+function validateSlotTime(data) {
     let errorList = []
     const startTime = moment(data.startDate, 'X');
     const startHour = data.startTime.split(':')[0]
diff --git a/zmsadmin/js/page/availabilityDay/helpers.js b/zmsadmin/js/page/availabilityDay/helpers.js
index 4c5c1a432..c9dfc554a 100644
--- a/zmsadmin/js/page/availabilityDay/helpers.js
+++ b/zmsadmin/js/page/availabilityDay/helpers.js
@@ -79,7 +79,7 @@ export const getInitialState = (props) => Object.assign({}, {
     selectedTab: 'table',
 }, getStateFromProps(props))
 
-export const getNewAvailability = (timestamp, tempId, scope) => {
+export const getNewAvailability = (timestamp, tempId, scope, existingAvailabilities = []) => {
     const now = moment(timestamp, 'X')
     const weekday = [
         'monday',
@@ -91,20 +91,70 @@ export const getNewAvailability = (timestamp, tempId, scope) => {
         'sunday'
     ][now.isoWeekday() - 1]
 
-    console.log(scope)
+    const todayAvailabilities = existingAvailabilities.filter(a => 
+        moment(a.startDate, 'X').format('YYYY-MM-DD') === now.format('YYYY-MM-DD')
+    )
 
-    const newAvailability = {
+    todayAvailabilities.sort((a, b) => {
+        const aTime = moment(a.startTime, 'HH:mm:ss')
+        const bTime = moment(b.startTime, 'HH:mm:ss') 
+        return aTime.diff(bTime)
+    })
+
+    const currentTime = moment()
+    const dayEndTime = moment('23:00:00', 'HH:mm:ss')
+    let startTime = moment('06:00:00', 'HH:mm:ss')
+    
+    if (now.format('YYYY-MM-DD') === currentTime.format('YYYY-MM-DD') && currentTime.isAfter(startTime)) {
+        startTime = moment(currentTime).add(5 - (currentTime.minutes() % 5), 'minutes')
+    }
+    let endTime = moment(startTime).add(1, 'hour')
+
+    if (endTime.isAfter(dayEndTime)) {
+        startTime = moment(dayEndTime).subtract(1, 'hour')
+        endTime = moment(dayEndTime)
+    }
+
+    const hasOverlap = (start, end) => {
+        return todayAvailabilities.some(availability => {
+            const availStart = moment(availability.startTime, 'HH:mm:ss')
+            const availEnd = moment(availability.endTime, 'HH:mm:ss')
+            return !(end.isSameOrBefore(availStart) || start.isSameOrAfter(availEnd))
+        })
+    }
+
+    if (todayAvailabilities.length > 0) {
+        const firstAvail = todayAvailabilities[0]
+        const firstStart = moment(firstAvail.startTime, 'HH:mm:ss')
+        
+        if (!hasOverlap(startTime, endTime) && endTime.isSameOrBefore(firstStart)) {
+        } else {
+            const lastAvail = todayAvailabilities[todayAvailabilities.length - 1]
+            startTime = moment(lastAvail.endTime, 'HH:mm:ss')
+            if (now.format('YYYY-MM-DD') === currentTime.format('YYYY-MM-DD') && startTime.isBefore(currentTime)) {
+                startTime = moment(currentTime).add(30 - (currentTime.minutes() % 30), 'minutes')
+            }
+            endTime = moment(startTime).add(1, 'hour')
+            
+            if (endTime.isAfter(dayEndTime)) {
+                startTime = moment(dayEndTime).subtract(1, 'hour')
+                endTime = moment(dayEndTime)
+            }
+        }
+    }
+
+    return {
         id: null,
         tempId,
         scope: Object.assign({}, scope),
         description: 'Neue Öffnungszeit',
         startDate: timestamp,
         endDate: timestamp,
-        startTime: '07:00:00',
-        endTime: '20:00:00',
+        startTime: startTime.format('HH:mm:ss'),
+        endTime: endTime.format('HH:mm:ss'),
         bookable: {
-            startInDays: "0",
-            endInDays: "0"
+            startInDays: scope.preferences.appointment.startInDaysDefault ?? 0,
+            endInDays: scope.preferences.appointment.endInDaysDefault ?? 0
         },
         multipleSlotsAllowed: 1,
         slotTimeInMinutes: scope.provider.data['slotTimeInMinutes'],
@@ -123,8 +173,6 @@ export const getNewAvailability = (timestamp, tempId, scope) => {
         type: null,
         kind: "new"
     }
-
-    return newAvailability
 }
 
 export const availabilityTypes = [
@@ -187,18 +235,15 @@ export const cleanupAvailabilityForSave = availability => {
         delete newAvailability.tempId;
     }
 
-    if (newAvailability.kind) {
-        delete newAvailability.kind;
-    }
-
     return newAvailability;
 }
 
 export const getDataValuesFromForm = (form, scope) => {
+
     return Object.assign({}, getFirstLevelValues(form), {
         bookable: {
-            startInDays: form.open_from === "" ? scope.preferences.appointment.startInDaysDefault : form.open_from,
-            endInDays: form.open_to === "" ? scope.preferences.appointment.endInDaysDefault : form.open_to
+            startInDays: (!form.open_from || form.open_from === "" || form.open_from === "0") ? scope.preferences.appointment.startInDaysDefault : form.open_from,
+            endInDays: (!form.open_to || form.open_to === "" || form.open_to === "0") ? scope.preferences.appointment.endInDaysDefault : form.open_to
         },
         workstationCount: {
             intern: form.workstationCount_intern,
@@ -224,8 +269,8 @@ export const cleanupFormData = data => {
     return Object.assign({}, data, {
         workstationCount_callcenter: callcenterCount,
         workstationCount_public: publicCount,
-        open_from: (data.open_from === data.openFromDefault) ? "" : data.open_from,
-        open_to: (data.open_to === data.openToDefault) ? "" : data.open_to
+        open_from: (!data.open_from || data.open_from === data.openFromDefault) ? "" : data.open_from,
+        open_to: (!data.open_to || data.open_to === data.openToDefault) ? "" : data.open_to
     })
 }
 
diff --git a/zmsadmin/js/page/availabilityDay/index.js b/zmsadmin/js/page/availabilityDay/index.js
index c3f34a6dc..eb7d4645b 100644
--- a/zmsadmin/js/page/availabilityDay/index.js
+++ b/zmsadmin/js/page/availabilityDay/index.js
@@ -51,6 +51,10 @@ class AvailabilityPage extends Component {
         };
     }
 
+    handleScrollToBottom() {
+        window.scrollTo(0, document.body.scrollHeight);
+    }
+
     componentDidMount() {
         this.getValidationList()
         this.unloadHandler = ev => {
@@ -101,36 +105,61 @@ class AvailabilityPage extends Component {
     }
 
     onSaveUpdates() {
-        const ok = confirm('Möchten Sie wirklich die Änderungen aller Öffnungszeiten speichern?')
+        const ok = confirm('Möchten Sie wirklich die Änderungen aller Öffnungszeiten speichern?');
         if (ok) {
             showSpinner();
-            const sendData = this.state.availabilitylist.filter((availability) => {
-                return (
-                    (availability.__modified || 
-                    availability.tempId && availability.tempId.includes('__temp__'))) &&
-                    ! this.hasErrors(availability)
-            }).map(availability => {
-                const sendAvailability = Object.assign({}, availability)
-                if (availability.tempId) {
-                    delete sendAvailability.tempId
-                }
-                return sendAvailability;
-            }).map(cleanupAvailabilityForSave)
-                
-            console.log('Saving updates', sendData)
+
+            const selectedDate = formatTimestampDate(this.props.timestamp);
+
+            const sendData = this.state.availabilitylist
+                .filter((availability) => {
+                    return (
+                        (availability.__modified ||
+                            (availability.tempId && availability.tempId.includes('__temp__'))) &&
+                        !this.hasErrors(availability)
+                    );
+                })
+                .map(availability => {
+                    const sendAvailability = Object.assign({}, availability);
+                    if (availability.tempId) {
+                        delete sendAvailability.tempId;
+                    }
+                    console.log(availability.kind);
+                    return {
+                        ...sendAvailability,
+                        kind: availability.kind || 'default',
+                    };
+                })
+                .map(cleanupAvailabilityForSave);
+
+            const payload = {
+                availabilityList: sendData,
+                selectedDate: selectedDate
+            };
+
+            console.log('Saving updates', payload);
 
             $.ajax(`${this.props.links.includeurl}/availability/`, {
                 method: 'POST',
-                data: JSON.stringify(sendData)
+                data: JSON.stringify(payload),
+                contentType: 'application/json'
             }).done((success) => {
-                console.log('save success:', success)
+                console.log('save success:', success);
                 this.refreshData();
                 this.setState({
                     lastSave: new Date().getTime(),
+                    saveSuccess: true,
                 }, () => {
-                    this.successElement.scrollIntoView();
-                })
+                    // Attempt to scroll immediately after state update, before the 6-second timer expires
+                    if (this.successElement) {
+                        this.successElement.scrollIntoView();
+                    } else {
+                        // Fallback to bottom scroll if the element isn't available
+                        this.handleScrollToBottom();
+                    }
+                });
                 hideSpinner();
+                this.handleScrollToBottom();
             }).fail((err) => {
                 let isException = err.responseText.toLowerCase().includes('exception');
                 if (err.status >= 500 && isException) {
@@ -139,19 +168,27 @@ class AvailabilityPage extends Component {
                         message: err.responseText
                     });
                 } else if (err.status === 404) {
-                    console.log('404 error, ignored')
+                    console.log('404 error, ignored');
                 } else {
-                    console.log('save all error', err)
+                    console.log('save all error', err);
                 }
+                this.setState({
+                    lastSave: new Date().getTime(),
+                    saveSuccess: true,
+                }, () => {
+                    if (this.successElement) {
+                        this.successElement.scrollIntoView();
+                    }
+                });
                 this.getValidationList();
                 hideSpinner();
-            })
+                this.handleScrollToBottom();
+            });
         } else {
             hideSpinner();
         }
     }
 
-
     onRevertUpdates() {
         this.isCreatingExclusion = false
         this.setState(Object.assign({}, getInitialState(this.props), {
@@ -164,43 +201,64 @@ class AvailabilityPage extends Component {
 
     onUpdateSingleAvailability(availability) {
         showSpinner();
-        const ok = confirm('Soll diese Öffnungszeit wirklich aktualisiert werden?')
-        const id = availability.id
+        const ok = confirm('Soll diese Öffnungszeit wirklich aktualisiert werden?');
+        const id = availability.id;
+
         if (ok) {
-            let list = [availability];
-            const sendData = list.map(availability => {
-                const sendAvailability = Object.assign({}, availability)
-                if (availability.tempId) {
-                    delete sendAvailability.tempId
-                }
-                return sendAvailability;
-            }).map(cleanupAvailabilityForSave)
+            const selectedDate = formatTimestampDate(this.props.timestamp);
+
+            const sendAvailability = Object.assign({}, availability);
+
+            if (sendAvailability.tempId) {
+                delete sendAvailability.tempId;
+            }
+
+            const payload = {
+                availabilityList: [
+                    {
+                        ...cleanupAvailabilityForSave(sendAvailability),
+                        kind: availability.kind || 'default'
+                    }
+                ],
+                selectedDate: selectedDate
+            };
+
+            console.log('Updating single availability', payload);
 
             $.ajax(`${this.props.links.includeurl}/availability/save/${id}/`, {
                 method: 'POST',
-                data: JSON.stringify(sendData[0])
+                data: JSON.stringify(payload),
+                contentType: 'application/json'
             }).done((data) => {
-                console.log('single update success data: ', data)
-                this.refreshData()
+                console.log('Single update success:', data);
+                this.refreshData();
                 this.setState({
                     lastSave: new Date().getTime(),
+                    saveSuccess: true,
                 }, () => {
                     this.successElement.scrollIntoView();
-                })
+                });
                 hideSpinner();
+                this.handleScrollToBottom();
             }).fail(err => {
-                let isException = err.responseText.toLowerCase().includes('exception');
+                const isException = err.responseText.toLowerCase().includes('exception');
                 if (isException) {
                     new ExceptionHandler($('.opened'), {
                         code: err.status,
                         message: err.responseText
                     });
                 } else {
-                    console.log('update error', err);
+                    console.log('Update error:', err);
                 }
-                this.getValidationList()
+                this.setState({
+                    lastSave: new Date().getTime(),
+                    saveSuccess: false,
+                });
+
+                this.getValidationList();
                 hideSpinner();
-            })
+                this.handleScrollToBottom();
+            });
         } else {
             hideSpinner();
         }
@@ -219,7 +277,7 @@ class AvailabilityPage extends Component {
                 }), () => {
                     this.refreshData()
                     this.getConflictList(),
-                    this.getValidationList()
+                        this.getValidationList()
                 });
                 hideSpinner();
             }).fail(err => {
@@ -237,7 +295,7 @@ class AvailabilityPage extends Component {
             })
         } else {
             hideSpinner();
-        }        
+        }
     }
 
     onCopyAvailability(availability) {
@@ -260,7 +318,7 @@ class AvailabilityPage extends Component {
     }
 
     onSelectAvailability(availability) {
-        if (availability || ! this.state.selectedAvailability) {
+        if (availability || !this.state.selectedAvailability) {
             this.setState({
                 selectedAvailability: availability
             }, () => {
@@ -271,14 +329,14 @@ class AvailabilityPage extends Component {
                 selectedAvailability: null
             })
         }
-        
+
     }
 
     editExclusionAvailability(availability, startDate, endDate, description, kind) {
         (startDate) ? availability.startDate = startDate : null;
         (endDate) ? availability.endDate = endDate : null;
         availability.__modified = true;
-        if (! availability.kind && kind != 'origin') {
+        if (!availability.kind && kind != 'origin') {
             availability.tempId = tempId()
             availability.id = null
             availability.description = (description) ? description : availability.description
@@ -296,8 +354,8 @@ class AvailabilityPage extends Component {
 
         this.isCreatingExclusion = true;
 
-        let endDateTimestamp = (parseInt(yesterday.unix(), 10) < availability.startDate) ? 
-            parseInt(selectedDay.unix(), 10) : 
+        let endDateTimestamp = (parseInt(yesterday.unix(), 10) < availability.startDate) ?
+            parseInt(selectedDay.unix(), 10) :
             parseInt(yesterday.unix(), 10);
 
         let name = availability.description;
@@ -306,7 +364,7 @@ class AvailabilityPage extends Component {
 
         const originAvailability = this.editExclusionAvailability(
             Object.assign({}, availability),
-            null, 
+            null,
             endDateTimestamp,
             null,
             'origin'
@@ -320,7 +378,7 @@ class AvailabilityPage extends Component {
         if (originAvailability.startDate < selectedDay.unix()) {
             exclusionAvailability = this.editExclusionAvailability(
                 Object.assign({}, availability),
-                parseInt(selectedDay.unix(), 10), 
+                parseInt(selectedDay.unix(), 10),
                 parseInt(selectedDay.unix(), 10),
                 `Ausnahme zu Terminserie ` + name,
                 'exclusion'
@@ -344,27 +402,27 @@ class AvailabilityPage extends Component {
                 exclusionAvailability,
                 futureAvailability
             ]),
-            { 
-                selectedAvailability: exclusionAvailability, 
-                stateChanged: true 
+            {
+                selectedAvailability: exclusionAvailability,
+                stateChanged: true
             }
         ), () => {
             console.log('in after merging', this.state.availabilitylist);
             this.getConflictList(),
-            this.getValidationList()
+                this.getValidationList()
         })
     }
 
     onEditAvailabilityInFuture(availability) {
         const selectedDay = moment(this.props.timestamp, 'X').startOf('day')
         const yesterday = selectedDay.clone().subtract(1, 'days')
-        let endDateTimestamp = (parseInt(yesterday.unix(), 10) < availability.startDate) ? 
-            parseInt(selectedDay.unix(), 10) : 
+        let endDateTimestamp = (parseInt(yesterday.unix(), 10) < availability.startDate) ?
+            parseInt(selectedDay.unix(), 10) :
             parseInt(yesterday.unix(), 10);
 
         const originAvailability = this.editExclusionAvailability(
             Object.assign({}, availability),
-            null, 
+            null,
             endDateTimestamp,
             null,
             'origin'
@@ -386,27 +444,38 @@ class AvailabilityPage extends Component {
                 originAvailability,
                 futureAvailability
             ]),
-            { 
-                selectedAvailability: futureAvailability, 
-                stateChanged: true 
+            {
+                selectedAvailability: futureAvailability,
+                stateChanged: true
             }
         ), () => {
             this.getConflictList(),
-            this.getValidationList()
+                this.getValidationList()
         })
     }
 
     onNewAvailability() {
         let state = {};
-        const newAvailability = getNewAvailability(this.props.timestamp, tempId(), this.props.scope)
-        newAvailability.type = "appointment"
+        const newAvailability = getNewAvailability(this.props.timestamp, tempId(), this.props.scope, this.state.availabilitylist);
+        newAvailability.type = "appointment";
+    
         state = Object.assign(
-            state, 
-            updateAvailabilityInState(this.state, newAvailability), 
-            { selectedAvailability: null, stateChanged: true }
+            state,
+            updateAvailabilityInState(this.state, newAvailability)
         );
-        this.setState(state);
-        $('body').scrollTop(0);
+    
+        state.selectedAvailability = newAvailability;
+        state.stateChanged = false;
+    
+        this.setState(state, () => {
+            Promise.all([
+                this.getValidationList(),
+                this.getConflictList()
+            ])
+            .then(() => {
+                $('body').scrollTop(0);
+            })
+        });
     }
 
     onTabSelect(tab) {
@@ -441,70 +510,115 @@ class AvailabilityPage extends Component {
         return hasError || hasConflict;
     }
 
-    getValidationList(list = []) {
-        const validateData = data => {
-            let validationResult = validate(data, this.props)
-            if (!validationResult.valid) {
-                return validationResult.errorList              
-                
-            } 
-            return [];
-        }
+    validateAvailabilityList(availabilitylist) {
+        const timeRegex = /^\d{2}:\d{2}(:\d{2})?$/;
 
-        this.state.availabilitylist.map(availability => {
-            list.push(validateData(availability))
-        })
-        list = list.filter(el => el.id)
+        const isValidTimestamp = (timestamp) => !Number.isNaN(Number(timestamp)) && moment.unix(timestamp).isValid();
+
+        const invalidAvailabilities = availabilitylist.filter((availability) => {
+            const hasInvalidDates =
+                !isValidTimestamp(availability.startDate) || !isValidTimestamp(availability.endDate);
+            const hasInvalidTimes =
+                !timeRegex.test(availability.startTime) || !timeRegex.test(availability.endTime);
 
-        this.setState({
-            errorList: list.length ? Object.assign({}, list) : {}
-        }, () => {
-            if (list.length) {
-                this.errorElement.scrollIntoView()
+            if (hasInvalidDates || hasInvalidTimes) {
+                console.warn("Invalid availability detected:", availability);
             }
-        })
+
+            return hasInvalidDates || hasInvalidTimes;
+        });
+
+        return invalidAvailabilities;
     }
 
-    getConflictList() {
-        const requestOptions = {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(Object.assign({}, {
-                availabilityList: this.state.availabilitylist, 
-                selectedDate: formatTimestampDate(this.props.timestamp),
-                selectedAvailability: this.state.selectedAvailability
-            }))
-        };
-        const url = `${this.props.links.includeurl}/availability/conflicts/`;
-        fetch(url, requestOptions)
-            .then(res => res.json())
-            .then(
-                (data) => {
-                    this.setState({
-                        conflictList: Object.assign({}, 
-                            {
-                                itemList: Object.assign({}, data.conflictList), 
-                                conflictIdList: data.conflictIdList
+    getValidationList() {
+        return new Promise((resolve, reject) => {
+            const validateData = (data) => {
+                const validationResult = validate(data, this.props);
+                if (!validationResult.valid) {
+                    return validationResult.errorList;
+                }
+                return [];
+            };
+    
+            try {
+                const list = this.state.availabilitylist
+                    .map(validateData)
+                    .flat();
+    
+                console.log("Validations fetched successfully:", list);
+    
+                this.setState(
+                    {
+                        errorList: list.length ? list : [],
+                    },
+                    () => {
+                        if (list.length > 0) {
+                            const nonPastTimeErrors = list.filter(error => 
+                                !error.itemList?.flat(2).some(item => item?.type === 'endTimePast')
+                            );
+                            
+                            if (nonPastTimeErrors.length > 0) {
+                                console.warn("Validation failed with errors:", nonPastTimeErrors);
+                                this.errorElement?.scrollIntoView();
+                            } else {
+                                console.log("Validation passed with only past time errors.");
                             }
-                        )
-                    })
-                    if (data.conflictIdList.length > 0) {
-                        this.errorElement.scrollIntoView()
+                        } else {
+                            console.log("Validation passed successfully.");
+                            resolve();
+                        }
                     }
-                },
-                (err) => {
-                    let isException = err.responseText.toLowerCase().includes('exception');
-                    if (err.status >= 500 && isException) {
-                        new ExceptionHandler($('.opened'), {
-                            code: err.status,
-                            message: err.responseText
+                );
+            } catch (error) {
+                console.error("Validation error:", error);
+                reject(error);
+            }
+        });
+    }
+
+    getConflictList() {
+        return new Promise((resolve, reject) => {
+            const { availabilitylist } = this.state;
+            const { timestamp } = this.props;
+            const requestOptions = {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    availabilityList: availabilitylist.filter(a => a.kind !== 'exclusion'),
+                    selectedDate: formatTimestampDate(timestamp)
+                }),
+            };
+    
+            const url = `${this.props.links.includeurl}/availability/conflicts/`;
+    
+            fetch(url, requestOptions)
+                .then((res) => res.json())
+                .then(
+                    (data) => {
+                        console.log("Conflicts fetched successfully:", data);
+                        this.setState({
+                            conflictList: {
+                                itemList: { ...data.conflictList },
+                                conflictIdList: data.conflictIdList,
+                            },
                         });
-                    } else {
-                        console.log('conflict error', err);
+                        if (data.conflictIdList.length > 0) {
+                            this.errorElement?.scrollIntoView();
+                        }
+                        resolve();
+                    },
+                    (err) => {
+                        console.error("Conflict fetch error:", err);
+                        hideSpinner();
+                        reject(err);
                     }
-                    hideSpinner();
-                }
-            )
+                )
+                .catch((error) => {
+                    console.warn("Conflict fetch failed:", error);
+                    reject(error);
+                });
+        });
     }
 
     renderTimeTable() {
@@ -532,39 +646,56 @@ class AvailabilityPage extends Component {
     }
 
     readCalculatedAvailabilityList() {
-        $.ajax(`${this.props.links.includeurl}/availability/slots/`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            data: JSON.stringify({
-                'availabilityList': this.state.availabilitylist,
-                'busySlots': this.state.busyslots
-            })
-        }).done((responseData) => {
-            let availabilityList =  writeSlotCalculationIntoAvailability(
-                this.state.availabilitylist, 
-                responseData['maxSlots'], 
-                responseData['busySlots']
-            );
-            this.setState({ 
-                availabilitylistslices: availabilityList,
-                maxWorkstationCount: parseInt(responseData['maxWorkstationCount']),
-            })
-        }).fail((err) => {
-            if (err.status === 404) {
-                console.log('404 error, ignored')
-            } else {
-                let isException = err.responseText.toLowerCase().includes('exception');
-                    if (err.status >= 500 && isException) {
-                        new ExceptionHandler($('.opened'), {
-                            code: err.status,
-                            message: err.responseText
+        this.getValidationList()
+            .then(() => {
+                const { availabilitylist, busyslots } = this.state;
+
+                console.log("Validation passed. Proceeding with /availability/slots/.");
+
+                $.ajax(`${this.props.links.includeurl}/availability/slots/`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    data: JSON.stringify({
+                        availabilityList: availabilitylist,
+                        busySlots: busyslots,
+                    }),
+                })
+                    .done((responseData) => {
+                        console.log("Slots fetched successfully:", responseData);
+                        const availabilityList = writeSlotCalculationIntoAvailability(
+                            this.state.availabilitylist,
+                            responseData['maxSlots'],
+                            responseData['busySlots']
+                        );
+                        this.setState({
+                            availabilitylistslices: availabilityList,
+                            maxWorkstationCount: parseInt(responseData['maxWorkstationCount']),
                         });
-                    } else {
-                        console.log('reading calculated availability list error', err);
-                    }
-                    hideSpinner();
-            }
-        })
+                    })
+                    .fail((err) => {
+                        console.error("Error during /availability/slots/ fetch:", err);
+                        if (err.status === 404) {
+                            console.log("404 error ignored.");
+                            hideSpinner();
+                        } else {
+                            const isException = err.responseText.toLowerCase().includes("exception");
+                            if (err.status >= 500 && isException) {
+                                new ExceptionHandler($(".opened"), {
+                                    code: err.status,
+                                    message: err.responseText,
+                                });
+                            } else {
+                                console.error("Unexpected error:", err.responseText);
+                            }
+                            hideSpinner();
+                        }
+                    });
+            })
+            .catch((error) => {
+                console.warn("Validation failed. Slot calculation fetch aborted.", error);
+                this.setState({ errorList: error });
+                this.errorElement?.scrollIntoView();
+            });
     }
 
     handleChange(data) {
@@ -593,7 +724,7 @@ class AvailabilityPage extends Component {
             this.handleOriginChanges(data)
         }
         if ('exclusion' == data.kind && data.__modified) {
-            this.handleExclusionChanges(data)        
+            this.handleExclusionChanges(data)
         }
         if ('future' == data.kind && data.__modified) {
             this.handleFutureChanges(data)
@@ -603,14 +734,14 @@ class AvailabilityPage extends Component {
     handleOriginChanges(data) {
         const exclusionAvailabilityFromState = findAvailabilityInStateByKind(this.state, 'exclusion');
         const futureAvailabilityFromState = findAvailabilityInStateByKind(this.state, 'future');
-        
+
         const exclusionAvailability = (exclusionAvailabilityFromState) ? Object.assign({}, exclusionAvailabilityFromState, {
             startDate: moment(data.endDate, 'X').startOf('day').add(1, 'days').unix(),
             endDate: (exclusionAvailabilityFromState.endDate > moment(data.endDate, 'X').startOf('day').add(1, 'days').unix()) ?
                 exclusionAvailabilityFromState.endDate :
                 moment(data.endDate, 'X').startOf('day').add(1, 'days').unix()
         }) : data;
-    
+
         const futureAvailability = Object.assign({}, futureAvailabilityFromState, {
             startDate: moment(exclusionAvailability.endDate, 'X').startOf('day').add(1, 'days').unix(),
             endDate: (
@@ -621,7 +752,7 @@ class AvailabilityPage extends Component {
         this.setState(Object.assign(
             {},
             mergeAvailabilityListIntoState(this.state, [exclusionAvailability, futureAvailability, data])
-        ));          
+        ));
     }
 
     handleExclusionChanges(data) {
@@ -635,7 +766,7 @@ class AvailabilityPage extends Component {
         const originAvailability = Object.assign({}, originAvailabilityFromState, {
             endDate: moment(exclusionAvailability.startDate, 'X').startOf('day').subtract(1, 'days').unix()
         });
-    
+
         const futureAvailability = Object.assign({}, futureAvailabilityFromState, {
             startDate: moment(exclusionAvailability.endDate, 'X').startOf('day').add(1, 'days').unix(),
             endDate: (
@@ -647,32 +778,32 @@ class AvailabilityPage extends Component {
         this.setState(Object.assign(
             {},
             mergeAvailabilityListIntoState(this.state, [
-                originAvailability, 
-                futureAvailability, 
+                originAvailability,
+                futureAvailability,
                 exclusionAvailability
             ])
-        ));  
+        ));
     }
 
     handleFutureChanges(data) {
         const startDate = moment(data.startDate, 'X').startOf('day').add(1, 'days').unix();
         const originAvailabilityFromState = findAvailabilityInStateByKind(this.state, 'origin');
         const exclusionAvailabilityFromState = findAvailabilityInStateByKind(this.state, 'exclusion');
-        
+
         const exclusionAvailability = (exclusionAvailabilityFromState) ? Object.assign({}, exclusionAvailabilityFromState, {
-            startDate: (startDate < exclusionAvailabilityFromState.endDate) ? 
-                parseInt(startDate, 10) : 
+            startDate: (startDate < exclusionAvailabilityFromState.endDate) ?
+                parseInt(startDate, 10) :
                 exclusionAvailabilityFromState.endDate
         }) : data;
 
         const originAvailability = Object.assign({}, originAvailabilityFromState, {
             endDate: moment(exclusionAvailability.startDate, 'X').startOf('day').subtract(1, 'days').unix()
         });
-    
+
         this.setState(Object.assign(
             {},
             mergeAvailabilityListIntoState(this.state, [originAvailability, exclusionAvailability, data])
-        ));          
+        ));
     }
 
     renderAvailabilityAccordion() {
@@ -707,7 +838,7 @@ class AvailabilityPage extends Component {
             this.handleChange(data)
         }
 
-        return <AccordionLayout 
+        return <AccordionLayout
             availabilityList={this.state.availabilitylist}
             data={this.state.selectedAvailability}
             today={this.state.today}
@@ -726,12 +857,12 @@ class AvailabilityPage extends Component {
             stateChanged={this.state.stateChanged}
             includeUrl={this.props.links.includeurl}
             setErrorRef={this.setErrorRef}
-            errorList={this.state.errorList ? 
+            errorList={this.state.errorList ?
                 this.state.errorList : {}
             }
-            conflictList={this.state.conflictList ? 
-                this.state.conflictList : 
-                {itemList: {}, conflictIdList: {}}
+            conflictList={this.state.conflictList ?
+                this.state.conflictList :
+                { itemList: {}, conflictIdList: {} }
             }
             isCreatingExclusion={this.isCreatingExclusion}
         />
@@ -739,7 +870,13 @@ class AvailabilityPage extends Component {
 
     renderSaveBar() {
         if (this.state.lastSave) {
-            return <SaveBar lastSave={this.state.lastSave} setSuccessRef={this.setSuccessRef} />
+            return (
+                <SaveBar
+                    lastSave={this.state.lastSave}
+                    success={this.state.saveSuccess}
+                    setSuccessRef={this.setSuccessRef}
+                />
+            )
         }
     }
 
diff --git a/zmsadmin/js/page/availabilityDay/layouts/accordion.js b/zmsadmin/js/page/availabilityDay/layouts/accordion.js
index 46f84641a..795c45027 100644
--- a/zmsadmin/js/page/availabilityDay/layouts/accordion.js
+++ b/zmsadmin/js/page/availabilityDay/layouts/accordion.js
@@ -157,11 +157,17 @@ class Accordion extends Component
                 title=""
                 body={renderAccordionBody()}
                 footer={<FooterButtons 
-                    hasConflicts={Object.keys(this.props.conflictList.itemList).length || Object.keys(this.props.errorList).length ? true : false}
+                    hasConflicts={Object.keys(this.props.conflictList.itemList).length ? true : false}
+                    hasErrors={Object.values(this.props.errorList).some(error => {
+                        const hasPastTimeError = error.itemList?.flat(2)
+                            .some(item => item?.type === 'endTimePast');
+                        return !hasPastTimeError;
+                    })}
                     hasSlotCountError={hasSlotCountError(this.props)}
                     stateChanged={this.props.stateChanged} 
-                    data={this.props.data} 
-                    {...{onNew, onPublish, onAbort }} 
+                    data={this.props.data}
+                    availabilitylist={this.props.availabilityList}
+                    {...{onNew, onPublish, onAbort }}
                 />}
             />
         )
diff --git a/zmsadmin/js/page/availabilityDay/layouts/page.js b/zmsadmin/js/page/availabilityDay/layouts/page.js
index 3a547e780..7a3ef83e2 100644
--- a/zmsadmin/js/page/availabilityDay/layouts/page.js
+++ b/zmsadmin/js/page/availabilityDay/layouts/page.js
@@ -11,6 +11,7 @@ const PageLayout = (props) => {
             {props.timeTable}
             {props.saveBar}
             {props.accordion}
+            {props.saveBar}
         </div>
     )
 }
@@ -19,8 +20,8 @@ PageLayout.propTypes = {
     timeTable: PropTypes.node,
     accordion: PropTypes.node,
     conflicts: PropTypes.node,
+    saveBar: PropTypes.node,
     tabs: PropTypes.node,
-    saveBar: PropTypes.node
 }
 
 export default PageLayout
diff --git a/zmsadmin/js/page/availabilityDay/saveBar.js b/zmsadmin/js/page/availabilityDay/saveBar.js
index e5868d09c..5792120bc 100644
--- a/zmsadmin/js/page/availabilityDay/saveBar.js
+++ b/zmsadmin/js/page/availabilityDay/saveBar.js
@@ -1,25 +1,44 @@
-import React from 'react'
+import React, { useEffect, useState } from 'react'
 import moment from 'moment'
-import PropTypes from 'prop-types' 
+import PropTypes from 'prop-types'
 
 const formatDate = date => {
     const momentDate = moment(date)
     return `${momentDate.format('DD.MM.YYYY')} um ${momentDate.format('HH:mm')} Uhr`
 } 
- 
+
 const SaveBar = (props) => {
+    const [isVisible, setIsVisible] = useState(true)
+
+    useEffect(() => {
+        setIsVisible(true) // Reset visibility when lastSave changes
+        const timer = setTimeout(() => {
+            setIsVisible(false)
+        }, 6000)
+        return () => clearTimeout(timer)
+    }, [props.lastSave]) // Add lastSave as dependency
+
+    if (!isVisible) return null
+
     return (
-        <div ref={props.setSuccessRef} className="message message--success">
-            Öffnungszeiten gespeichert, {formatDate(props.lastSave)}
+        <div 
+            ref={props.setSuccessRef} 
+            className={`message ${props.success ? 'message--success' : 'message--error'}`}
+        >
+            {props.success 
+                ? <b><i className="fas fa-check-circle" aria-hidden="true" aria-label="Erfolg"></i> Öffnungszeiten gespeichert, {formatDate(props.lastSave)}</b>
+                : <b><i className="fas fa-times-circle" aria-hidden="true" aria-label="Fehler"></i> Fehler beim Speichern der Öffnungszeiten. Bitte versuchen Sie es erneut.</b>}
         </div>
     )
 }
 
 SaveBar.propTypes = {
     lastSave: PropTypes.oneOfType([
-        PropTypes.number, PropTypes.string
+        PropTypes.number, 
+        PropTypes.string
     ]).isRequired,
+    success: PropTypes.bool.isRequired,
     setSuccessRef: PropTypes.func
 }
 
-export default SaveBar
+export default SaveBar
\ No newline at end of file
diff --git a/zmsadmin/js/page/availabilityDay/timetable/graphview.js b/zmsadmin/js/page/availabilityDay/timetable/graphview.js
index c8ccfde27..dcd32b890 100644
--- a/zmsadmin/js/page/availabilityDay/timetable/graphview.js
+++ b/zmsadmin/js/page/availabilityDay/timetable/graphview.js
@@ -30,7 +30,6 @@ const GraphView = (props) => {
                 headerRight={constants.headerRight(props.links, props.onNewAvailability)}
                 headerMiddle={constants.headerMiddle()}
                 body={graphBody}
-                footer={constants.renderFooter()}
             />
 
         </>
diff --git a/zmsadmin/js/page/availabilityDay/timetable/index.js b/zmsadmin/js/page/availabilityDay/timetable/index.js
index 81ae07cff..e913ee8cb 100644
--- a/zmsadmin/js/page/availabilityDay/timetable/index.js
+++ b/zmsadmin/js/page/availabilityDay/timetable/index.js
@@ -34,6 +34,4 @@ export const renderAppointments = (items, maxWorkstationCount, onSelect) => {ret
 
 export const renderOpenings = (items, onSelect) => {return items
     .filter(item => item.type === "openinghours")
-    .map((data, key) => <OpeningTimebar key={key} {...{ key, data, onSelect }} />)}
-
-export const renderFooter = () => {return <small>Zum Bearbeiten einer Öffnungszeit, bitte auf den entsprechenden blauen oder grünen Zeitstrahl klicken.</small>}
\ No newline at end of file
+    .map((data, key) => <OpeningTimebar key={key} {...{ key, data, onSelect }} />)}
\ No newline at end of file
diff --git a/zmsadmin/src/Zmsadmin/AvailabilityConflicts.php b/zmsadmin/src/Zmsadmin/AvailabilityConflicts.php
index cf41ff895..2ce725535 100644
--- a/zmsadmin/src/Zmsadmin/AvailabilityConflicts.php
+++ b/zmsadmin/src/Zmsadmin/AvailabilityConflicts.php
@@ -6,13 +6,12 @@
 
 namespace BO\Zmsadmin;
 
-use BO\Zmsentities\Availability;
-
+use BO\Zmsapi\Exception\BadRequest as BadRequestException;
 use BO\Zmsentities\Collection\AvailabilityList;
+use BO\Zmsentities\Process;
 
 /**
  * Check if new Availability is in conflict with existing availability
- *
  */
 class AvailabilityConflicts extends BaseController
 {
@@ -28,44 +27,147 @@ public function readResponse(
         $validator = $request->getAttribute('validator');
         $input = $validator->getInput()->isJson()->assertValid()->getValue();
         $data = static::getAvailabilityData($input);
-        return \BO\Slim\Render::withJson(
-            $response,
-            $data
-        );
+        return \BO\Slim\Render::withJson($response, $data);
     }
 
     protected static function getAvailabilityData($input)
     {
+        if (!isset($input['availabilityList']) || !is_array($input['availabilityList'])) {
+            throw new BadRequestException('Missing or invalid availabilityList.');
+        } else if(!isset($input['availabilityList'][0]['scope'])){
+            throw new BadRequestException('Missing or invalid scope.');
+        } else if (!isset($input['selectedDate'])) {
+            throw new BadRequestException("'selectedDate' is required.");
+        }
+
         $conflictList = new \BO\Zmsentities\Collection\ProcessList();
         $availabilityList = (new AvailabilityList())->addData($input['availabilityList']);
         $conflictedList = [];
-
+    
         $selectedDateTime = (new \DateTimeImmutable($input['selectedDate']))->modify(\App::$now->format('H:i:s'));
-        $selectedAvailability = new Availability($input['selectedAvailability']);
-        $startDateTime = ($selectedAvailability->getStartDateTime() >= \App::$now) ?
-            $selectedAvailability->getStartDateTime() : $selectedDateTime;
-        $endDateTime = ($input['selectedAvailability']) ?
-            $selectedAvailability->getEndDateTime() : $selectedDateTime;
 
-        $availabilityList = $availabilityList->sortByCustomStringKey('endTime');
-        $conflictList = $availabilityList->getConflicts($startDateTime, $endDateTime);
+        $overlapConflicts = self::checkNewVsNewConflicts($availabilityList, $selectedDateTime);
+        $conflictList->addList($overlapConflicts);
+    
+        $scopeData = $input['availabilityList'][0]['scope'];
+        $scope = new \BO\Zmsentities\Scope($scopeData);
 
+        $futureAvailabilityList = self::getAvailabilityList($scope, $selectedDateTime);
+    
+        foreach ($futureAvailabilityList as $futureAvailability) {
+            $availabilityList->addEntity($futureAvailability);
+        }
+    
+        $originId = null;
+        foreach ($availabilityList as $availability) {
+            if (isset($availability->kind) && $availability->kind === 'origin' && isset($availability->id)) {
+                $originId = $availability->id;
+                break;
+            }
+        }
+    
+        $filteredAvailabilityList = new AvailabilityList();
+        foreach ($availabilityList as $availability) {
+            if ((!isset($availability->kind) || $availability->kind !== 'exclusion') && 
+                (!isset($availability->id) || $availability->id !== $originId)) {
+                $filteredAvailabilityList->addEntity($availability);
+            }
+        }
+    
+        [$earliestStartDateTime, $latestEndDateTime] = $filteredAvailabilityList->getDateTimeRangeFromList($selectedDateTime);
+    
+        $filteredAvailabilityList = $filteredAvailabilityList->sortByCustomStringKey('endTime');
+        $existingConflicts = $filteredAvailabilityList->checkAllVsExistingConflicts($earliestStartDateTime, $latestEndDateTime);
+        $conflictList->addList($existingConflicts);
+    
         foreach ($conflictList as $conflict) {
             $availabilityId = ($conflict->getFirstAppointment()->getAvailability()->getId()) ?
                 $conflict->getFirstAppointment()->getAvailability()->getId() :
                 $conflict->getFirstAppointment()->getAvailability()->tempId;
-            if (! in_array($availabilityId, $conflictedList)) {
+            if (!in_array($availabilityId, $conflictedList)) {
                 $conflictedList[] = $availabilityId;
             }
         }
-
+    
         return [
             'conflictList' => $conflictList->toConflictListByDay(),
             'conflictIdList' => (count($conflictedList)) ? $conflictedList : []
         ];
     }
 
-    /*
+    /**
+     * Check for overlaps between availabilities in the collection
+     * 
+     * @param AvailabilityList $collection
+     * @param \DateTimeImmutable $selectedDateTime
+     * @return \BO\Zmsentities\Collection\ProcessList
+     */
+    protected static function checkNewVsNewConflicts(AvailabilityList $collection, \DateTimeImmutable $selectedDateTime)
+    {
+        $conflicts = new \BO\Zmsentities\Collection\ProcessList();
+        
+        $newAvailabilities = new AvailabilityList();
+        foreach ($collection as $availability) {
+            if (isset($availability->tempId) && strpos($availability->tempId, '__temp__') !== false) {
+                $newAvailabilities->addEntity($availability);
+            }
+        }
+        
+        foreach ($newAvailabilities as $availability1) {
+            foreach ($newAvailabilities as $availability2) {
+                $scope1Id = is_array($availability1->scope) ? ($availability1->scope['id'] ?? null) : ($availability1->scope->id ?? null);
+                $scope2Id = is_array($availability2->scope) ? ($availability2->scope['id'] ?? null) : ($availability2->scope->id ?? null);
+                
+                if ($availability1 !== $availability2 && 
+                    $availability1->type == $availability2->type &&
+                    $scope1Id == $scope2Id &&
+                    $availability1->hasSharedWeekdayWith($availability2)) {
+                    
+                    $date1 = (new \DateTimeImmutable())->setTimestamp($availability1->startDate)->format('Y-m-d');
+                    $date2 = (new \DateTimeImmutable())->setTimestamp($availability2->startDate)->format('Y-m-d');
+                    
+                    if ($date1 === $date2) {
+                        $time1Start = (new \DateTimeImmutable())->setTimestamp($availability1->startDate)
+                            ->modify($availability1->startTime)->format('H:i');
+                        $time1End = (new \DateTimeImmutable())->setTimestamp($availability1->endDate)
+                            ->modify($availability1->endTime)->format('H:i');
+                        $time2Start = (new \DateTimeImmutable())->setTimestamp($availability2->startDate)
+                            ->modify($availability2->startTime)->format('H:i');
+                        $time2End = (new \DateTimeImmutable())->setTimestamp($availability2->endDate)
+                            ->modify($availability2->endTime)->format('H:i');
+    
+                        if ($time2Start < $time1End && $time1Start < $time2End) {
+                            $process = new Process();
+                            
+                            $dateRange1 = date('d.m.Y', $availability1->startDate) . ' - ' . date('d.m.Y', $availability1->endDate);
+                            $dateRange2 = date('d.m.Y', $availability2->startDate) . ' - ' . date('d.m.Y', $availability2->endDate);
+                            $timeRange1 = $time1Start . ' - ' . $time1End;
+                            $timeRange2 = $time2Start . ' - ' . $time2End;
+    
+                            $process->amendment = "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n"
+                                . "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[$dateRange1, $timeRange1]\n"
+                                . "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[$dateRange2, $timeRange2]";
+                            
+                            $appointment = new \BO\Zmsentities\Appointment();
+                            $appointment->date = $availability1->startDate;
+                            $appointment->availability = $availability1;
+                            $process->addAppointment($appointment);
+                            $conflicts->addEntity($process);
+                        }
+                    }
+                }
+            }
+        }
+        return $conflicts;
+    }
+
+    /**
+     * Fetch availabilities for a given scope and date.
+     * 
+     * @param \BO\Zmsentities\Scope $scope
+     * @param \DateTimeImmutable $dateTime
+     * @return AvailabilityList
+     */
     protected static function getAvailabilityList($scope, $dateTime)
     {
         try {
@@ -74,7 +176,7 @@ protected static function getAvailabilityList($scope, $dateTime)
                     '/scope/' . $scope->getId() . '/availability/',
                     [
                         'resolveReferences' => 0,
-                        'startDate' => $dateTime->format('Y-m-d') //for skipping old availabilities
+                        'startDate' => $dateTime->format('Y-m-d')
                     ]
                 )
                 ->getCollection();
@@ -86,5 +188,4 @@ protected static function getAvailabilityList($scope, $dateTime)
         }
         return $availabilityList->withScope($scope);
     }
-    */
-}
+}
\ No newline at end of file
diff --git a/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityaddfailed.twig b/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityaddfailed.twig
new file mode 100644
index 000000000..f41a04995
--- /dev/null
+++ b/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityaddfailed.twig
@@ -0,0 +1,7 @@
+{%
+    include "exception/bo/layout.twig" with {
+		"message":"Zu den angegebenen Daten konnte keine Öffnungszeit erstellt werden. Bitte überprüfen Sie Ihre Eingaben und korrigieren Sie diese gegebenenfalls.",
+		"title":"Konflikt: Öffnungszeit überschneidet sich mit einer bestehenden Zeit",
+        "reload":"1"
+    }
+%}
diff --git a/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityupdatefailed.twig b/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityupdatefailed.twig
new file mode 100644
index 000000000..32fa920d0
--- /dev/null
+++ b/zmsadmin/templates/exception/bo/zmsapi/exception/availability/availabilityupdatefailed.twig
@@ -0,0 +1,7 @@
+{%
+    include "exception/bo/layout.twig" with {
+		"message":"Zu den angegebenen Daten konnte keine Öffnungszeit geändert werden. Bitte überprüfen Sie Ihre Eingaben und korrigieren Sie diese gegebenenfalls.",
+		"title":"Konflikt: Öffnungszeit überschneidet sich mit einer bestehenden Zeit",
+        "reload":"1"
+    }
+%}
diff --git a/zmsadmin/tests/Zmsadmin/AvailabilityConflictsTest.php b/zmsadmin/tests/Zmsadmin/AvailabilityConflictsTest.php
index 73f6d93eb..8b3f2ce1c 100644
--- a/zmsadmin/tests/Zmsadmin/AvailabilityConflictsTest.php
+++ b/zmsadmin/tests/Zmsadmin/AvailabilityConflictsTest.php
@@ -10,6 +10,21 @@ class AvailabilityConflictsTest extends Base
 
     public function testRendering()
     {
+
+        $this->setApiCalls(
+            [
+                [
+                    'function' => 'readGetResult',
+                    'url' => '/scope/141/availability/',
+                    'parameters' => [
+                        'resolveReferences' => 0,
+                        'startDate' => '2016-04-04'
+                    ],
+                    'response' => $this->readFixture("GET_availability_68985.json")
+                ]
+            ]
+        );
+
         $response = $this->render([], [
             '__body' => '{
                 "availabilityList": [
diff --git a/zmsapi/src/Zmsapi/AvailabilityAdd.php b/zmsapi/src/Zmsapi/AvailabilityAdd.php
index b63a024ac..06104c0b0 100644
--- a/zmsapi/src/Zmsapi/AvailabilityAdd.php
+++ b/zmsapi/src/Zmsapi/AvailabilityAdd.php
@@ -20,7 +20,7 @@
 
 use BO\Zmsapi\AvailabilitySlotsUpdate;
 use BO\Zmsapi\Exception\BadRequest as BadRequestException;
-use BO\Zmsapi\Exception\Availability\AvailabilityUpdateFailed as UpdateFailedException;
+use BO\Zmsapi\Exception\Availability\AvailabilityAddFailed;
 
 /**
  * @SuppressWarnings(Coupling)
@@ -37,43 +37,123 @@ public function readResponse(
         array $args
     ): ResponseInterface {
         (new Helper\User($request))->checkRights();
+        $resolveReferences = Validator::param('resolveReferences')->isNumber()->setDefault(2)->getValue();
         $input = Validator::input()->isJson()->assertValid()->getValue();
-        if (! $input || count($input) === 0) {
+        if (!$input || count($input) === 0) {
             throw new BadRequestException();
         }
-        $collection = new Collection();
+
         DbConnection::getWriteConnection();
-        foreach ($input as $item) {
+
+        if (!isset($input['availabilityList']) || !is_array($input['availabilityList'])) {
+            throw new BadRequestException('Missing or invalid availabilityList.');
+        } else if (!isset($input['availabilityList'][0]['scope'])) {
+            throw new BadRequestException('Missing or invalid scope.');
+        } else if (!isset($input['selectedDate'])) {
+            throw new BadRequestException("'selectedDate' is required.");
+        }
+
+        $newCollection = new Collection();
+        foreach ($input['availabilityList'] as $item) {
             $entity = new Entity($item);
             $entity->testValid();
-            $updatedEntity = $this->writeEntityUpdate($entity);
+            $newCollection->addEntity($entity);
+        }
+
+        $scopeData = $input['availabilityList'][0]['scope'];
+        $scope = new \BO\Zmsentities\Scope($scopeData);
+
+        $selectedDate = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $input['selectedDate'] . ' 00:00:00');
+        $this->checkNewVsNewConflicts($newCollection, $selectedDate);
+
+        $availabilityRepo = new AvailabilityRepository();
+        $existingCollection = $availabilityRepo->readAvailabilityListByScope($scope, 1);
+
+        $mergedCollection = new Collection();
+        foreach ($existingCollection as $existingAvailability) {
+            $mergedCollection->addEntity($existingAvailability);
+        }
+
+        $validations = [];
+        foreach ($newCollection as $newAvailability) {
+            $startDate = (new \DateTimeImmutable())->setTimestamp($newAvailability->startDate);
+            $endDate = (new \DateTimeImmutable())->setTimestamp($newAvailability->endDate);
+            $startDateTime = new \DateTimeImmutable("{$startDate->format('Y-m-d')} {$newAvailability->startTime}");
+            $endDateTime = new \DateTimeImmutable("{$endDate->format('Y-m-d')} {$newAvailability->endTime}");
+
+            $validations = $mergedCollection->validateInputs(
+                $startDateTime,
+                $endDateTime,
+                $selectedDate,
+                $newAvailability->kind ?? 'default',
+                $newAvailability->bookable['startInDays'],
+                $newAvailability->bookable['endInDays']
+            );
+
+            $mergedCollection->addEntity($newAvailability);
+        }
+
+        if (count($validations) > 0) {
+            throw new AvailabilityAddFailed();
+        }
+
+        $originId = null;
+        foreach ($mergedCollection as $availability) {
+            if (isset($availability->kind) && $availability->kind === 'origin' && isset($availability->id)) {
+                $originId = $availability->id;
+                break;
+            }
+        }
+
+        $mergedCollectionWithoutExclusions = new Collection();
+        foreach ($mergedCollection as $availability) {
+            if (
+                (!isset($availability->kind) || $availability->kind !== 'exclusion') &&
+                (!isset($availability->id) || $availability->id !== $originId)
+            ) {
+                $mergedCollectionWithoutExclusions->addEntity($availability);
+            }
+        }
+
+        [$earliestStartDateTime, $latestEndDateTime] = $mergedCollectionWithoutExclusions->getDateTimeRangeFromList(
+            \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $input['selectedDate'] . ' 00:00:00')
+        );
+        $conflicts = $mergedCollectionWithoutExclusions->checkAllVsExistingConflicts($earliestStartDateTime, $latestEndDateTime);
+        if ($conflicts->count() > 0) {
+            throw new AvailabilityAddFailed();
+        }
+
+        $updatedCollection = new Collection();
+        foreach ($newCollection as $entity) {
+            $updatedEntity = $this->writeEntityUpdate($entity, $resolveReferences);
             AvailabilitySlotsUpdate::writeCalculatedSlots($updatedEntity, true);
-            $collection->addEntity($updatedEntity);
+            $updatedCollection->addEntity($updatedEntity);
         }
 
         $message = Response\Message::create($request);
-        $message->data = $collection->getArrayCopy();
+        $message->data = $updatedCollection->getArrayCopy();
 
         $response = Render::withLastModified($response, time(), '0');
-        $response = Render::withJson($response, $message->setUpdatedMetaData(), $message->getStatuscode());
-        return $response;
+        return Render::withJson($response, $message->setUpdatedMetaData(), $message->getStatuscode());
     }
 
-    protected function writeEntityUpdate($entity): Entity
+    protected function writeEntityUpdate($entity, $resolveReferences): Entity
     {
         $repository = new AvailabilityRepository();
         $updatedEntity = null;
         if ($entity->id) {
-            $oldentity = $repository->readEntity($entity->id);
-            if ($oldentity && $oldentity->hasId()) {
-                $this->writeSpontaneousEntity($oldentity);
-                $updatedEntity = $repository->updateEntity($entity->id, $entity, 2);
+            $oldEntity = $repository->readEntity($entity->id);
+            if ($oldEntity !== null && $oldEntity->hasId()) {
+                $this->writeSpontaneousEntity($oldEntity);
+                $updatedEntity = $repository->updateEntity($entity->id, $entity, $resolveReferences);
+            } else {
+                throw new AvailabilityAddFailed("Entity with ID {$entity->id} not found.");
             }
         } else {
             $updatedEntity = $repository->writeEntity($entity, 2);
         }
-        if (! $updatedEntity) {
-            throw new UpdateFailedException();
+        if (!$updatedEntity) {
+            throw new AvailabilityAddFailed();
         }
         return $updatedEntity;
     }
@@ -90,4 +170,40 @@ protected function writeSpontaneousEntity(Entity $entity): void
             (new AvailabilityRepository())->writeEntity($doubleTypesEntity);
         }
     }
-}
+
+    protected function checkNewVsNewConflicts(Collection $collection, \DateTimeImmutable $selectedDate): void
+    {
+        $newAvailabilities = new Collection();
+        foreach ($collection as $availability) {
+            if (isset($availability->tempId) && strpos($availability->tempId, '__temp__') !== false) {
+                $newAvailabilities->addEntity($availability);
+            }
+        }
+
+        foreach ($collection as $availability1) {
+            foreach ($collection as $availability2) {
+                $scope1Id = is_array($availability1->scope) ? ($availability1->scope['id'] ?? null) : ($availability1->scope->id ?? null);
+                $scope2Id = is_array($availability2->scope) ? ($availability2->scope['id'] ?? null) : ($availability2->scope->id ?? null);
+                
+                if ($availability1 !== $availability2 && 
+                    $availability1->type == $availability2->type &&
+                    $scope1Id == $scope2Id &&
+                    $availability1->hasSharedWeekdayWith($availability2)) {
+                    
+                    $start1 = (new \DateTimeImmutable())->setTimestamp($availability1->startDate)
+                        ->modify($availability1->startTime);
+                    $end1 = (new \DateTimeImmutable())->setTimestamp($availability1->endDate)
+                        ->modify($availability1->endTime);
+                    $start2 = (new \DateTimeImmutable())->setTimestamp($availability2->startDate)
+                        ->modify($availability2->startTime);
+                    $end2 = (new \DateTimeImmutable())->setTimestamp($availability2->endDate)
+                        ->modify($availability2->endTime);
+    
+                    if ($start1 < $end2 && $start2 < $end1) {
+                        throw new AvailabilityAddFailed('Neue Öffnungszeiten überschneiden sich.');
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/zmsapi/src/Zmsapi/AvailabilityUpdate.php b/zmsapi/src/Zmsapi/AvailabilityUpdate.php
index 29d656505..732432bd0 100644
--- a/zmsapi/src/Zmsapi/AvailabilityUpdate.php
+++ b/zmsapi/src/Zmsapi/AvailabilityUpdate.php
@@ -1,7 +1,7 @@
 <?php
 /**
  * @package ZMS API
- * @copyright BerlinOnline Stadtportal GmbH & Co. KG
+ * @copyright BerlinOnline Stadtportal GmbH & Co.
  **/
 
 namespace BO\Zmsapi;
@@ -13,12 +13,15 @@
 use BO\Zmsdb\Connection\Select as DbConnection;
 
 use BO\Zmsentities\Availability as Entity;
+use BO\Zmsentities\Collection\AvailabilityList as Collection;
 
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 
 use BO\Zmsapi\AvailabilitySlotsUpdate;
-use BO\Zmsapi\Exception\Availability\AvailabilityNotFound as NotfoundException;
+use BO\Zmsapi\Exception\BadRequest as BadRequestException;
+use BO\Zmsapi\Exception\Availability\AvailabilityNotFound as NotFoundException;
+use BO\Zmsapi\Exception\Availability\AvailabilityUpdateFailed;
 
 /**
  * @SuppressWarnings(Coupling)
@@ -36,25 +39,131 @@ public function readResponse(
         (new Helper\User($request))->checkRights();
         $resolveReferences = Validator::param('resolveReferences')->isNumber()->setDefault(2)->getValue();
         $input = Validator::input()->isJson()->assertValid()->getValue();
-        $entity = new Entity($input);
-        $entity->testValid();
 
-        $availability = (new AvailabilityRepository())->readEntity($args['id'], $resolveReferences);
-        if (! $availability->hasId()) {
-            throw new NotfoundException();
+        if (!$input || count($input) === 0) {
+            throw new BadRequestException();
         }
 
         DbConnection::getWriteConnection();
-        $this->writeSpontaneousEntity($availability);
-        $updatedEntity = (new AvailabilityRepository())->updateEntity($args['id'], $entity, $resolveReferences);
-        AvailabilitySlotsUpdate::writeCalculatedSlots($updatedEntity, true);
+
+        if (!isset($input['availabilityList']) || !is_array($input['availabilityList'])) {
+            throw new BadRequestException('Missing or invalid availabilityList.');
+        } else if(!isset($input['availabilityList'][0]['scope'])){
+            throw new BadRequestException('Missing or invalid scope.');
+        } else if (!isset($input['selectedDate'])) {
+            throw new BadRequestException("'selectedDate' is required.");
+        }    
+        $availabilityRepo = new AvailabilityRepository();
+        $newCollection = new Collection();
+        foreach ($input['availabilityList'] as $item) {
+            $entity = new Entity($item);
+            $entity->testValid();
+            if (isset($entity->id)) {
+                $existingEntity = $availabilityRepo->readEntity($entity->id, $resolveReferences);
+                if (!$existingEntity || !$existingEntity->hasId()) {
+                    throw new NotFoundException("Availability with ID {$entity->id} not found.");
+                }
+            }
+
+            $newCollection->addEntity($entity);
+        }
+
+        $scopeData = $input['availabilityList'][0]['scope'];
+        $scope = new \BO\Zmsentities\Scope($scopeData);
+
+        $selectedDate = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $input['selectedDate'] . ' 00:00:00');
+        $this->checkNewVsNewConflicts($newCollection, $selectedDate);
+
+        $existingCollection = $availabilityRepo->readAvailabilityListByScope($scope, 1);
+
+        $mergedCollection = new Collection();
+        foreach ($existingCollection as $existingAvailability) {
+            $mergedCollection->addEntity($existingAvailability);
+        }
+
+        $validations = [];
+        foreach ($newCollection as $newAvailability) {
+            $startDate = (new \DateTimeImmutable())->setTimestamp($newAvailability->startDate)->format('Y-m-d');
+            $endDate = (new \DateTimeImmutable())->setTimestamp($newAvailability->endDate)->format('Y-m-d');
+            $startDateTime = new \DateTimeImmutable("{$startDate} {$newAvailability->startTime}");
+            $endDateTime = new \DateTimeImmutable("{$endDate} {$newAvailability->endTime}");
+            
+            $validations = $mergedCollection->validateInputs(
+                $startDateTime,
+                $endDateTime,
+                $selectedDate,
+                $newAvailability->kind ?? 'default',
+                $newAvailability->bookable['startInDays'],
+                $newAvailability->bookable['endInDays']
+            );
+
+            $mergedCollection->addEntity($newAvailability);
+        }
+
+        if (count($validations) > 0) {
+            throw new AvailabilityUpdateFailed();
+        }        
+    
+        $originId = null;
+        foreach ($mergedCollection as $availability) {
+            if (isset($availability->kind) && $availability->kind === 'origin' && isset($availability->id)) {
+                $originId = $availability->id;
+                break;
+            }
+        }
+        
+        $mergedCollectionWithoutExclusions = new Collection();
+        foreach ($mergedCollection as $availability) {
+            if ((!isset($availability->kind) || $availability->kind !== 'exclusion') && 
+                (!isset($availability->id) || $availability->id !== $originId)) {
+                $mergedCollectionWithoutExclusions->addEntity($availability);
+            }
+        }
+        
+        [$earliestStartDateTime, $latestEndDateTime] = $mergedCollectionWithoutExclusions->getDateTimeRangeFromList(
+            \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $input['selectedDate'] . ' 00:00:00')
+        );
+        $conflicts = $mergedCollectionWithoutExclusions->checkAllVsExistingConflicts($earliestStartDateTime, $latestEndDateTime);
+        if ($conflicts->count() > 0) {
+            throw new AvailabilityUpdateFailed();
+        }
+
+        $updatedCollection = new Collection();
+        foreach ($newCollection as $entity) {
+            $updatedEntity = $this->writeEntityUpdate($entity, $resolveReferences);
+            AvailabilitySlotsUpdate::writeCalculatedSlots($updatedEntity, true);
+            $updatedCollection->addEntity($updatedEntity);
+        }
 
         $message = Response\Message::create($request);
-        $message->data = $updatedEntity;
+        $message->data = $updatedCollection->getArrayCopy();
 
         $response = Render::withLastModified($response, time(), '0');
-        $response = Render::withJson($response, $message->setUpdatedMetaData(), $message->getStatuscode());
-        return $response;
+        return Render::withJson($response, $message->setUpdatedMetaData(), $message->getStatuscode());
+    }
+
+    protected function writeEntityUpdate($entity, $resolveReferences): Entity
+    {
+        $repository = new AvailabilityRepository();
+        $updatedEntity = null;
+
+        if ($entity->id) {
+            $oldEntity = $repository->readEntity($entity->id);
+            if ($oldEntity !== null && $oldEntity->hasId()) {
+                $this->writeSpontaneousEntity($oldEntity);
+                $updatedEntity = $repository->updateEntity($entity->id, $entity, $resolveReferences);
+            } else {
+                throw new AvailabilityUpdateFailed("Entity with ID {$entity->id} not found.");
+            }
+        } else {
+            $updatedEntity = $repository->writeEntity($entity, 2);
+        }
+
+        if (!$updatedEntity) {
+            throw new AvailabilityUpdateFailed();
+        }
+
+        return $updatedEntity;
     }
 
     protected function writeSpontaneousEntity(Entity $entity): void
@@ -69,4 +178,40 @@ protected function writeSpontaneousEntity(Entity $entity): void
             (new AvailabilityRepository())->writeEntity($doubleTypesEntity);
         }
     }
+
+    protected function checkNewVsNewConflicts(Collection $collection, \DateTimeImmutable $selectedDate): void
+    {
+        $newAvailabilities = new Collection();
+        foreach ($collection as $availability) {
+            if (isset($availability->tempId) && strpos($availability->tempId, '__temp__') !== false) {
+                $newAvailabilities->addEntity($availability);
+            }
+        }
+
+        foreach ($collection as $availability1) {
+            foreach ($collection as $availability2) {
+                $scope1Id = is_array($availability1->scope) ? ($availability1->scope['id'] ?? null) : ($availability1->scope->id ?? null);
+                $scope2Id = is_array($availability2->scope) ? ($availability2->scope['id'] ?? null) : ($availability2->scope->id ?? null);
+                
+                if ($availability1 !== $availability2 && 
+                    $availability1->type == $availability2->type &&
+                    $scope1Id == $scope2Id &&
+                    $availability1->hasSharedWeekdayWith($availability2)) {
+                    
+                    $start1 = (new \DateTimeImmutable())->setTimestamp($availability1->startDate)
+                        ->modify($availability1->startTime);
+                    $end1 = (new \DateTimeImmutable())->setTimestamp($availability1->endDate)
+                        ->modify($availability1->endTime);
+                    $start2 = (new \DateTimeImmutable())->setTimestamp($availability2->startDate)
+                        ->modify($availability2->startTime);
+                    $end2 = (new \DateTimeImmutable())->setTimestamp($availability2->endDate)
+                        ->modify($availability2->endTime);
+    
+                    if ($start1 < $end2 && $start2 < $end1) {
+                        throw new AvailabilityUpdateFailed('Neue Öffnungszeiten überschneiden sich.');
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityAddFailed.php b/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityAddFailed.php
new file mode 100644
index 000000000..339905244
--- /dev/null
+++ b/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityAddFailed.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace BO\Zmsapi\Exception\Availability;
+
+/**
+ * example class to generate an exception
+ */
+class AvailabilityAddFailed extends \Exception
+{
+    protected $code = 400;
+
+    protected $message = 'Failed to create availability. Please ensure there are no conflicts with existing entries.';
+
+}
diff --git a/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityUpdateFailed.php b/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityUpdateFailed.php
index 5a0d61a43..549934ce6 100644
--- a/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityUpdateFailed.php
+++ b/zmsapi/src/Zmsapi/Exception/Availability/AvailabilityUpdateFailed.php
@@ -9,5 +9,5 @@ class AvailabilityUpdateFailed extends \Exception
 {
     protected $code = 400;
 
-    protected $message = 'Could not insert or update availablity';
+    protected $message = 'Could not update availability.';
 }
diff --git a/zmsapi/tests/Zmsapi/AvailabilityAddTest.php b/zmsapi/tests/Zmsapi/AvailabilityAddTest.php
index 9f69e7cf4..7259e89bc 100644
--- a/zmsapi/tests/Zmsapi/AvailabilityAddTest.php
+++ b/zmsapi/tests/Zmsapi/AvailabilityAddTest.php
@@ -2,6 +2,8 @@
 
 namespace BO\Zmsapi\Tests;
 
+use BO\Zmsapi\Exception\Availability\AvailabilityAddFailed;
+use \DateTime;
 class AvailabilityAddTest extends Base
 {
     protected $classname = "AvailabilityAdd";
@@ -9,27 +11,133 @@ class AvailabilityAddTest extends Base
     public function testRendering()
     {
         $this->setWorkstation();
+
         $response = $this->render([], [
-            '__body' => '[
-                {
-                    "id": 21202,
-                    "description": "Test Öffnungszeit update",
-                    "scope": {
-                        "id": 312
-                    }
-                },
-                {
-                    "description": "Test Öffnungszeit ohne id",
-                    "scope": {
-                        "id": 141
-                    }
-                }
-            ]'
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => 21202,
+                        "description" => "Test Öffnungszeit update",
+                        "startDate" => time() + (2 * 24 * 60 * 60), // 2 days in the future
+                        "endDate" => time() + (5 * 24 * 60 * 60),   // 5 days in the future
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312
+                        ]
+                    ],
+                    [
+                        "description" => "Test Öffnungszeit ohne id",
+                        "startDate" => time() + (1 * 24 * 60 * 60), // 1 day in the future
+                        "endDate" => time() + (4 * 24 * 60 * 60),   // 4 days in the future
+                        "startTime" => "10:00:00",
+                        "endTime" => "16:30:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 141
+                        ]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
         ], []);
+
         $this->assertStringContainsString('availability.json', (string)$response->getBody());
         $this->assertTrue(200 == $response->getStatusCode());
     }
 
+    public function testOverlappingAvailability()
+    {
+        $this->setWorkstation();
+        $this->expectException(AvailabilityAddFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => 21202,
+                        "description" => "Overlapping Entry 1",
+                        "startDate" => time() + (2 * 24 * 60 * 60),
+                        "endDate" => time() + (3 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => ["id" => 312]
+                    ],
+                    [
+                        "id" => 21203,
+                        "description" => "Overlapping Entry 2",
+                        "startDate" => time() + (2 * 24 * 60 * 60),
+                        "endDate" => time() + (3 * 24 * 60 * 60),
+                        "startTime" => "10:00:00",
+                        "endTime" => "18:00:00",
+                        "kind" => "default",
+                        "scope" => ["id" => 312]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
+    public function testDuplicateOverlappingAvailability()
+    {
+        $this->setWorkstation();
+        $this->expectException(AvailabilityAddFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => 21202,
+                        "description" => "Duplicate Entry 1",
+                        "startDate" => time() + (3 * 24 * 60 * 60),
+                        "endDate" => time() + (4 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => ["id" => 312]
+                    ],
+                    [
+                        "id" => 21203,
+                        "description" => "Duplicate Entry 2",
+                        "startDate" => time() + (3 * 24 * 60 * 60),
+                        "endDate" => time() + (4 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => ["id" => 312]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
+    public function testInvalidEndTime()
+    {
+        $this->setWorkstation();
+        $this->expectException(AvailabilityAddFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "description" => "End Time Before Start Time",
+                        "startDate" => time() + (2 * 24 * 60 * 60),
+                        "endDate" => time() + (2 * 24 * 60 * 60),
+                        "startTime" => "17:00:00",
+                        "endTime" => "09:00:00",
+                        "kind" => "default",
+                        "scope" => ["id" => 312]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
     public function testEmpty()
     {
         $this->setWorkstation();
@@ -47,21 +155,23 @@ public function testEmptyBody()
         ], []);
     }
 
-    public function testUpdateFailed()
+    public function testAddFailed()
     {
         $this->setWorkstation();
-        $this->expectException('\BO\Zmsapi\Exception\Availability\AvailabilityUpdateFailed');
+        $this->expectException('\BO\Zmsapi\Exception\Availability\AvailabilityAddFailed');
         $this->expectExceptionCode(400);
+
         $this->render([], [
-            '__body' => '[
-                {
-                  "id": 99999,
-                  "description": "Test Öffnungszeit update failed",
-                  "scope": {
-                      "id": 312
-                  }
-                }
-            ]',
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => 99999,
+                        "description" => "Test Öffnungszeit update failed",
+                        "scope" => ["id" => 312]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ]),
             'migrationfix' => 0
         ], []);
     }
diff --git a/zmsapi/tests/Zmsapi/AvailabilityUpdateTest.php b/zmsapi/tests/Zmsapi/AvailabilityUpdateTest.php
index 736c7acf8..87fcd0603 100644
--- a/zmsapi/tests/Zmsapi/AvailabilityUpdateTest.php
+++ b/zmsapi/tests/Zmsapi/AvailabilityUpdateTest.php
@@ -2,9 +2,9 @@
 
 namespace BO\Zmsapi\Tests;
 
-use \BO\Zmsentities\Availability as Entity;
-
-use \BO\Zmsdb\Availability as Query;
+use BO\Zmsentities\Availability as Entity;
+use BO\Zmsdb\Availability as Query;
+use BO\Zmsapi\Exception\Availability\AvailabilityUpdateFailed;
 
 class AvailabilityUpdateTest extends Base
 {
@@ -13,21 +13,358 @@ class AvailabilityUpdateTest extends Base
     public function testRendering()
     {
         $input = (new Entity)->createExample();
+        $currentTimestamp = time();
+        $input['startDate'] = $currentTimestamp + (2 * 24 * 60 * 60); // 2 days in the future
+        $input['endDate'] = $currentTimestamp + (5 * 24 * 60 * 60);   // 5 days in the future
+        $input['startTime'] = "09:00:00";
+        $input['endTime'] = "17:00:00";
+        $input['scope'] = [
+            "id" => 312,
+            "dayoff" => [
+                [
+                    "id" => 35,
+                    "date" => $currentTimestamp + (7 * 24 * 60 * 60), // 7 days in the future
+                    "name" => "1. Mai",
+                    "lastChange" => $currentTimestamp
+                ],
+                [
+                    "id" => 36,
+                    "date" => $currentTimestamp + (14 * 24 * 60 * 60), // 14 days in the future
+                    "name" => "Christi Himmelfahrt",
+                    "lastChange" => $currentTimestamp
+                ]
+            ]
+        ];
+        $input['kind'] = "default";
+
         $entity = (new Query())->writeEntity($input);
         $this->setWorkstation();
-        $response = $this->render(["id"=> $entity->getId()], [
-            '__body' => '{
-                  "id": '. $entity->getId() .',
-                  "description": "",
-                  "scope": {
-                      "id": 312
-                  }
-              }'
+
+        $response = $this->render([
+            "id" => $entity->getId()
+        ], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => $entity->getId(),
+                        "description" => "Test Öffnungszeit update",
+                        "startDate" => $currentTimestamp + (2 * 24 * 60 * 60),
+                        "endDate" => $currentTimestamp + (5 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (7 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (14 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
         ], []);
-        $this->assertStringContainsString('availability.json', (string)$response->getBody());
+
+        $this->assertStringContainsString('availability.json', (string) $response->getBody());
         $this->assertTrue(200 == $response->getStatusCode());
     }
 
+    public function testDuplicateOverlappingAvailability()
+    {
+
+        $input = (new Entity)->createExample();
+        $currentTimestamp = time();
+        $input['startDate'] = $currentTimestamp + (20 * 24 * 60 * 60); // 2 days in the future
+        $input['endDate'] = $currentTimestamp + (50 * 24 * 60 * 60);   // 5 days in the future
+        $input['startTime'] = "09:00:00";
+        $input['endTime'] = "17:00:00";
+        $input['scope'] = [
+            "id" => 312,
+            "dayoff" => [
+                [
+                    "id" => 35,
+                    "date" => $currentTimestamp + (70 * 24 * 60 * 60), // 7 days in the future
+                    "name" => "1. Mai",
+                    "lastChange" => $currentTimestamp
+                ],
+                [
+                    "id" => 36,
+                    "date" => $currentTimestamp + (140 * 24 * 60 * 60), // 14 days in the future
+                    "name" => "Christi Himmelfahrt",
+                    "lastChange" => $currentTimestamp
+                ]
+            ]
+        ];
+        $input['kind'] = "default";
+
+        $entity = (new Query())->writeEntity($input);
+        $secondEntity = (new Query())->writeEntity($input);
+        $this->setWorkstation();
+        $currentTimestamp = time();
+        $this->expectException(AvailabilityUpdateFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => $entity->getId(),
+                        "description" => "Duplicate Entry 1",
+                        "startDate" => $currentTimestamp + (20 * 24 * 60 * 60),
+                        "endDate" => $currentTimestamp + (20 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (70 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (140 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ],
+
+                    ],
+                    [
+                        "id" => $secondEntity->getId(),
+                        "description" => "Duplicate Entry 2",
+                        "startDate" => $currentTimestamp + (20 * 24 * 60 * 60),
+                        "endDate" => $currentTimestamp + (20 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (70 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (140 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
+    public function testOverlappingAvailability()
+    {
+
+        $input = (new Entity)->createExample();
+        $currentTimestamp = time();
+        $input['startDate'] = $currentTimestamp + (20 * 24 * 60 * 60); // 2 days in the future
+        $input['endDate'] = $currentTimestamp + (50 * 24 * 60 * 60);   // 5 days in the future
+        $input['startTime'] = "09:00:00";
+        $input['endTime'] = "17:00:00";
+        $input['scope'] = [
+            "id" => 312,
+            "dayoff" => [
+                [
+                    "id" => 35,
+                    "date" => $currentTimestamp + (70 * 24 * 60 * 60), // 7 days in the future
+                    "name" => "1. Mai",
+                    "lastChange" => $currentTimestamp
+                ],
+                [
+                    "id" => 36,
+                    "date" => $currentTimestamp + (140 * 24 * 60 * 60), // 14 days in the future
+                    "name" => "Christi Himmelfahrt",
+                    "lastChange" => $currentTimestamp
+                ]
+            ]
+        ];
+        $input['kind'] = "default";
+
+
+        $secondInput = (new Entity)->createExample();
+        $currentTimestamp = time();
+        $secondInput['startDate'] = $currentTimestamp + (20 * 24 * 60 * 60); // 2 days in the future
+        $secondInput['endDate'] = $currentTimestamp + (50 * 24 * 60 * 60);   // 5 days in the future
+        $secondInput['startTime'] = "10:00:00";
+        $secondInput['endTime'] = "20:00:00";
+        $secondInput['scope'] = [
+            "id" => 312,
+            "dayoff" => [
+                [
+                    "id" => 35,
+                    "date" => $currentTimestamp + (70 * 24 * 60 * 60), // 7 days in the future
+                    "name" => "1. Mai",
+                    "lastChange" => $currentTimestamp
+                ],
+                [
+                    "id" => 36,
+                    "date" => $currentTimestamp + (140 * 24 * 60 * 60), // 14 days in the future
+                    "name" => "Christi Himmelfahrt",
+                    "lastChange" => $currentTimestamp
+                ]
+            ]
+        ];
+        $secondInput['kind'] = "default";
+
+        $entity = (new Query())->writeEntity($input);
+        $secondEntity = (new Query())->writeEntity($secondInput);
+        $this->setWorkstation();
+        $currentTimestamp = time();
+        $this->expectException(AvailabilityUpdateFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => $entity->getId(),
+                        "description" => "Duplicate Entry 1",
+                        "startDate" => $currentTimestamp + (200 * 24 * 60 * 60),
+                        "endDate" => $currentTimestamp + (200 * 24 * 60 * 60),
+                        "startTime" => "09:00:00",
+                        "endTime" => "17:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (700 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (1400 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ],
+
+                    ],
+                    [
+                        "id" => $secondEntity->getId(), // Duplicate ID
+                        "description" => "Duplicate Entry 2",
+                        "startDate" => $currentTimestamp + (200 * 24 * 60 * 60),
+                        "endDate" => $currentTimestamp + (200 * 24 * 60 * 60),
+                        "startTime" => "10:00:00",
+                        "endTime" => "20:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (700 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (1400 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
+    public function testInvalidEndTime()
+    {
+
+        $input = (new Entity)->createExample();
+        $currentTimestamp = time();
+        $input['startDate'] = $currentTimestamp + (20 * 24 * 60 * 60); // 2 days in the future
+        $input['endDate'] = $currentTimestamp + (20 * 24 * 60 * 60);
+        $input['startTime'] = "17:00:00";
+        $input['endTime'] = "09:00:00";
+        $input['scope'] = [
+            "id" => 312,
+            "dayoff" => [
+                [
+                    "id" => 35,
+                    "date" => $currentTimestamp + (70 * 24 * 60 * 60), // 7 days in the future
+                    "name" => "1. Mai",
+                    "lastChange" => $currentTimestamp
+                ],
+                [
+                    "id" => 36,
+                    "date" => $currentTimestamp + (140 * 24 * 60 * 60), // 14 days in the future
+                    "name" => "Christi Himmelfahrt",
+                    "lastChange" => $currentTimestamp
+                ]
+            ]
+        ];
+        $input['kind'] = "default";
+
+        $entity = (new Query())->writeEntity($input);
+        $this->setWorkstation();
+        $this->expectException(AvailabilityUpdateFailed::class);
+
+        $this->render([], [
+            '__body' => json_encode([
+                'availabilityList' => [
+                    [
+                        "id" => $entity->getId(),
+                        "description" => "End Time Before Start Time",
+                        "startDate" => time() + (20 * 24 * 60 * 60),
+                        "endDate" => time() + (20 * 24 * 60 * 60),
+                        "startTime" => "17:00:00",
+                        "endTime" => "09:00:00",
+                        "kind" => "default",
+                        "scope" => [
+                            "id" => 312,
+                            "dayoff" => [
+                                [
+                                    "id" => 35,
+                                    "date" => $currentTimestamp + (70 * 24 * 60 * 60),
+                                    "name" => "1. Mai",
+                                    "lastChange" => $currentTimestamp
+                                ],
+                                [
+                                    "id" => 36,
+                                    "date" => $currentTimestamp + (140 * 24 * 60 * 60),
+                                    "name" => "Christi Himmelfahrt",
+                                    "lastChange" => $currentTimestamp
+                                ]
+                            ]
+                        ]
+                    ]
+                ],
+                'selectedDate' => date('Y-m-d')
+            ])
+        ], []);
+    }
+
     public function testEmpty()
     {
         $this->setWorkstation();
@@ -40,14 +377,22 @@ public function testNotFound()
         $this->setWorkstation();
         $this->expectException('\BO\Zmsapi\Exception\Availability\AvailabilityNotFound');
         $this->expectExceptionCode(404);
-        $this->render(["id"=> 1], [
-            '__body' => '{
-                  "id": 1,
-                  "description": "Test Öffnungszeit not found",
-                  "scope": {
-                      "id": 312
-                  }
-              }'
-        ], []);
+
+        $this->render(
+            ["id" => 1],
+            [
+                '__body' => json_encode([
+                    'availabilityList' => [
+                        [
+                            "id" => 1,
+                            "description" => "Test Öffnungszeit not found",
+                            "scope" => ["id" => 312]
+                        ]
+                    ],
+                    'selectedDate' => date('Y-m-d')
+                ])
+            ],
+            []
+        );
     }
 }
diff --git a/zmsdb/src/Zmsdb/Process.php b/zmsdb/src/Zmsdb/Process.php
index 352ba7ab1..a5e49b6cc 100755
--- a/zmsdb/src/Zmsdb/Process.php
+++ b/zmsdb/src/Zmsdb/Process.php
@@ -492,7 +492,7 @@ public function readConflictListByScopeAndTime(
             $endDate = $startDate;
         }
         $currentDate = ($startDate) ? $startDate : $now;
-        $conflictList = $availabilityList->getConflicts($startDate, $endDate);
+        $conflictList = $availabilityList->checkAllVsExistingConflicts($startDate, $endDate);
         while ($currentDate <= $endDate) {
             $query = new Query\Process(Query\Base::SELECT);
             $query
diff --git a/zmsdb/tests/Zmsdb/AvailabilityTest.php b/zmsdb/tests/Zmsdb/AvailabilityTest.php
index 2c2f1abd5..8342d8c5a 100644
--- a/zmsdb/tests/Zmsdb/AvailabilityTest.php
+++ b/zmsdb/tests/Zmsdb/AvailabilityTest.php
@@ -74,7 +74,7 @@ public function testWriteEntity()
         $lastInsertedId = $entity->id;
 
         $entity = $query->readEntity($lastInsertedId, 1);
-        $this->assertEquals(12, $entity->slotTimeInMinutes);
+        $this->assertEquals(10, $entity->slotTimeInMinutes);
         $this->assertTrue((bool)$entity->weekday['thursday']);
         $this->assertTrue((bool)$entity->weekday['friday']);
 
diff --git a/zmsdb/tests/Zmsdb/ProcessConflictTest.php b/zmsdb/tests/Zmsdb/ProcessConflictTest.php
index 48b5f70e3..e04c67be2 100644
--- a/zmsdb/tests/Zmsdb/ProcessConflictTest.php
+++ b/zmsdb/tests/Zmsdb/ProcessConflictTest.php
@@ -53,8 +53,8 @@ public function testOverbookedOnDay()
     }
 
     /*
-    * Test a single day availability without repeats but with conflicts out of availability start and enttime
-    */
+     * Test a single day availability without repeats but with conflicts out of availability start and enttime
+     */
 
     public function testSingleDayOutOfAvailability()
     {
@@ -100,7 +100,9 @@ public function testEqual()
         (new \BO\Zmsdb\Availability())->writeEntity($availabilityCopy);
         $conflictList = (new \BO\Zmsdb\Process())->readConflictListByScopeAndTime($scope, $startDate, null, $now, 0);
         $this->assertEquals(2, $conflictList->count());
-        $this->assertEquals('Zwei Öffnungszeiten sind gleich.', $conflictList->getFirst()->getAmendment());
+        $this->assertEquals("Konflikt: Zwei Öffnungszeiten sind gleich.\n" .
+            "Bestehende Öffnungszeit:&thinsp;&thinsp;[30.01.2016 - 22.05.2016, 08:00 - 13:50]\n" .
+            "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[30.01.2016 - 22.05.2016, 08:00 - 13:50]", $conflictList->getFirst()->getAmendment());
         $this->assertEquals('conflict', $conflictList->getFirst()->getStatus());
     }
 
@@ -115,7 +117,9 @@ public function testOverLap()
         (new \BO\Zmsdb\Availability())->writeEntity($availabilityCopy);
         $conflictList = (new \BO\Zmsdb\Process())->readConflictListByScopeAndTime($scope, $startDate, null, $now, 0);
         $this->assertEquals(2, $conflictList->count());
-        $this->assertEquals('Zwei Öffnungszeiten überschneiden sich.', $conflictList->getFirst()->getAmendment());
+        $this->assertEquals("Konflikt: Zwei Öffnungszeiten überschneiden sich.\n" .
+            "Bestehende Öffnungszeit:&thinsp;&thinsp;[30.01.2016 - 22.05.2016, 08:00 - 15:50]\n" .
+            "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[30.01.2016 - 22.05.2016, 08:00 - 13:50]", $conflictList->getFirst()->getAmendment());
         $this->assertEquals('conflict', $conflictList->getFirst()->getStatus());
     }
 }
diff --git a/zmsentities/schema/availability.json b/zmsentities/schema/availability.json
index d71c1fdfc..99a98d31a 100644
--- a/zmsentities/schema/availability.json
+++ b/zmsentities/schema/availability.json
@@ -18,7 +18,7 @@
     "scope": {
       "id": 141
     },
-    "slotTimeInMinutes": 12,
+    "slotTimeInMinutes": 10,
     "startDate": 1447919543,
     "startTime": "10:00",
     "weekday": {
@@ -119,6 +119,10 @@
       "type": "string",
       "description": "format '0:00' or '17:30'"
     },
+    "kind": {
+      "type": "string",
+      "description": "format"
+    },
     "type": {
       "type": "string",
       "enum": [
diff --git a/zmsentities/src/Zmsentities/Availability.php b/zmsentities/src/Zmsentities/Availability.php
index f73338259..3b028d6ea 100644
--- a/zmsentities/src/Zmsentities/Availability.php
+++ b/zmsentities/src/Zmsentities/Availability.php
@@ -112,7 +112,7 @@ public function hasBookableDates(\DateTimeInterface $now)
      * ATTENTION: Time critical function, keep highly optimized
      *
      * @param \DateTimeInterface $dateTime
-     * @param String $type of "openinghours", "appointment" or false to ignore type
+     * @param string $type of "openinghours", "appointment" or false to ignore type
      *
      * @return Bool
      */
@@ -136,7 +136,7 @@ public function isOpenedOnDate(\DateTimeInterface $dateTime, $type = false)
      * Compared to hasDate() the time of the day is checked, but not booking time
      *
      * @param \DateTimeInterface $dateTime
-     * @param String $type of "openinghours", "appointment" or false to ignore type
+     * @param string $type of "openinghours", "appointment" or false to ignore type
      *
      */
     public function isOpened(\DateTimeInterface $dateTime, $type = false)
@@ -434,7 +434,7 @@ public function getSlotTimeInMinutes()
      *
      * @return Array of arrays with the keys time, public, callcenter, intern
      */
-    public function hasDateBetween(\DateTimeInterface $startTime, \DateTimeInterface $stopTime, \DateTimeInterface $now)
+    public function hasDateBetween(\DateTimeInterface $startTime, \DateTimeInterface $stopTime, \DateTimeInterface $now): bool
     {
         if ($startTime->getTimestamp() < $now->getTimestamp()) {
             $startTime = $now;
@@ -450,7 +450,143 @@ public function hasDateBetween(\DateTimeInterface $startTime, \DateTimeInterface
         } while ($startTime->getTimestamp() <= $stopTime->getTimestamp());
         return false;
     }
+    public function validateStartTime(\DateTimeInterface $today, \DateTimeInterface $tomorrow, \DateTimeInterface $startDate, \DateTimeInterface $endDate, \DateTimeInterface $selectedDate, string $kind): array
+    {
+        $errorList = [];
+        
+        $startTime = (clone $startDate)->setTime(0, 0);
+        $startHour = ($startDate->format('H'));
+        $endHour = (int)$endDate->format('H');
+        $startMinute = (int)$startDate->format('i');
+        $endMinute = (int)$endDate->format('i');
+        $isFuture = ($kind && $kind === 'future');
+
+        if (
+            !$isFuture &&
+            $selectedDate->getTimestamp() > $today->getTimestamp() &&
+            $startTime->getTimestamp() > (clone $selectedDate)->setTime(0, 0)->getTimestamp()
+        ) {
+            $errorList[] = [
+                'type' => 'startTimeFuture',
+                'message' => "Das Startdatum der Öffnungszeit muss vor dem " . $tomorrow->format('d.m.Y') . " liegen."
+            ];
+        }
+        
+        if ($startHour >= 23 || $startHour === 0 || $endHour >= 23 || $endHour === 0) {
+            $errorList[] = [
+                'type' => 'startOfDay',
+                'message' => 'Die Uhrzeit darf nicht zwischen 23:00 und 01:00 liegen, da in diesem Zeitraum der tägliche Cronjob ausgeführt wird.'
+            ];
+        }
+        
+        return $errorList;
+    }  
+    public function validateEndTime(\DateTimeInterface $startDate, \DateTimeInterface $endDate): array
+    {
+        $errorList = [];
+        
+        $startHour = (int)$startDate->format('H');
+        $endHour = (int)$endDate->format('H');
+        $startMinute = (int)$startDate->format('i');
+        $endMinute = (int)$endDate->format('i');
+        $dayMinutesStart = ($startHour * 60) + $startMinute;
+        $dayMinutesEnd = ($endHour * 60) + $endMinute;
+        $startTimestamp = $startDate->getTimestamp();
+        $endTimestamp = $endDate->getTimestamp();
+
+        if ($dayMinutesEnd <= $dayMinutesStart) {
+            $errorList[] = [
+                'type' => 'endTime',
+                'message' => 'Die Endzeit darf nicht vor der Startzeit liegen.'
+            ];
+        } elseif ($startTimestamp >= $endTimestamp) {
+            $errorList[] = [
+                'type' => 'endTime',
+                'message' => 'Das Enddatum darf nicht vor dem Startdatum liegen.'
+            ];
+        }
+        
+        return $errorList;
+    }
+    
+    public function validateOriginEndTime(\DateTimeInterface $today, \DateTimeInterface $yesterday, \DateTimeInterface $startDate, \DateTimeInterface $endDate, \DateTimeInterface $selectedDate, string $kind): array
+    {
+        $errorList = [];
+        $endHour = (int) $endDate->format('H');
+        $endMinute = (int) $endDate->format('i');
+        $endDateTime = (clone $endDate)->setTime($endHour, $endMinute);
+        $endTimestamp = $endDateTime->getTimestamp();
+        $isOrigin = ($kind && $kind === 'origin');
+    
+        if (!$isOrigin && $selectedDate->getTimestamp() > $today->getTimestamp() && $endDate < (clone $selectedDate)->setTime(0, 0)) {
+            $errorList[] = [
+                'type' => 'endTimeFuture',
+                'message' => "Das Enddatum der Öffnungszeit muss nach dem " . $yesterday->format('d.m.Y') . " liegen."
+            ];
+        }
+    
+        if (!$isOrigin && $endTimestamp < $today->getTimestamp()) {
+            $errorList[] = [
+                'type' => 'endTimePast',
+                'message' => 'Öffnungszeiten in der Vergangenheit lassen sich nicht bearbeiten '
+                    . '(Die aktuelle Zeit "' . $today->format('d.m.Y H:i') . ' Uhr" liegt nach dem Terminende am "'
+                    . $endDateTime->format('d.m.Y H:i') . ' Uhr").'
+            ];
+        }
+    
+        return $errorList;
+    }
+    
+    public function validateType(string $kind): array
+    {
+        $errorList = [];
+        if (empty($kind)) {
+            $errorList[] = [
+                'type' => 'type',
+                'message' => 'Typ erforderlich'
+            ];
+        }
+        return $errorList;
+    }
+    
+    public function validateSlotTime(\DateTimeInterface $startDate, \DateTimeInterface $endDate): array
+    {
+        $errorList = [];
+        $slotTime = $this['slotTimeInMinutes'];
+        $startTimestamp = $startDate->getTimestamp();
+        $endTimestamp = $endDate->getTimestamp();
+
+        if ($slotTime === 0) { 
+            $errorList[] = [
+                'type' => 'slotTime', 
+                'message' => 'Die Slot-Zeit darf nicht 0 sein.']; 
+            return $errorList;
+        }
+    
+        $slotAmount = (($endTimestamp - $startTimestamp) / 60) % $slotTime;
+        if ($slotAmount > 0) {
+            $errorList[] = [
+                'type' => 'slotCount',
+                'message' => 'Zeitschlitze müssen sich gleichmäßig in der Öffnungszeit aufteilen lassen.'
+            ];
+        }
+    
+        return $errorList;
+    }
 
+    public function validateBookableDayRange(int $startInDays, int $endInDays): array
+    {
+        $errorList = [];
+        if ($startInDays > $endInDays) {
+            $errorList[] = [
+                'type' => 'bookableDayRange',
+                'message' => 'Bitte geben Sie im Feld \'von\' eine kleinere Zahl ein als im Feld \'bis\', wenn Sie bei \'Buchbar\' sind.'
+            ];
+        }
+    
+        return $errorList;
+    }
+    
     /**
      * Get problems on configuration of this availability
      *
@@ -632,35 +768,41 @@ public function getTimeOverlaps(Availability $availability, \DateTimeInterface $
             && $this->hasSharedWeekdayWith($availability)
         ) {
             $processTemplate = new Process();
-            $processTemplate->amendment = "Zwei Öffnungszeiten überschneiden sich.";
             $processTemplate->status = 'conflict';
             $appointment = $processTemplate->getFirstAppointment();
             $appointment->availability = $this;
             $appointment->date = $this->getStartDateTime()->getTimestamp();
-            $thisStart = $this->getStartDateTime()->getSecondsOfDay();
-            $thisEnd = $this->getEndDateTime()->getSecondsOfDay();
-            $availabilityStart = $availability->getStartDateTime()->getSecondsOfDay();
-            $availabilityEnd = $availability->getEndDateTime()->getSecondsOfDay();
-
-            $isEqual = ($availabilityStart == $thisStart && $availabilityEnd == $thisEnd);
-                
-            if ($availabilityStart < $thisEnd && $thisStart < $availabilityEnd && ! $isEqual) {
-                $process = clone $processTemplate;
-                $process->getFirstAppointment()->date = $this
-                    ->getStartDateTime()
-                    ->modify($currentDate->format("Y-m-d"))
-                    ->getTimestamp();
-                $processList->addEntity($process);
-            } elseif ($thisEnd < $availabilityStart && $availabilityEnd < $thisStart && ! $isEqual) {
+    
+            $existingDateRange = $this->getStartDateTime()->format('d.m.Y') . ' - ' . $this->getEndDateTime()->format('d.m.Y');
+            $newDateRange = $availability->getStartDateTime()->format('d.m.Y') . ' - ' . $availability->getEndDateTime()->format('d.m.Y');
+            
+            $existingTimeRange = $this->getStartDateTime()->format('H:i') . ' - ' . $this->getEndDateTime()->format('H:i');
+            $newTimeRange = $availability->getStartDateTime()->format('H:i') . ' - ' . $availability->getEndDateTime()->format('H:i');
+    
+            // Compare exact times without seconds
+            $start1 = $this->getStartDateTime()->format('H:i');
+            $end1 = $this->getEndDateTime()->format('H:i');
+            $start2 = $availability->getStartDateTime()->format('H:i');
+            $end2 = $availability->getEndDateTime()->format('H:i');
+    
+            $isEqual = ($start1 === $start2 && $end1 === $end2);
+            
+            if ($isEqual) {
                 $process = clone $processTemplate;
+                $process->amendment = "Konflikt: Zwei Öffnungszeiten sind gleich.\n"
+                                    . "Bestehende Öffnungszeit:&thinsp;&thinsp;[$newDateRange, $newTimeRange]\n"
+                                    . "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[$existingDateRange, $existingTimeRange]";
                 $process->getFirstAppointment()->date = $availability
                     ->getStartDateTime()
                     ->modify($currentDate->format("Y-m-d"))
                     ->getTimestamp();
                 $processList->addEntity($process);
-            } elseif ($isEqual) {
+            }
+            elseif ($start2 < $end1 && $start1 < $end2) {
                 $process = clone $processTemplate;
-                $process->amendment = "Zwei Öffnungszeiten sind gleich.";
+                $process->amendment = "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n"
+                                    . "Bestehende Öffnungszeit:&thinsp;&thinsp;[$newDateRange, $newTimeRange]\n"
+                                    . "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[$existingDateRange, $existingTimeRange]";
                 $process->getFirstAppointment()->date = $availability
                     ->getStartDateTime()
                     ->modify($currentDate->format("Y-m-d"))
@@ -668,6 +810,7 @@ public function getTimeOverlaps(Availability $availability, \DateTimeInterface $
                 $processList->addEntity($process);
             }
         }
+    
         return $processList;
     }
 
diff --git a/zmsentities/src/Zmsentities/Collection/AvailabilityList.php b/zmsentities/src/Zmsentities/Collection/AvailabilityList.php
index f4606aae2..3256a8b5a 100644
--- a/zmsentities/src/Zmsentities/Collection/AvailabilityList.php
+++ b/zmsentities/src/Zmsentities/Collection/AvailabilityList.php
@@ -18,7 +18,7 @@ public function getMaxWorkstationCount()
     {
         $max = 0;
         foreach ($this as $availability) {
-            if ($availability['workstationCount']['intern'] >  $max) {
+            if ($availability['workstationCount']['intern'] > $max) {
                 $max = $availability['workstationCount']['intern'];
             }
         }
@@ -161,7 +161,79 @@ public function getSlotListByType($type)
         return $slotList;
     }
 
-    public function getConflicts($startDate, $endDate)
+    /**
+    * Validates availability inputs against business rules and time constraints
+    *
+    * @param \DateTimeImmutable $startDate    The start date to validate
+    * @param \DateTimeImmutable $endDate      The end date to validate
+    * @param \DateTimeImmutable $selectedDate The selected date for context
+    * @param string $kind                     The type of validation to perform
+    *
+    * @return array<string> List of validation errors
+    */
+    public function validateInputs(\DateTimeImmutable $startDate, \DateTimeImmutable $endDate, \DateTimeImmutable $selectedDate, string $kind, $startInDays, $endInDays): array
+    {
+        $errorList = [];
+
+        $today = new \DateTimeImmutable();
+        $yesterday = $selectedDate->modify('-1 day');
+        $tomorrow = $selectedDate->modify('+1 day');
+
+        foreach ($this as $availability) {
+            $errorList = array_merge($errorList,
+                $availability->validateStartTime($today, $tomorrow, $startDate, $endDate, $selectedDate, $kind),
+                $availability->validateEndTime($startDate, $endDate),
+                $availability->validateOriginEndTime($today, $yesterday, $startDate, $endDate, $selectedDate, $kind),
+                $availability->validateType($kind),
+                $availability->validateSlotTime($startDate, $endDate),
+                $availability->validateBookableDayRange((int)$startInDays, (int)$endInDays)
+            );
+        }
+        return $errorList;
+    }
+
+    /**
+     * Get the earliest startDateTime and latest endDateTime from an AvailabilityList
+     * If the start date of any availability is before the selected date, use the selected date instead.
+     *
+     * @param AvailabilityList $availabilityList
+     * @param \DateTimeImmutable $selectedDate
+     * @return array
+     */
+    public function getDateTimeRangeFromList(\DateTimeImmutable $selectedDate): array
+    {
+        $earliestStartDateTime = null;
+        $latestEndDateTime = null;
+
+        foreach ($this as $availability) {
+            // Convert Unix timestamp to date strings
+            $startDate = (new \DateTimeImmutable())->setTimestamp($availability->startDate)->format('Y-m-d');
+            $endDate = (new \DateTimeImmutable())->setTimestamp($availability->endDate)->format('Y-m-d');
+
+            // Combine date and time for start and end
+            $startDateTime = new \DateTimeImmutable("{$startDate} {$availability->startTime}");
+            $endDateTime = new \DateTimeImmutable("{$endDate} {$availability->endTime}");
+
+            // Adjust the startDateTime if it's before the selected date
+            if ($startDateTime < $selectedDate) {
+                $startDateTime = $selectedDate->setTime(0, 0);
+            }
+
+            // Determine the earliest start time
+            if (is_null($earliestStartDateTime) || $startDateTime < $earliestStartDateTime) {
+                $earliestStartDateTime = $startDateTime;
+            }
+
+            // Determine the latest end time
+            if (is_null($latestEndDateTime) || $endDateTime > $latestEndDateTime) {
+                $latestEndDateTime = $endDateTime;
+            }
+        }
+
+        return [$earliestStartDateTime, $latestEndDateTime];
+    }
+
+    public function checkAllVsExistingConflicts($startDate, $endDate)
     {
         $processList = new ProcessList();
         foreach ($this as $availability) {
diff --git a/zmsentities/tests/Zmsentities/AvailabilityTest.php b/zmsentities/tests/Zmsentities/AvailabilityTest.php
index 79a6fcf59..873f2556b 100644
--- a/zmsentities/tests/Zmsentities/AvailabilityTest.php
+++ b/zmsentities/tests/Zmsentities/AvailabilityTest.php
@@ -179,7 +179,7 @@ public function testGetAvailableSecondsPerDay()
     {
         $entity = (new $this->entityclass())->getExample();
         $withCalculatedSlots = $entity->withCalculatedSlots();
-        $this->assertEquals(5346000, $withCalculatedSlots->getAvailableSecondsPerDay());
+        $this->assertEquals(6534000, $withCalculatedSlots->getAvailableSecondsPerDay());
     }
 
     public function testGetAvailableSecondsOnDateTime()
@@ -196,7 +196,7 @@ public function testGetAvailableSecondsOnDateTime()
         $collection = new $this->collectionclass();
         $collection->addEntity($entity);
         $collection = $collection->withCalculatedSlots();
-        $this->assertEquals(5346000, $collection->getAvailableSecondsOnDateTime($time));
+        $this->assertEquals(6534000, $collection->getAvailableSecondsOnDateTime($time));
     }
 
     public function testDayOff()
@@ -498,7 +498,7 @@ public function testWithCalculatedSlots()
     {
         $entity = (new $this->entityclass())->getExample();
         $withCalculatedSlots = $entity->withCalculatedSlots();
-        $this->assertTrue(81 == $withCalculatedSlots['workstationCount']['public'], $withCalculatedSlots);
+        $this->assertTrue(99 == $withCalculatedSlots['workstationCount']['public'], $withCalculatedSlots);
     }
 
     public function testGetSlotList()
@@ -507,9 +507,9 @@ public function testGetSlotList()
         $entity = (new $this->entityclass())->getExample();
         $collection->addEntity($entity);
         $slotList = $collection->getSlotList();
-        $this->assertTrue(28 == count($slotList));
+        $this->assertTrue(33 == count($slotList));
         $this->assertEquals('10:00', $slotList->getFirst()['time']);
-        $this->assertEquals('10:12', $slotList[1]['time']);
+        $this->assertEquals('10:10', $slotList[1]['time']);
     }
 
     public function testToString()
@@ -541,7 +541,7 @@ public function testCollection()
         $this->assertTrue(
             2 == count($collection),
             'Amount of entities in collection failed, 2 expected (' .
-                count($collection) . ' found)'
+            count($collection) . ' found)'
         );
 
         $this->assertTrue(
@@ -550,7 +550,7 @@ public function testCollection()
         );
 
         $this->assertTrue(
-            81 == $collection->withCalculatedSlots()[0]['workstationCount']['public'],
+            99 == $collection->withCalculatedSlots()[0]['workstationCount']['public'],
             'Failed to get list with calculated slots'
         );
         $collection->addEntity($entity);
@@ -867,7 +867,7 @@ public function testConflicts()
         ]);
         $startDate = new \DateTimeImmutable('2016-04-19 09:00');
         $endDate = new \DateTimeImmutable('2016-04-19 16:00');
-        $conflicts = $availabilityList->getConflicts($startDate, $startDate);
+        $conflicts = $availabilityList->checkAllVsExistingConflicts($startDate, $startDate);
         $list = [];
         foreach ($conflicts as $conflict) {
             /*error_log(
@@ -878,36 +878,83 @@ public function testConflicts()
             */
 
             $id = $conflict->getFirstAppointment()->getAvailability()->getId();
-            if (! isset($list[$conflict->amendment])) {
+            if (!isset($list[$conflict->amendment])) {
                 $list[$conflict->amendment] = [];
             }
-            if (! isset($list[$conflict->amendment][$id])) {
+            if (!isset($list[$conflict->amendment][$id])) {
                 $list[$conflict->amendment][$id] = 1;
             } else {
                 $list[$conflict->amendment][$id] += 1;
             }
         }
-    
-        // Availability 1 und 5 überschneiden sich jeweils 3 mal
-        $this->assertEquals(3, $list['Zwei Öffnungszeiten überschneiden sich.'][1]);
-        $this->assertEquals(3, $list['Zwei Öffnungszeiten überschneiden sich.'][5]);
 
-        // Availability 2, 4 und 6 überschneiden sich jeweils 2 mal
-        $this->assertEquals(2, $list['Zwei Öffnungszeiten überschneiden sich.'][2]);
-        $this->assertEquals(2, $list['Zwei Öffnungszeiten überschneiden sich.'][4]);
-        $this->assertEquals(2, $list['Zwei Öffnungszeiten überschneiden sich.'][6]);
+        // Assertion for overlapping availabilities - Availability 1 and 5
+        $this->assertEquals(
+            1,
+            $list[
+                "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 10:00 - 13:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]"
+            ][1]
+        );
+
+        $this->assertEquals(
+            1,
+            $list[
+                "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 10:00 - 13:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]"
+            ][5]
+        );
+
+        // Assertions for overlapping availabilities - Availability 2, 4
+        $this->assertEquals(
+            2,
+            $list[
+                "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 10:00 - 13:00]"
+            ][2]
+        );
 
-        // Availability 1 und 5 sind sich jeweils gleich
-        $this->assertEquals(1, $list['Zwei Öffnungszeiten sind gleich.'][1]);
-        $this->assertEquals(1, $list['Zwei Öffnungszeiten sind gleich.'][5]);
+        $this->assertEquals(
+            2,
+            $list[
+                "Konflikt: Zwei Öffnungszeiten überschneiden sich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 15:00 - 17:00]"
+            ][4]
+        );
 
-        // Availability 3 hat eine falsche Slotgröße
+        // Assertions for exact matches - Availability 1 and 5
         $this->assertEquals(
             1,
-            $list['Der eingestellte Zeitschlitz von 25 Minuten sollte in die eingestellte Uhrzeit passen.'][3]
+            $list[
+                "Konflikt: Zwei Öffnungszeiten sind gleich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]"
+            ][1]
+        );
+
+        $this->assertEquals(
+            1,
+            $list[
+                "Konflikt: Zwei Öffnungszeiten sind gleich.\n" .
+                "Bestehende Öffnungszeit:&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]\n" .
+                "Neue Öffnungszeit:&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;&thinsp;[19.04.2016 - 19.04.2016, 12:00 - 16:00]"
+            ][5]
         );
-    }
 
+        // Assertion for slot size conflict
+        $this->assertEquals(
+            1,
+            $list[
+                'Der eingestellte Zeitschlitz von 25 Minuten sollte in die eingestellte Uhrzeit passen.'
+            ][3]
+        );
+
+
+    }
 
     protected function getExampleWithTypeOpeningHours(\DateTimeImmutable $time)
     {
diff --git a/zmsentities/tests/Zmsentities/ProcessTest.php b/zmsentities/tests/Zmsentities/ProcessTest.php
index b6f04dfae..aed0e503d 100644
--- a/zmsentities/tests/Zmsentities/ProcessTest.php
+++ b/zmsentities/tests/Zmsentities/ProcessTest.php
@@ -491,7 +491,7 @@ public function testToConflictListByDay()
         //$this->assertEquals('Beispiel Termin', $list['2015-11-18'][0]['message']);
         $this->assertEquals('18:52', $list['2015-11-18'][0]['appointments'][0]['startTime']);
         // endTime = slotTimeInMinutes * slotCount 12X2 = 24
-        $this->assertEquals('19:16', $list['2015-11-18'][0]['appointments'][0]['endTime']);
+        $this->assertEquals('19:12', $list['2015-11-18'][0]['appointments'][0]['endTime']);
     }
 
     public function testToQueue()