GroupDeletedEvent + GroupLeftEvent + removed UI Subscriber

src/main/angular/src/app/api/Subscribed.ts

@@ -1,50 +0,0 @@
-import {Subscription} from "rxjs";
-import {Next} from "./common/types";
-
-export class Subscribed<T> {
-
-  private subscription: Subscription | null = null;
-
-  private _value: T | null = null;
-
-  constructor(
-    private readonly same: (a: T, b: T) => boolean,
-    private readonly subscribe: (value: T, next: Next<T>) => Subscription,
-  ) {
-    // -
-  }
-
-  get value(): T | null {
-    return this._value;
-  }
-
-  set value(value: T | null) {
-    if (!this.isSame(value)) {
-      this.unsubscribe();
-      if (value) {
-        this.subscription = this.subscribe(value, next => this.value = next);
-      }
-    }
-    this._value = value;
-  }
-
-  public unsubscribe() {
-    if (this.subscription) {
-      this.subscription.unsubscribe();
-      this.subscription = null;
-    }
-  }
-
-  private isSame(value: T | null) {
-    if (this._value === null) {
-      return value === null;
-    } else {
-      if (value === null) {
-        return false
-      } else {
-        return this.same(this._value, value);
-      }
-    }
-  }
-
-}

src/main/angular/src/app/api/User/UserPrivate.ts

@@ -1,24 +1,27 @@
 import {validateBoolean, validateDate, validateString} from "../common/validators";
+import {UserPublic} from "./UserPublic";
 
-export class UserPrivate {
+export class UserPrivate extends UserPublic {
 
   constructor(
     readonly privateUuid: string,
-    readonly publicUuid: string,
+    publicUuid: string,
     readonly created: Date,
-    readonly name: string,
+    name: string,
     readonly password: boolean,
+    admin: boolean,
   ) {
-    // -
+    super(publicUuid, name, admin);
   }
 
-  static fromJson(json: any): UserPrivate {
+  static override fromJson(json: any): UserPrivate {
     return new UserPrivate(
       validateString(json['privateUuid']),
       validateString(json['publicUuid']),
       validateDate(json['created']),
       validateString(json['name']),
       validateBoolean(json['password']),
+      validateBoolean(json['admin']),
     );
   }
 
@@ -29,8 +32,4 @@ export class UserPrivate {
     return UserPrivate.fromJson(json);
   }
 
-  static samePrivateUuid(a: UserPrivate, b: UserPrivate): boolean {
-    return a.privateUuid === b.privateUuid;
-  }
-
 }

src/main/angular/src/app/api/User/UserPublic.ts

@@ -1,10 +1,12 @@
-import {validateString} from "../common/validators";
+import {validateBoolean, validateString} from "../common/validators";
+import {UserPrivate} from "./UserPrivate";
 
 export class UserPublic {
 
   constructor(
     readonly publicUuid: string,
     readonly name: string,
+    readonly admin: boolean,
   ) {
     // -
   }
@@ -13,6 +15,7 @@ export class UserPublic {
     return new UserPublic(
       validateString(json['publicUuid']),
       validateString(json['name']),
+      validateBoolean(json['admin']),
     );
   }
 
@@ -20,4 +23,8 @@ export class UserPublic {
     return a.name.localeCompare(b.name);
   }
 
+  equals(user: UserPublic | UserPrivate | null) {
+    return user !== null && this.publicUuid === user.publicUuid;
+  }
+
 }

src/main/angular/src/app/api/User/user.service.ts

@@ -1,13 +1,15 @@
-import {Injectable} from '@angular/core';
+import {Injectable, Type} from '@angular/core';
 import {ApiService} from "../common/api.service";
 import {UserPrivate} from "./UserPrivate";
 import {Next} from "../common/types";
 import {UserPublic} from "./UserPublic";
 import {EventType, Router} from "@angular/router";
-import {BehaviorSubject, filter, Subject, Subscription} from "rxjs";
+import {BehaviorSubject, filter, map, Subject, Subscription} from "rxjs";
 import {Group} from "../group/Group";
 import {StompService} from "@stomp/ng2-stompjs";
 import {Numbers} from "../tools/Numbers/Numbers";
+import {GroupDeletedEvent} from "../group/events/GroupDeletedEvent";
+import {GroupLeftEvent} from "../group/events/GroupLeftEvent";
 
 function userPushMessageFromJson(json: any): object {
   const type = json['_type_'];
@@ -18,6 +20,10 @@ function userPushMessageFromJson(json: any): object {
       return UserPrivate.fromJson(json['payload']);
     case 'GroupDto':
       return Group.fromJson(json['payload']);
+    case 'GroupDeletedEvent':
+      return GroupDeletedEvent.fromJson(json['payload']);
+    case 'GroupLeftEvent':
+      return GroupLeftEvent.fromJson(json['payload']);
   }
   throw new Error("Not implemented UserPushMessage._type_ = " + type);
 }
@@ -78,14 +84,8 @@ export class UserService {
     return this.subject.subscribe(next);
   }
 
-  subscribePush<T>(predicate: (m: any) => boolean, next: Next<T>): Subscription {
-    return this.pushSubject
-      .pipe(filter(predicate))
-      .subscribe(next);
-  }
-
   iOwn(group: Group): boolean {
-    return this.user?.publicUuid === group.owner.publicUuid;
+    return group.owner.equals(this.user);
   }
 
   private setUser(user: UserPrivate | null) {
@@ -99,4 +99,17 @@ export class UserService {
     this.subject.next(user);
   }
 
+  iAm(user: UserPublic | UserPrivate | null) {
+    return this.user !== null && this.user.equals(user);
+  }
+
+  subscribePush<T>(TYPE: Type<T>, next: Next<T>): Subscription {
+    return this.pushSubject
+      .pipe(
+        filter(m => m instanceof TYPE),
+        map(m => m as T),
+      )
+      .subscribe(next);
+  }
+
 }

src/main/angular/src/app/api/group/Group.ts

@@ -1,18 +1,21 @@
 import {UserPublic} from "../User/UserPublic";
 import {validateBoolean, validateDate, validateList, validateString} from "../common/validators";
+import {UserPrivate} from "../User/UserPrivate";
+import {GroupUuid} from "./GroupUuid";
 
-export class Group {
+export class Group extends GroupUuid {
 
-  protected constructor(
-    readonly uuid: string,
+  constructor(
+    uuid: string,
     readonly owner: UserPublic,
     readonly created: Date,
     readonly title: string,
     readonly password: string,
     readonly users: UserPublic[],
+    readonly banned: UserPublic[],
     readonly initial: boolean,
   ) {
-    // -
+    super(uuid);
   }
 
   isOwner(user: UserPublic) {
@@ -27,6 +30,7 @@ export class Group {
       validateString(json['title']),
       validateString(json['password']),
       validateList(json['users'], UserPublic.fromJson),
+      validateList(json['banned'], UserPublic.fromJson),
       validateBoolean(json['initial']),
     );
   }
@@ -44,13 +48,17 @@ export class Group {
     return UserPublic.compareName(a, b);
   }
 
-  static sameUuid(a: Group, b: Group): boolean {
-    return a.uuid === b.uuid;
-  }
-
   static compareCreated(a: Group, b: Group): number {
     return a.created.getTime() - b.created.getTime();
   }
 
+  isOwnedBy(user: UserPublic | UserPrivate | null) {
+    return user !== null && user.equals(this.owner);
+  }
+
+  bannedByName() {
+    return this.banned.sort(UserPublic.compareName);
+  }
+
 }
 

src/main/angular/src/app/api/group/GroupUuid.ts

@@ -0,0 +1,13 @@
+export class GroupUuid {
+
+  protected constructor(
+    readonly uuid: string,
+  ) {
+    // -
+  }
+
+  is(other: GroupUuid | null) {
+    return other !== null && this.uuid === other.uuid;
+  }
+
+}

src/main/angular/src/app/api/group/events/GroupDeletedEvent.ts

@@ -0,0 +1,19 @@
+import {validateString} from "../../common/validators";
+
+import {GroupUuid} from "../GroupUuid";
+
+export class GroupDeletedEvent extends GroupUuid {
+
+  constructor(
+    uuid: string,
+  ) {
+    super(uuid);
+  }
+
+  static fromJson(json: any): GroupDeletedEvent {
+    return new GroupDeletedEvent(
+      validateString(json['uuid']),
+    );
+  }
+
+}

src/main/angular/src/app/api/group/events/GroupLeftEvent.ts

@@ -0,0 +1,19 @@
+import {GroupUuid} from "../GroupUuid";
+import {validateString} from "../../common/validators";
+import {GroupDeletedEvent} from "./GroupDeletedEvent";
+
+export class GroupLeftEvent extends GroupUuid {
+
+  constructor(
+    uuid: string,
+  ) {
+    super(uuid);
+  }
+
+  static fromJson(json: any): GroupDeletedEvent {
+    return new GroupDeletedEvent(
+      validateString(json['uuid']),
+    );
+  }
+
+}

src/main/angular/src/app/api/group/group.service.ts

@@ -5,7 +5,11 @@ import {Router} from "@angular/router";
 import {UserService} from "../User/user.service";
 import {validateBoolean} from "../common/validators";
 import {Injectable} from "@angular/core";
-import {Subscribed} from "../Subscribed";
+import {UserPublic} from "../User/UserPublic";
+import {GroupUserRequest} from "./requests/GroupUserRequest";
+import {GroupChangeTitleRequest} from "./requests/GroupChangeTitleRequest";
+import {GroupChangePasswordRequest} from "./requests/GroupChangePasswordRequest";
+import {GroupJoinRequest} from "./requests/GroupJoinRequest";
 
 @Injectable({
   providedIn: 'root'
@@ -41,26 +45,17 @@ export class GroupService {
   }
 
   changeTitle(group: Group, title: string, next?: Next<Group>): void {
-    const data = {
-      uuid: group.uuid,
-      title: title,
-    };
+    const data = new GroupChangeTitleRequest(group, title);
     this.api.postSingle(['Group', 'changeTitle'], data, Group.fromJson, next);
   }
 
   changePassword(group: Group, password: string, next?: Next<Group>): void {
-    const data = {
-      uuid: group.uuid,
-      password: password,
-    };
+    const data = new GroupChangePasswordRequest(group, password);
     this.api.postSingle(['Group', 'changePassword'], data, Group.fromJson, next);
   }
 
-  join(uuid: string, password: string, next: Next<Group>): void {
-    const data = {
-      uuid: uuid,
-      password: password,
-    };
+  join(groupUuid: string, password: string, next: Next<Group>): void {
+    const data = new GroupJoinRequest(groupUuid, password);
     this.api.postSingle(['Group', 'join'], data, Group.fromJson, next);
   }
 
@@ -72,10 +67,6 @@ export class GroupService {
     this.router.navigate(['Group', uuid]);
   }
 
-  newSubscriber(): Subscribed<Group> {
-    return new Subscribed<Group>(Group.sameUuid, (group, next) => this.api.subscribe(['Group', group.uuid], Group.fromJson, next));
-  }
-
   gotoGroups(): void {
     this.router.navigate(['Groups']);
   }
@@ -84,5 +75,17 @@ export class GroupService {
     this.api.postNone(['Group', 'delete'], group.uuid, next);
   }
 
+  kick(group: Group, user: UserPublic, next?: Next<void>): void {
+    this.api.postNone(['Group', 'kick'], new GroupUserRequest(group, user), next);
+  }
+
+  ban(group: Group, user: UserPublic, next?: Next<void>): void {
+    this.api.postNone(['Group', 'ban'], new GroupUserRequest(group, user), next);
+  }
+
+  unban(group: Group, user: UserPublic, next?: Next<void>): void {
+    this.api.postNone(['Group', 'unban'], new GroupUserRequest(group, user), next);
+  }
+
 }
 

src/main/angular/src/app/api/group/requests/GroupChangePasswordRequest.ts

@@ -0,0 +1,14 @@
+import {Group} from "../Group";
+
+export class GroupChangePasswordRequest {
+
+  readonly groupUuid: string;
+
+  readonly password: string;
+
+  constructor(group: Group, password: string) {
+    this.groupUuid = group.uuid;
+    this.password = password;
+  }
+
+}

src/main/angular/src/app/api/group/requests/GroupChangeTitleRequest.ts

@@ -0,0 +1,14 @@
+import {Group} from "../Group";
+
+export class GroupChangeTitleRequest {
+
+  readonly groupUuid: string;
+
+  readonly title: string;
+
+  constructor(group: Group, title: string) {
+    this.groupUuid = group.uuid;
+    this.title = title;
+  }
+
+}

src/main/angular/src/app/api/group/requests/GroupJoinRequest.ts

@@ -0,0 +1,12 @@
+export class GroupJoinRequest {
+
+  readonly groupUuid: string;
+
+  readonly password: string;
+
+  constructor(groupUuid: string, password: string) {
+    this.groupUuid = groupUuid;
+    this.password = password;
+  }
+
+}

src/main/angular/src/app/api/group/requests/GroupUserRequest.ts

@@ -0,0 +1,15 @@
+import {Group} from "../Group";
+import {UserPublic} from "../../User/UserPublic";
+
+export class GroupUserRequest {
+
+  readonly groupUuid: string;
+
+  readonly userPublicUuid: string;
+
+  constructor(group: Group, user: UserPublic) {
+    this.groupUuid = group.uuid;
+    this.userPublicUuid = user.publicUuid;
+  }
+
+}

src/main/angular/src/app/api/tools/Numbers/Numbers.ts

@@ -1,5 +1,5 @@
 import {Group} from "../../group/Group";
-import {validateDate, validateNumber, validateString} from "../../common/validators";
+import {validateDate, validateDateOrNull, validateNumberOrNull, validateString} from "../../common/validators";
 
 export class Numbers {
 
@@ -7,7 +7,8 @@ export class Numbers {
     readonly uuid: string,
     readonly group: Group,
     readonly date: Date,
-    readonly number: number,
+    readonly read: Date | null,
+    readonly number: number | null,
   ) {
     // -
   }
@@ -17,7 +18,8 @@ export class Numbers {
       validateString(json['uuid']),
       Group.fromJson(json['group']),
       validateDate(json['date']),
-      validateNumber(json['number']),
+      validateDateOrNull(json['read']),
+      validateNumberOrNull(json['number']),
     );
   }
 

src/main/angular/src/app/api/tools/Numbers/numbers.service.ts

@@ -17,9 +17,7 @@ export class NumbersService {
     protected readonly router: Router,
     protected readonly userService: UserService
   ) {
-    this.userService.subscribePush<Numbers>(m => m instanceof Numbers, message => {
-      this.router.navigate(['Numbers', message.uuid])
-    });
+    // -
   }
 
   create(groupUuid: string): void {
@@ -30,8 +28,8 @@ export class NumbersService {
     this.api.getPage(['Numbers', 'page', groupUuid, page, pageSize], Numbers.fromJson, next);
   }
 
-  byUuid(numbersUuid: string, next: Next<Numbers>): void {
-    this.api.postSingle(['Numbers', 'byUuid'], numbersUuid, Numbers.fromJson, next);
+  fetchAndMarkAsRead(numbersUuid: string, next: Next<Numbers>): void {
+    this.api.postSingle(['Numbers', 'fetchAndMarkAsRead'], numbersUuid, Numbers.fromJson, next);
   }
 
   canAccess(numbersUuid: string, next: Next<boolean>): void {
@@ -42,4 +40,8 @@ export class NumbersService {
     this.api.postSingle(['Numbers', 'getGroupUuid'], numbersUuid, validateString, next);
   }
 
+  goto(numbers: Numbers) {
+    this.router.navigate(['Numbers', numbers.uuid]);
+  }
+
 }

src/main/angular/src/app/pages/group/group/group.component.html

@@ -1,6 +1,6 @@
 <div class="tileContainer">
 
-  <div class="tile" *ngIf="granted === false">
+  <div class="tile" *ngIf="group === null && granted === false">
     <div class="tileInner">
       <div class="tileTitle">
         Passwort
@@ -11,7 +11,7 @@
     </div>
   </div>
 
-  <ng-container *ngIf="group.value">
+  <ng-container *ngIf="group">
 
     <div class="tile">
       <div class="tileInner">
@@ -19,32 +19,86 @@
           Gruppe
         </div>
         <div class="tileContent">
+
           <table>
             <tr>
               <th>Erstellt</th>
-              <td>{{ group.value.created | date:'yyyy-MM-dd HH:mm' }}</td>
+              <td>{{ group.created | date:'yyyy-MM-dd HH:mm' }}</td>
             </tr>
             <tr>
               <th>Titel</th>
               <td>
-                <app-text [initial]="group.value.title" [editable]="userService.iOwn(group.value)" (onChange)="changeTitle(group.value, $event)"></app-text>
-                <ng-container *ngIf="!userService.iOwn(group.value)"></ng-container>
+                <app-text [initial]="group.title" [editable]="userService.iOwn(group)" (onChange)="changeTitle(group, $event)"></app-text>
+                <ng-container *ngIf="!userService.iOwn(group)"></ng-container>
               </td>
             </tr>
             <tr>
               <th>Passwort</th>
               <td>
-                <app-text [initial]="group.value.password" [editable]="userService.iOwn(group.value)" (onChange)="changePassword(group.value, $event)"></app-text>
-                <ng-container *ngIf="!userService.iOwn(group.value)"></ng-container>
-              </td>
-            </tr>
-            <tr>
-              <th>Teilnehmer</th>
-              <td>
-                <div class="user" [class.user_owner]="group.value.isOwner(user)" *ngFor="let user of group.value.usersByNameOwnerFirst()" (click)="userService.goto(user)">{{ user.name }}</div>
+                <app-text [initial]="group.password" [editable]="userService.iOwn(group)" (onChange)="changePassword(group, $event)"></app-text>
+                <ng-container *ngIf="!userService.iOwn(group)"></ng-container>
               </td>
             </tr>
           </table>
+
+          <div class="buttons">
+            <div class="button buttonRight buttonDelete" (click)="groupDelete(group)">
+              Gruppe löschen
+            </div>
+          </div>
+
+        </div>
+      </div>
+    </div>
+
+    <div class="tile">
+      <div class="tileInner">
+        <div class="tileTitle">
+          Mitglieder
+        </div>
+        <div class="tileContent">
+          <div class="numbers">
+            <table>
+              <tr [class.user_owner]="group.isOwner(user)" *ngFor="let user of group.usersByNameOwnerFirst()">
+                <td (click)="userService.goto(user)">{{ user.name }}</td>
+                <td>
+                  <span class="owner" *ngIf="group.isOwnedBy(user)">
+                    Admin
+                  </span>
+                  <div class="buttons">
+                    <ng-container *ngIf="userService.iOwn(group) && !userService.iAm(user)">
+                      <div class="button buttonRight buttonBan" (click)="groupService.ban(group, user)">Verbannen</div>
+                      <div class="button buttonRight buttonRemove" (click)="groupService.kick(group, user)">Entfernen</div>
+                    </ng-container>
+                  </div>
+                </td>
+              </tr>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="tile" *ngIf="group.banned.length > 0">
+      <div class="tileInner">
+        <div class="tileTitle">
+          Verbannt
+        </div>
+        <div class="tileContent">
+          <div class="numbers">
+            <table>
+              <tr [class.user_owner]="group.isOwner(user)" *ngFor="let user of group.bannedByName()" (click)="userService.goto(user)">
+                <td>{{ user.name }}</td>
+                <td>
+                  <div class="buttons">
+                    <ng-container *ngIf="userService.iOwn(group) && !userService.iAm(user)">
+                      <div class="button buttonRight buttonUnban" (click)="groupService.unban(group, user)">Aufheben</div>
+                    </ng-container>
+                  </div>
+                </td>
+              </tr>
+            </table>
+          </div>
         </div>
       </div>
     </div>
@@ -55,28 +109,17 @@
           Nummern
         </div>
         <div class="tileContent">
+          <div class="buttons">
+            <div class="button buttonRight buttonNext" *ngIf="userService.iOwn(group)" (click)="numbersService.create(group.uuid)">+ Nächste Runde</div>
+          </div>
           <div class="numbers">
             <table>
-              <tr class="number" *ngFor="let numbers of numbersList.content">
+              <tr class="number" *ngFor="let numbers of numbersList.content" (click)="numbersService.goto(numbers)" [class.read]="numbers.read !== null">
                 <td>{{ numbers.date | relative:now }}</td>
-                <td>{{ numbers.number }}</td>
+                <td>{{ numbers.number || '-' }}</td>
               </tr>
             </table>
           </div>
-          <button *ngIf="userService.iOwn(group.value)" (click)="numbersService.create(group.value.uuid)">Numbers</button>
-        </div>
-      </div>
-    </div>
-
-    <div class="tile" *ngIf="userService.iOwn(group.value)">
-      <div class="tileInner">
-        <div class="tileTitle">
-          Löschen
-        </div>
-        <div class="tileContent">
-          <button (click)="delete(group.value)">
-            Löschen
-          </button>
         </div>
       </div>
     </div>

src/main/angular/src/app/pages/group/group/group.component.less

@@ -3,3 +3,23 @@
 th {
   text-align: left;
 }
+
+.read {
+  color: gray;
+}
+
+.unread {
+  background-color: lightskyblue;
+}
+
+.buttonRemove {
+  color: orange;
+}
+
+.buttonBan {
+  color: red;
+}
+
+.buttonUnban {
+  color: green;
+}

src/main/angular/src/app/pages/group/group/group.component.ts

@@ -6,13 +6,14 @@ import {ActivatedRoute, Router} from "@angular/router";
 import {GroupService} from "../../../api/group/group.service";
 import {UserService} from "../../../api/User/user.service";
 import {Group} from "../../../api/group/Group";
-import {Subscribed} from "../../../api/Subscribed";
 import {NumbersService} from "../../../api/tools/Numbers/numbers.service";
 import {PasswordComponent} from "../../../shared/password/password.component";
 import {Numbers} from "../../../api/tools/Numbers/Numbers";
 import {Page} from "../../../api/common/Page";
 import {RelativePipe} from "../../../shared/relative.pipe";
 import {Subscription, timer} from "rxjs";
+import {GroupDeletedEvent} from "../../../api/group/events/GroupDeletedEvent";
+import {GroupLeftEvent} from "../../../api/group/events/GroupLeftEvent";
 
 @Component({
   selector: 'app-group',
@@ -32,7 +33,9 @@ import {Subscription, timer} from "rxjs";
 })
 export class GroupComponent implements OnInit, OnDestroy {
 
-  protected readonly group: Subscribed<Group>;
+  protected readonly subs: Subscription[] = [];
+
+  protected group: Group | null = null;
 
   protected numbersList: Page<Numbers> = Page.EMPTY;
 
@@ -42,8 +45,6 @@ export class GroupComponent implements OnInit, OnDestroy {
 
   protected now: Date = new Date();
 
-  private timer?: Subscription;
-
   constructor(
     protected readonly router: Router,
     protected readonly activatedRoute: ActivatedRoute,
@@ -51,12 +52,30 @@ export class GroupComponent implements OnInit, OnDestroy {
     protected readonly userService: UserService,
     protected readonly numbersService: NumbersService,
   ) {
-    this.group = this.groupService.newSubscriber();
+    // -
   }
 
   ngOnInit(): void {
-    this.timer = timer(1000, 1000).subscribe(() => this.now = new Date());
-    this.activatedRoute.params.subscribe(params => {
+    this.subs.push(timer(1000, 1000).subscribe(() => this.now = new Date()));
+    this.subs.push(this.userService.subscribePush(Numbers, _ => {
+      this.updateNumbersList();
+    }));
+    this.subs.push(this.userService.subscribePush(Group, group => {
+      if (group.is(this.group)) {
+        this.group = group;
+      }
+    }));
+    this.subs.push(this.userService.subscribePush(GroupDeletedEvent, event => {
+      if (event.is(this.group)) {
+        this.groupService.gotoGroups();
+      }
+    }));
+    this.subs.push(this.userService.subscribePush(GroupLeftEvent, event => {
+      if (event.is(this.group)) {
+        this.groupService.gotoGroups();
+      }
+    }));
+    this.subs.push(this.activatedRoute.params.subscribe(params => {
       const groupUuid = params['uuid'];
       this.uuid = groupUuid;
       this.granted = null;
@@ -64,38 +83,44 @@ export class GroupComponent implements OnInit, OnDestroy {
         this.groupService.canAccess(groupUuid, granted => {
           this.granted = granted;
           if (granted) {
-            this.groupService.get(groupUuid, group => this.group.value = group);
-            this.numbersService.page(groupUuid, 0, 10, numbersList => this.numbersList = numbersList);
+            this.groupService.get(groupUuid, group => {
+              this.group = group;
+              this.updateNumbersList();
+            });
           }
         });
       }
-    });
+    }));
+  }
+
+  private updateNumbersList() {
+    if (this.group) {
+      this.numbersService.page(this.group.uuid, 0, 10, numbersList => this.numbersList = numbersList);
+    }
   }
 
   ngOnDestroy(): void {
-    if (this.timer) {
-      this.timer.unsubscribe();
-      this.timer = undefined;
-    }
-    this.group.unsubscribe();
+    this.subs.forEach(sub => sub.unsubscribe());
   }
 
   protected changeTitle(group: Group, title: string): void {
-    this.groupService.changeTitle(group, title, group => this.group.value = group);
+    this.groupService.changeTitle(group, title, group => this.group = group);
   }
 
   protected changePassword(group: Group, password: string): void {
-    this.groupService.changePassword(group, password, group => this.group.value = group);
+    this.groupService.changePassword(group, password, group => this.group = group);
   }
 
   protected join(password: string): void {
     if (this.uuid) {
-      this.groupService.join(this.uuid, password, group => this.group.value = group);
+      this.groupService.join(this.uuid, password, group => this.group = group);
     }
   }
 
-  protected delete(group: Group): void {
-    this.groupService.delete(group, () => this.groupService.gotoGroups());
+  protected groupDelete(group: Group): void {
+    if (confirm("Gruppe \"" + group.title + "\" wirklich löschen?")) {
+      this.groupService.delete(group, () => this.groupService.gotoGroups());
+    }
   }
 
 }

src/main/angular/src/app/pages/group/groups/groups.component.html

@@ -11,7 +11,9 @@
         </ng-container>
       </div>
       <div class="tileFooter">
-        <button (click)="create()">+ Neue Gruppen erstellen</button>
+        <div class="buttons">
+          <div class="button buttonRight buttonCreate" (click)="create()">+ Neue Gruppen erstellen</div>
+        </div>
       </div>
     </div>
   </div>

src/main/angular/src/app/pages/group/groups/groups.component.ts

@@ -5,20 +5,24 @@ import {NgIf} from "@angular/common";
 import {GroupService} from "../../../api/group/group.service";
 import {Group} from "../../../api/group/Group";
 import {Subscription} from "rxjs";
+import {ReactiveFormsModule} from "@angular/forms";
+import {GroupLeftEvent} from "../../../api/group/events/GroupLeftEvent";
+import {GroupDeletedEvent} from "../../../api/group/events/GroupDeletedEvent";
 
 @Component({
   selector: 'app-groups',
   standalone: true,
   imports: [
     GroupListComponent,
-    NgIf
+    NgIf,
+    ReactiveFormsModule
   ],
   templateUrl: './groups.component.html',
   styleUrl: './groups.component.less'
 })
 export class GroupsComponent implements OnInit, OnDestroy {
 
-  private readonly subscriptions: Subscription[] = [];
+  private readonly subs: Subscription[] = [];
 
   protected groups: Group[] = [];
 
@@ -30,13 +34,18 @@ export class GroupsComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit(): void {
-    this.subscriptions.push(this.userService.subscribe(_ => {
-      this.groupService.findAllJoined(groups => this.groups = groups);
-    }));
+    this.subs.push(this.userService.subscribePush(Group, _ => this.updateGroups()));
+    this.subs.push(this.userService.subscribePush(GroupLeftEvent, _ => this.updateGroups()));
+    this.subs.push(this.userService.subscribePush(GroupDeletedEvent, _ => this.updateGroups()));
+    this.updateGroups();
   }
 
   ngOnDestroy(): void {
-    this.subscriptions.forEach(subscription => subscription.unsubscribe());
+    this.subs.forEach(sub => sub.unsubscribe());
+  }
+
+  private updateGroups() {
+    this.groupService.findAllJoined(groups => this.groups = groups);
   }
 
   create(): void {

src/main/angular/src/app/pages/tools/numbers/numbers.component.html

@@ -5,16 +5,18 @@
   [class.date_old]="now.getTime() - numbers.date.getTime() >= 5 * 60 * 1000"
 >
 
-  <button *ngIf="userService.iOwn(numbers.group)" (click)="numbersService.create(numbers.group.uuid)">
-    Nächste Runde
-  </button>
-
   <div class="date">
     {{ numbers.date | relative:now }}
   </div>
 
-  <div class="huge">
-    {{ numbers.number }}
+  <div class="huge" (click)="gotoGroup()">
+    {{ numbers.number || '-' }}
+  </div>
+
+  <div class="buttons">
+    <div class="button buttonRight buttonNext" *ngIf="userService.iOwn(numbers.group)" (click)="numbersService.create(numbers.group.uuid)">
+      Nächste Runde
+    </div>
   </div>
 
 </div>

src/main/angular/src/app/pages/tools/numbers/numbers.component.ts

@@ -1,4 +1,4 @@
-import {Component, OnDestroy, OnInit} from '@angular/core';
+import {Component, HostListener, OnDestroy, OnInit} from '@angular/core';
 import {Numbers} from "../../../api/tools/Numbers/Numbers";
 import {ActivatedRoute} from "@angular/router";
 import {NumbersService} from "../../../api/tools/Numbers/numbers.service";
@@ -46,7 +46,7 @@ export class NumbersComponent implements OnInit, OnDestroy {
       if (uuid) {
         this.numbersService.canAccess(uuid, granted => {
           if (granted) {
-            this.numbersService.byUuid(uuid, numbers => this.numbers = numbers);
+            this.numbersService.fetchAndMarkAsRead(uuid, numbers => this.numbers = numbers);
           } else {
             this.numbersService.getGroupUuid(uuid, groupUuid => this.groupService.goto(groupUuid));
           }
@@ -64,4 +64,11 @@ export class NumbersComponent implements OnInit, OnDestroy {
     }
   }
 
+  @HostListener('window:keydown.escape')
+  protected gotoGroup() {
+    if (this.numbers?.group) {
+      this.groupService.goto(this.numbers.group.uuid);
+    }
+  }
+
 }

src/main/angular/src/app/shared/password/password.component.html

@@ -1,5 +1,7 @@
 <ng-container *ngIf="visible">
   <h1>Passwort</h1>
   <input type="text" [(ngModel)]="password" (keydown.enter)="join.emit(password)">
-  <button (click)="join.emit(password)">Beitreten</button>
+  <div class="buttons">
+    <div class="button buttonRight buttonJoin" (click)="join.emit(password)">Beitreten</div>
+  </div>
 </ng-container>

src/main/angular/src/common.less

@@ -1,2 +1,52 @@
 @import "./tile.less";
 @import "./user.less";
+
+.buttons {
+  margin-bottom: @halfSpace;
+
+  .button {
+    float: left;
+    margin-left: @quarterSpace;
+    margin-right: @quarterSpace;
+    padding: @halfSpace;
+    border-radius: @halfSpace;
+    background-color: #dddddd;
+  }
+
+  .buttonRight {
+    float: right;
+  }
+
+  .buttonCreate {
+    background-color: lightgreen;
+  }
+
+  .buttonCreate:hover {
+    background-color: limegreen;
+  }
+
+  .buttonJoin {
+    background-color: lightskyblue;
+  }
+
+  .buttonJoin:hover {
+    background-color: dodgerblue;
+  }
+
+  .buttonNext {
+    background-color: lightgreen;
+  }
+
+  .buttonNext:hover {
+    background-color: limegreen;
+  }
+
+  .buttonDelete {
+    background-color: indianred;
+  }
+
+  .buttonDelete:hover {
+    background-color: palevioletred;
+  }
+
+}

src/main/angular/src/config.less

@@ -1,2 +1,3 @@
 @space: 0.5em;
 @halfSpace: calc(@space / 2);
+@quarterSpace: calc(@halfSpace / 2);

src/main/java/de/ph87/tools/group/Group.java

@@ -55,8 +55,15 @@ public class Group extends GroupAbstract implements IWebSocketMessage {
   @NonNull
   @ManyToMany
   @ToString.Exclude
+  @JoinTable(name = "`group_user`")
   private Set<User> users = new HashSet<>();
 
+  @NonNull
+  @ManyToMany
+  @ToString.Exclude
+  @JoinTable(name = "`group_banned`")
+  private Set<User> banned = new HashSet<>();
+
   @Setter
   @NonNull
   @Column(nullable = false)
@@ -89,4 +96,8 @@ public class Group extends GroupAbstract implements IWebSocketMessage {
     return List.of("Number", uuid);
   }
 
+  public boolean isBanned(@NonNull final User user) {
+    return banned.stream().anyMatch(u -> u.equals(user));
+  }
+
 }

src/main/java/de/ph87/tools/group/GroupAccessController.java

@@ -0,0 +1,26 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import jakarta.annotation.Nullable;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@CrossOrigin
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("Group")
+public class GroupAccessController {
+
+  private final GroupAccessService groupAccessService;
+
+  @PostMapping("canAccess")
+  public boolean canAccess(@Nullable final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    return groupAccessService.canAccess(privateUuid, groupUuid);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupAccessService.java

@@ -1,7 +1,6 @@
 package de.ph87.tools.group;
 
 import de.ph87.tools.group.uuid.GroupUuid;
-import de.ph87.tools.tools.numbers.NumbersRepository;
 import de.ph87.tools.user.User;
 import de.ph87.tools.user.UserService;
 import de.ph87.tools.user.uuid.UserPrivateUuid;
@@ -24,8 +23,6 @@ public class GroupAccessService {
 
   private final UserService userService;
 
-  private final NumbersRepository numbersRepository;
-
   public boolean canAccess(@Nullable final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
     final User user = userService.accessOrNull(userPrivateUuid);
     if (user == null) {
@@ -35,13 +32,6 @@ public class GroupAccessService {
     return group.getUsers().contains(user);
   }
 
-  public void delete(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
-    final GroupAccess groupAccess = accessAsOwner(userPrivateUuid, groupUuid);
-    numbersRepository.deleteAllByGroup(groupAccess.group);
-    groupRepository.delete(groupAccess.group);
-    log.info("Group deleted: group={}", groupAccess.group);
-  }
-
   @NonNull
   public GroupAccess access(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
     final User user = userService.access(userPrivateUuid);
@@ -50,7 +40,7 @@ public class GroupAccessService {
   }
 
   @NonNull
-  public GroupAccess accessAsOwner(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
+  public GroupAccess ownerAccess(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
     final GroupAccess groupAccess = access(userPrivateUuid, groupUuid);
     if (!groupAccess.group.isOwnedBy(groupAccess.user)) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST);

src/main/java/de/ph87/tools/group/GroupController.java

@@ -1,79 +0,0 @@
-package de.ph87.tools.group;
-
-import de.ph87.tools.group.requests.GroupChangePasswordRequest;
-import de.ph87.tools.group.requests.GroupChangeTitleRequest;
-import de.ph87.tools.group.requests.GroupJoinRequest;
-import de.ph87.tools.group.uuid.GroupUuid;
-import de.ph87.tools.user.uuid.UserPrivateUuid;
-import de.ph87.tools.user.uuid.UserPublicUuid;
-import jakarta.annotation.Nullable;
-import jakarta.servlet.http.HttpServletResponse;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Set;
-
-@CrossOrigin
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("Group")
-public class GroupController {
-
-  private final GroupService groupService;
-
-  private final GroupAccessService groupAccessService;
-
-  @GetMapping("create")
-  public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
-    return groupService.create(privateUuid, response);
-  }
-
-  @PostMapping("canAccess")
-  public boolean canAccess(@Nullable final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    return groupAccessService.canAccess(privateUuid, groupUuid);
-  }
-
-  @PostMapping("delete")
-  public void delete(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    groupAccessService.delete(privateUuid, groupUuid);
-  }
-
-  @PostMapping("get")
-  public GroupDto get(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    return groupService.get(privateUuid, groupUuid);
-  }
-
-  @NonNull
-  @GetMapping("findAllJoined")
-  public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid userUuid) {
-    return groupService.findAllJoined(userUuid);
-  }
-
-  @NonNull
-  @PostMapping("findAllCommon")
-  public Set<GroupDto> findAllCommon(@NonNull final UserPrivateUuid userUuid, @NonNull final UserPublicUuid targetUuid) {
-    return groupService.findAllCommon(userUuid, targetUuid);
-  }
-
-  @PostMapping("join")
-  public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
-    return groupService.join(privateUuid, request, response);
-  }
-
-  @PostMapping("changeTitle")
-  public GroupDto changeTitle(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupChangeTitleRequest request) {
-    return groupService.changeTitle(privateUuid, request);
-  }
-
-  @PostMapping("changePassword")
-  public GroupDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupChangePasswordRequest request) {
-    return groupService.changePassword(privateUuid, request);
-  }
-
-  @PostMapping("leave")
-  public void leave(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    groupService.leave(privateUuid, groupUuid);
-  }
-
-}

src/main/java/de/ph87/tools/group/GroupMemberController.java

@@ -0,0 +1,31 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.requests.GroupJoinRequest;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import jakarta.annotation.Nullable;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@CrossOrigin
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("Group")
+public class GroupMemberController {
+
+  private final GroupMemberService groupMemberService;
+
+  @PostMapping("join")
+  public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
+    return groupMemberService.join(privateUuid, request, response);
+  }
+
+  @PostMapping("leave")
+  public void leave(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    groupMemberService.leave(privateUuid, groupUuid);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupMemberService.java

@@ -0,0 +1,78 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.events.GroupLeftEvent;
+import de.ph87.tools.group.requests.GroupJoinRequest;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.User;
+import de.ph87.tools.user.UserService;
+import de.ph87.tools.user.push.UserPushService;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import jakarta.annotation.Nullable;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.function.BiConsumer;
+
+@Slf4j
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class GroupMemberService {
+
+  private final UserService userService;
+
+  private final GroupReadService groupReadService;
+
+  private final UserPushService userPushService;
+
+  @NonNull
+  public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
+    final User user = userService.getUserByPrivateUuidOrElseCreate(privateUuid, response);
+    final Group group = groupReadService.getGroupByGroupUuid(request.groupUuid);
+    if (group.isBanned(user)) {
+      log.error("User is banned from Group and cannot join it: user={}, group={}", user, group);
+      throw new ResponseStatusException(HttpStatus.FORBIDDEN);
+    }
+    if (!group.getPassword().equals(request.password)) {
+      log.error("Wrong password: user={}, group={}", user, group);
+      throw new ResponseStatusException(HttpStatus.FORBIDDEN);
+    }
+    return _add_user_to_group_unchecked(group, user);
+  }
+
+  public void leave(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    final User user = userService.access(privateUuid);
+    final Group group = groupReadService.getGroupByGroupUuid(groupUuid);
+    if (group.isOwnedBy(user)) {
+      // owner cannot remove itself from group
+      throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
+    }
+    _remove_user_from_group_unchecked(group, user, (g, u) -> log.info("User left Group: user={}, group={}", u, g));
+  }
+
+  @NonNull
+  public GroupDto _add_user_to_group_unchecked(@NonNull final Group group, @NonNull final User user) {
+    group.getUsers().add(user);
+    group.touch();
+    user.touch();
+    log.info("User joined Group: user={}, group={}", user, group);
+    return groupReadService.publish(group);
+  }
+
+  public void _remove_user_from_group_unchecked(@NonNull final Group group, @NonNull final User user, @NonNull final BiConsumer<Group, User> beforePush) {
+    group.getUsers().remove(user);
+    group.touch();
+    user.touch();
+    beforePush.accept(group, user);
+    userPushService.push(user, new GroupLeftEvent(group));
+    groupReadService.publish(group);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupOwnerController.java

@@ -0,0 +1,58 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.requests.GroupChangePasswordRequest;
+import de.ph87.tools.group.requests.GroupChangeTitleRequest;
+import de.ph87.tools.group.requests.GroupUserRequest;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import jakarta.annotation.Nullable;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@CrossOrigin
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("Group")
+public class GroupOwnerController {
+
+  private final GroupOwnerService groupOwnerService;
+
+  @GetMapping("create")
+  public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
+    return groupOwnerService.create(privateUuid, response);
+  }
+
+  @PostMapping("delete")
+  public void delete(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    groupOwnerService.delete(privateUuid, groupUuid);
+  }
+
+  @PostMapping("kick")
+  public void kick(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupUserRequest request) {
+    groupOwnerService.kick(privateUuid, request);
+  }
+
+  @PostMapping("ban")
+  public void ban(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupUserRequest request) {
+    groupOwnerService.ban(privateUuid, request);
+  }
+
+  @PostMapping("unban")
+  public void unban(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupUserRequest request) {
+    groupOwnerService.unban(privateUuid, request);
+  }
+
+  @PostMapping("changeTitle")
+  public GroupDto changeTitle(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupChangeTitleRequest request) {
+    return groupOwnerService.changeTitle(privateUuid, request);
+  }
+
+  @PostMapping("changePassword")
+  public GroupDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupChangePasswordRequest request) {
+    return groupOwnerService.changePassword(privateUuid, request);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupOwnerService.java

@@ -0,0 +1,141 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.events.GroupDeletedEvent;
+import de.ph87.tools.group.requests.GroupChangePasswordRequest;
+import de.ph87.tools.group.requests.GroupChangeTitleRequest;
+import de.ph87.tools.group.requests.GroupUserRequest;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.tools.numbers.NumbersRepository;
+import de.ph87.tools.user.User;
+import de.ph87.tools.user.UserService;
+import de.ph87.tools.user.push.UserPushService;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import jakarta.annotation.Nullable;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.function.BiConsumer;
+
+@Slf4j
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class GroupOwnerService {
+
+  private final GroupAccessService groupAccessService;
+
+  private final GroupRepository groupRepository;
+
+  private final UserService userService;
+
+  private final GroupReadService groupReadService;
+
+  private final GroupMemberService groupMemberService;
+
+  private final NumbersRepository numbersRepository;
+
+  private final UserPushService userPushService;
+
+  @NonNull
+  public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
+    final User user = userService.getUserByPrivateUuidOrElseCreate(privateUuid, response);
+    final Group group = _create_unchecked(user);
+    return groupMemberService._add_user_to_group_unchecked(group, user);
+  }
+
+  public void delete(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
+    final GroupAccess access = groupAccessService.ownerAccess(userPrivateUuid, groupUuid);
+    numbersRepository.deleteAllByGroup(access.group);
+    groupRepository.delete(access.group);
+    log.info("Group deleted: group={}", access.group);
+
+    final GroupDeletedEvent event = new GroupDeletedEvent(access.group);
+    access.group.getUsers().forEach(user -> userPushService.push(user, event));
+  }
+
+  public void kick(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUserRequest request) {
+    final OwnerRemoveResult result = _removeUser(privateUuid, request, (group, user) -> log.info("User kicked out of group: user={}, group={}", user, group));
+    groupReadService.publish(result.group);
+  }
+
+  public void ban(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUserRequest request) {
+    final OwnerRemoveResult result = _removeUser(privateUuid, request, (group, user) -> log.info("User banned from group: user={}, group={}", user, group));
+    result.group.getBanned().add(result.kicked);
+    groupReadService.publish(result.group);
+  }
+
+  public void unban(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUserRequest request) {
+    final GroupAccess access = groupAccessService.ownerAccess(privateUuid, request.groupUuid);
+    final User user = access.group.getBanned().stream().filter(u -> u.getPublicUuid().equals(request.userPublicUuid)).findFirst().orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
+    access.group.getBanned().remove(user);
+    log.info("User unbanned from group: user={}, group={}", user, access.group);
+    groupReadService.publish(access.group);
+  }
+
+  @NonNull
+  public GroupDto changeTitle(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupChangeTitleRequest request) {
+    final GroupAccess ug = groupAccessService.access(privateUuid, request.groupUuid);
+    if (!ug.group.isOwnedBy(ug.user)) {
+      throw new ResponseStatusException(HttpStatus.FORBIDDEN);
+    }
+    ug.group.setTitle(request.title);
+    return groupReadService.publish(ug.group);
+  }
+
+  @NonNull
+  public GroupDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupChangePasswordRequest request) {
+    final GroupAccess access = groupAccessService.ownerAccess(privateUuid, request.groupUuid);
+    access.group.setPassword(request.password);
+    return groupReadService.publish(access.group);
+  }
+
+  /* EXECUTORS ------------------------------------------------------------------------------------ */
+
+  @NonNull
+  private Group _create_unchecked(@NonNull final User user) {
+    final Group group = groupRepository.save(new Group(user));
+    log.info("Group CREATED: {}", group);
+    return group;
+  }
+
+  @NonNull
+  private OwnerRemoveResult _removeUser(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUserRequest request, @NonNull final BiConsumer<Group, User> beforePush) {
+    final GroupAccess access = groupAccessService.ownerAccess(privateUuid, request.groupUuid);
+    final User user = access.group.getUsers().stream().filter(u -> u.getPublicUuid().equals(request.userPublicUuid)).findFirst().orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
+    if (user.equals(access.user)) {
+      // owner cannot kick itself from group
+      throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
+    }
+    groupMemberService._remove_user_from_group_unchecked(access.group, user, beforePush);
+    return new OwnerRemoveResult(access, user);
+  }
+
+  /* RESULT CLASSES ------------------------------------------------------------------------------- */
+
+  @Getter
+  @ToString
+  private static class OwnerRemoveResult {
+
+    @NonNull
+    public final Group group;
+
+    @NonNull
+    public final User kicked;
+
+    public OwnerRemoveResult(@NonNull final GroupAccess access, @NonNull final User kicked) {
+      this.group = access.group;
+      this.kicked = kicked;
+    }
+
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupReadController.java

@@ -0,0 +1,38 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import de.ph87.tools.user.uuid.UserPublicUuid;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Set;
+
+@CrossOrigin
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("Group")
+public class GroupReadController {
+
+  private final GroupReadService groupReadService;
+
+  @PostMapping("get")
+  public GroupDto get(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    return groupReadService.get(privateUuid, groupUuid);
+  }
+
+  @NonNull
+  @GetMapping("findAllJoined")
+  public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid userUuid) {
+    return groupReadService.findAllJoined(userUuid);
+  }
+
+  @NonNull
+  @PostMapping("findAllCommon")
+  public Set<GroupDto> findAllCommon(@NonNull final UserPrivateUuid userUuid, @NonNull final UserPublicUuid targetUuid) {
+    return groupReadService.findAllCommon(userUuid, targetUuid);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupReadService.java

@@ -0,0 +1,86 @@
+package de.ph87.tools.group;
+
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.user.User;
+import de.ph87.tools.user.UserPublicDto;
+import de.ph87.tools.user.UserService;
+import de.ph87.tools.user.push.UserPushService;
+import de.ph87.tools.user.uuid.UserPrivateUuid;
+import de.ph87.tools.user.uuid.UserPublicUuid;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class GroupReadService {
+
+  private final GroupAccessService groupAccessService;
+
+  private final GroupRepository groupRepository;
+
+  private final UserPushService userPushService;
+
+  private final UserService userService;
+
+  @NonNull
+  public GroupDto get(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
+    final GroupAccess ug = groupAccessService.access(privateUuid, groupUuid);
+    return toDto(ug.group);
+  }
+
+  @NonNull
+  public Group getGroupByGroupUuid(@NonNull final GroupUuid groupUuid) {
+    return groupRepository.findByUuid(groupUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
+  }
+
+  /* DTO ------------------------------------------------------------------------------------------ */
+
+  @NonNull
+  public GroupDto toDto(@NonNull final Group group) {
+    final UserPublicDto owner = new UserPublicDto(group.getOwner());
+    final Set<UserPublicDto> users = group.getUsers().stream().map(UserPublicDto::new).collect(Collectors.toSet());
+    final Set<UserPublicDto> banned = group.getBanned().stream().map(UserPublicDto::new).collect(Collectors.toSet());
+    return new GroupDto(group, owner, users, banned);
+  }
+
+  /* PUBLISH -------------------------------------------------------------------------------------- */
+
+  @NonNull
+  public GroupDto publish(@NonNull final Group group) {
+    final GroupDto dto = toDto(group);
+    group.getUsers().forEach(user -> userPushService.push(user, dto));
+    return dto;
+  }
+
+  /* FIND & GET ----------------------------------------------------------------------------------- */
+
+  @NonNull
+  public Set<GroupDto> findAllCommonGroups(@NonNull final User a, @NonNull final User b) {
+    return groupRepository.findAllByUsersContainsAndUsersContains(a, b).stream().map(this::toDto).collect(Collectors.toSet());
+  }
+
+  @NonNull
+  public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid privateUuid) {
+    final User principal = userService.access(privateUuid);
+    return groupRepository.findAllByUsersContains(principal).stream().map(this::toDto).collect(Collectors.toSet());
+  }
+
+  @NonNull
+  public Set<GroupDto> findAllCommon(@NonNull final UserPrivateUuid privateUuid, @NonNull final UserPublicUuid targetUuid) {
+    final User principal = userService.access(privateUuid);
+    final User target = userService.getByPublicUuid(targetUuid);
+    return findAllCommonGroups(principal, target);
+  }
+
+}

src/main/java/de/ph87/tools/group/GroupService.java

@@ -1,156 +0,0 @@
-package de.ph87.tools.group;
-
-import de.ph87.tools.group.requests.GroupChangePasswordRequest;
-import de.ph87.tools.group.requests.GroupChangeTitleRequest;
-import de.ph87.tools.group.requests.GroupJoinRequest;
-import de.ph87.tools.group.uuid.GroupUuid;
-import de.ph87.tools.user.User;
-import de.ph87.tools.user.UserPublicDto;
-import de.ph87.tools.user.UserService;
-import de.ph87.tools.user.push.UserPushService;
-import de.ph87.tools.user.uuid.UserPrivateUuid;
-import de.ph87.tools.user.uuid.UserPublicUuid;
-import jakarta.annotation.Nullable;
-import jakarta.servlet.http.HttpServletResponse;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.server.ResponseStatusException;
-
-import java.util.Set;
-import java.util.stream.Collectors;
-
-@Slf4j
-@Service
-@Transactional
-@RequiredArgsConstructor
-public class GroupService {
-
-  private final GroupAccessService groupAccessService;
-
-  private final GroupRepository groupRepository;
-
-  private final UserPushService userPushService;
-
-  private final UserService userService;
-
-  @NonNull
-  public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
-    final User user = userService.getUserByPrivateUuidOrElseCreate(privateUuid, response);
-    final Group group = createUnchecked(user);
-    return doJoinUnchecked(group, user);
-  }
-
-  @NonNull
-  public GroupDto get(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    final GroupAccess ug = groupAccessService.access(privateUuid, groupUuid);
-    return toDto(ug.group);
-  }
-
-  @NonNull
-  public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
-    final User user = userService.getUserByPrivateUuidOrElseCreate(privateUuid, response);
-    final Group group = getByGroupByGroupUuid(request.uuid);
-    if (!group.getPassword().equals(request.password)) {
-      log.error("Wrong password: user={}, group={}", user, group);
-      throw new ResponseStatusException(HttpStatus.FORBIDDEN);
-    }
-    return doJoinUnchecked(group, user);
-  }
-
-  @NonNull
-  private Group getByGroupByGroupUuid(@NonNull final GroupUuid groupUuid) {
-    return groupRepository.findByUuid(groupUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
-  }
-
-  @NonNull
-  public GroupDto changeTitle(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupChangeTitleRequest request) {
-    final GroupAccess ug = groupAccessService.access(privateUuid, request.uuid);
-    if (!ug.group.isOwnedBy(ug.user)) {
-      throw new ResponseStatusException(HttpStatus.FORBIDDEN);
-    }
-    ug.group.setTitle(request.title);
-    return publish(ug.group);
-  }
-
-  @NonNull
-  public GroupDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupChangePasswordRequest request) {
-    final GroupAccess access = groupAccessService.accessAsOwner(privateUuid, request.uuid);
-    access.group.setPassword(request.password);
-    return publish(access.group);
-  }
-
-  public void leave(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
-    final User user = userService.access(privateUuid);
-    final Group group = getByGroupByGroupUuid(groupUuid);
-    doLeaveUnchecked(group, user);
-  }
-
-  /* CREATE, JOIN, LEAVE -------------------------------------------------------------------------- */
-
-  @NonNull
-  private Group createUnchecked(@NonNull final User user) {
-    final Group group = groupRepository.save(new Group(user));
-    log.info("Group CREATED: {}", group);
-    return group;
-  }
-
-  @NonNull
-  private GroupDto doJoinUnchecked(@NonNull final Group group, @NonNull final User user) {
-    group.getUsers().add(user);
-    group.touch();
-    user.touch();
-    log.info("User joined Group: user={}, group={}", user, group);
-    return publish(group);
-  }
-
-  private void doLeaveUnchecked(final Group group, final User user) {
-    group.getUsers().remove(user);
-    group.touch();
-    user.touch();
-    log.info("User left Group: user={}, group={}", user, group);
-    publish(group);
-  }
-
-  /* DTO ------------------------------------------------------------------------------------------ */
-
-  @NonNull
-  public GroupDto toDto(@NonNull final Group group) {
-    final UserPublicDto owner = new UserPublicDto(group.getOwner());
-    final Set<UserPublicDto> users = group.getUsers().stream().map(UserPublicDto::new).collect(Collectors.toSet());
-    return new GroupDto(group, owner, users);
-  }
-
-  /* PUBLISH -------------------------------------------------------------------------------------- */
-
-  @NonNull
-  public GroupDto publish(@NonNull final Group group) {
-    final GroupDto dto = toDto(group);
-    group.getUsers().forEach(user -> userPushService.push(user, dto));
-    return dto;
-  }
-
-  /* FIND & GET ----------------------------------------------------------------------------------- */
-
-  @NonNull
-  public Set<GroupDto> findAllCommonGroups(@NonNull final User a, @NonNull final User b) {
-    return groupRepository.findAllByUsersContainsAndUsersContains(a, b).stream().map(this::toDto).collect(Collectors.toSet());
-  }
-
-  @NonNull
-  public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid privateUuid) {
-    final User principal = userService.access(privateUuid);
-    return groupRepository.findAllByUsersContains(principal).stream().map(this::toDto).collect(Collectors.toSet());
-  }
-
-  @NonNull
-  public Set<GroupDto> findAllCommon(@NonNull final UserPrivateUuid privateUuid, @NonNull final UserPublicUuid targetUuid) {
-    final User principal = userService.access(privateUuid);
-    final User target = userService.getByPublicUuid(targetUuid);
-    return findAllCommonGroups(principal, target);
-  }
-
-}

src/main/java/de/ph87/tools/group/dto/GroupDto.java

@@ -1,7 +1,9 @@
-package de.ph87.tools.group;
+package de.ph87.tools.group.dto;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import de.ph87.tools.common.uuid.UuidSerializer;
+import de.ph87.tools.group.Group;
 import de.ph87.tools.group.uuid.GroupUuid;
 import de.ph87.tools.user.UserPublicDto;
 import lombok.Getter;
@@ -26,23 +28,50 @@ public class GroupDto {
   public final ZonedDateTime created;
 
   @NonNull
+  @ToString.Exclude
   public final String password;
 
   @NonNull
+  @ToString.Exclude
   public final UserPublicDto owner;
 
   @NonNull
+  @JsonIgnore
+  @ToString.Include
+  public String ownerPublicUuid() {
+    return owner.publicUuid.uuid;
+  }
+
+  @NonNull
+  @ToString.Exclude
   public final Set<UserPublicDto> users;
 
+  @JsonIgnore
+  @ToString.Include
+  public int users() {
+    return users.size();
+  }
+
+  @NonNull
+  @ToString.Exclude
+  public final Set<UserPublicDto> banned;
+
+  @JsonIgnore
+  @ToString.Include
+  public int banned() {
+    return banned.size();
+  }
+
   public final boolean initial;
 
-  public GroupDto(@NonNull final Group group, @NonNull final UserPublicDto owner, @NonNull final Set<UserPublicDto> users) {
+  public GroupDto(@NonNull final Group group, @NonNull final UserPublicDto owner, @NonNull final Set<UserPublicDto> users, @NonNull final Set<UserPublicDto> banned) {
     this.uuid = group.getUuid();
     this.title = group.getTitle();
     this.created = group.getCreated();
     this.password = group.getPassword();
     this.owner = owner;
     this.users = users;
+    this.banned = banned;
     this.initial = group.isInitial();
   }
 

src/main/java/de/ph87/tools/group/events/GroupDeletedEvent.java

@@ -0,0 +1,22 @@
+package de.ph87.tools.group.events;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import de.ph87.tools.common.uuid.UuidSerializer;
+import de.ph87.tools.group.Group;
+import de.ph87.tools.group.uuid.GroupUuid;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.ToString;
+
+@Getter
+@ToString
+public class GroupDeletedEvent {
+
+  @JsonSerialize(using = UuidSerializer.class)
+  public final GroupUuid uuid;
+
+  public GroupDeletedEvent(@NonNull final Group group) {
+    this.uuid = group.getUuid();
+  }
+
+}

src/main/java/de/ph87/tools/group/events/GroupLeftEvent.java

@@ -0,0 +1,22 @@
+package de.ph87.tools.group.events;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import de.ph87.tools.common.uuid.UuidSerializer;
+import de.ph87.tools.group.Group;
+import de.ph87.tools.group.uuid.GroupUuid;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.ToString;
+
+@Getter
+@ToString
+public class GroupLeftEvent {
+
+  @JsonSerialize(using = UuidSerializer.class)
+  public final GroupUuid uuid;
+
+  public GroupLeftEvent(@NonNull final Group group) {
+    this.uuid = group.getUuid();
+  }
+
+}

src/main/java/de/ph87/tools/group/requests/GroupChangePasswordRequest.java

@@ -15,7 +15,7 @@ public class GroupChangePasswordRequest {
 
   @NonNull
   @JsonDeserialize(using = GroupUuidDeserializer.class)
-  public final GroupUuid uuid;
+  public final GroupUuid groupUuid;
 
   @NonNull
   public final String password;

src/main/java/de/ph87/tools/group/requests/GroupChangeTitleRequest.java

@@ -15,7 +15,7 @@ public class GroupChangeTitleRequest {
 
   @NonNull
   @JsonDeserialize(using = GroupUuidDeserializer.class)
-  public final GroupUuid uuid;
+  public final GroupUuid groupUuid;
 
   @NonNull
   public final String title;

src/main/java/de/ph87/tools/group/requests/GroupJoinRequest.java

@@ -15,7 +15,7 @@ public class GroupJoinRequest {
 
   @NonNull
   @JsonDeserialize(using = GroupUuidDeserializer.class)
-  public final GroupUuid uuid;
+  public final GroupUuid groupUuid;
 
   @NonNull
   public final String password;

src/main/java/de/ph87/tools/group/requests/GroupUserRequest.java

@@ -0,0 +1,26 @@
+package de.ph87.tools.group.requests;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import de.ph87.tools.group.uuid.GroupUuid;
+import de.ph87.tools.group.uuid.GroupUuidDeserializer;
+import de.ph87.tools.user.uuid.UserPublicUuid;
+import de.ph87.tools.user.uuid.UserPublicUuidDeserializer;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.ToString;
+
+@Getter
+@ToString
+@AllArgsConstructor
+public class GroupUserRequest {
+
+  @NonNull
+  @JsonDeserialize(using = GroupUuidDeserializer.class)
+  public final GroupUuid groupUuid;
+
+  @NonNull
+  @JsonDeserialize(using = UserPublicUuidDeserializer.class)
+  public final UserPublicUuid userPublicUuid;
+
+}

src/main/java/de/ph87/tools/tools/numbers/Numbers.java

@@ -5,6 +5,7 @@ import de.ph87.tools.tools.numbers.uuid.NumbersAbstract;
 import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
 import de.ph87.tools.user.User;
 import de.ph87.tools.user.reference.UserReference;
+import jakarta.annotation.Nullable;
 import jakarta.persistence.*;
 import lombok.*;
 
@@ -43,7 +44,12 @@ public class Numbers extends NumbersAbstract {
   @Column(nullable = false)
   private ZonedDateTime date = ZonedDateTime.now();
 
+  @Column
+  @Nullable
+  private ZonedDateTime read = null;
+
   @NonNull
+  @OrderColumn
   @OneToMany(orphanRemoval = true)
   private List<UserReference> users;
 
@@ -52,14 +58,22 @@ public class Numbers extends NumbersAbstract {
     this.users = users;
   }
 
-  public int getNumberForUser(@NonNull final User user) {
+  public void setRead(@NonNull final ZonedDateTime date) {
+    if (this.read != null) {
+      throw new RuntimeException();
+    }
+    this.read = date;
+  }
+
+  @Nullable
+  public Integer getNumberForUser(@NonNull final User user) {
     for (int userReferenceIndex = 0; userReferenceIndex < users.size(); userReferenceIndex++) {
       final UserReference userReference = users.get(userReferenceIndex);
       if (userReference.getUser() != null && userReference.getUser().equals(user)) {
         return userReferenceIndex + 1;
       }
     }
-    throw new RuntimeException();
+    return null;
   }
 
   public boolean containsUser(@NonNull final User user) {

src/main/java/de/ph87/tools/tools/numbers/NumbersController.java

@@ -41,9 +41,9 @@ public class NumbersController {
   }
 
   @NonNull
-  @PostMapping("byUuid")
-  public NumbersDto byUuid(@NonNull final UserPrivateUuid privateUuid, final NumbersUuid numbersUuid) {
-    return numbersService.dtoByUuid(privateUuid, numbersUuid);
+  @PostMapping("fetchAndMarkAsRead")
+  public NumbersDto fetchAndMarkAsRead(@NonNull final UserPrivateUuid privateUuid, final NumbersUuid numbersUuid) {
+    return numbersService.fetchAndMarkAsRead(privateUuid, numbersUuid);
   }
 
 }

src/main/java/de/ph87/tools/tools/numbers/NumbersDto.java

@@ -2,9 +2,10 @@ package de.ph87.tools.tools.numbers;
 
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import de.ph87.tools.common.uuid.UuidSerializer;
-import de.ph87.tools.group.GroupDto;
+import de.ph87.tools.group.dto.GroupDto;
 import de.ph87.tools.tools.numbers.uuid.NumbersAbstract;
 import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
+import jakarta.annotation.Nullable;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.ToString;
@@ -25,11 +26,16 @@ public class NumbersDto extends NumbersAbstract {
   @NonNull
   private final ZonedDateTime date;
 
-  private final int number;
+  @Nullable
+  private final ZonedDateTime read;
 
-  public NumbersDto(@NonNull final Numbers numbers, @NonNull final GroupDto group, final int number) {
+  @Nullable
+  private final Integer number;
+
+  public NumbersDto(@NonNull final Numbers numbers, @NonNull final GroupDto group, @Nullable final Integer number) {
     this.uuid = numbers.getUuid();
     this.date = numbers.getDate();
+    this.read = numbers.getRead();
     this.group = group;
     this.number = number;
   }

src/main/java/de/ph87/tools/tools/numbers/NumbersRepository.java

@@ -6,6 +6,8 @@ import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.repository.ListCrudRepository;
 
+import java.util.List;
+
 public interface NumbersRepository extends ListCrudRepository<Numbers, String> {
 
   @NonNull
@@ -13,4 +15,6 @@ public interface NumbersRepository extends ListCrudRepository<Numbers, String> {
 
   void deleteAllByGroup(@NonNull Group group);
 
+  List<Numbers> findAllByGroupAndReadNull(@NonNull Group group);
+
 }

src/main/java/de/ph87/tools/tools/numbers/NumbersService.java

@@ -2,8 +2,8 @@ package de.ph87.tools.tools.numbers;
 
 import de.ph87.tools.group.GroupAccess;
 import de.ph87.tools.group.GroupAccessService;
-import de.ph87.tools.group.GroupDto;
-import de.ph87.tools.group.GroupService;
+import de.ph87.tools.group.dto.GroupDto;
+import de.ph87.tools.group.GroupReadService;
 import de.ph87.tools.group.uuid.GroupUuid;
 import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
 import de.ph87.tools.user.User;
@@ -23,6 +23,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.server.ResponseStatusException;
 
+import java.time.ZonedDateTime;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -40,14 +41,14 @@ public class NumbersService {
 
   private final UserReferenceService userReferenceService;
 
-  private final GroupService groupService;
+  private final GroupReadService groupReadService;
 
   private final UserPushService userPushService;
 
   private final UserService userService;
 
   public void create(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
-    final GroupAccess access = groupAccessService.accessAsOwner(userPrivateUuid, groupUuid);
+    final GroupAccess access = groupAccessService.ownerAccess(userPrivateUuid, groupUuid);
     final List<UserReference> users = access.getGroup().getUsers().stream().map(userReferenceService::create).collect(Collectors.toList());
     Collections.shuffle(users);
     final Numbers numbers = numbersRepository.save(new Numbers(access.getGroup(), users));
@@ -70,8 +71,8 @@ public class NumbersService {
 
   @NonNull
   public NumbersDto toDto(@NonNull final Numbers numbers, @NonNull final User user) {
-    final GroupDto group = groupService.toDto(numbers.getGroup());
-    final int number = numbers.getNumberForUser(user);
+    final GroupDto group = groupReadService.toDto(numbers.getGroup());
+    final Integer number = numbers.getNumberForUser(user);
     return new NumbersDto(numbers, group, number);
   }
 
@@ -88,8 +89,10 @@ public class NumbersService {
   }
 
   @NonNull
-  public NumbersDto dtoByUuid(@NonNull final UserPrivateUuid privateUuid, @NonNull final NumbersUuid numbersUuid) {
+  public NumbersDto fetchAndMarkAsRead(@NonNull final UserPrivateUuid privateUuid, @NonNull final NumbersUuid numbersUuid) {
     final NumbersAccess access = access(privateUuid, numbersUuid);
+    final ZonedDateTime now = ZonedDateTime.now();
+    numbersRepository.findAllByGroupAndReadNull(access.numbers.getGroup()).forEach(numbers -> numbers.setRead(now));
     return toDto(access.numbers, access.user);
   }
 

src/main/java/de/ph87/tools/user/UserPrivateDto.java

@@ -35,12 +35,15 @@ public class UserPrivateDto extends UserPublicAbstract {
 
   private final boolean password;
 
+  private final boolean admin;
+
   public UserPrivateDto(@NonNull final User user) {
     this.publicUuid = user.getPublicUuid();
     this.privateUuid = user.getPrivateUuid();
     this.name = user.getName();
     this.created = user.getCreated();
     this.password = !user.getPassword().isEmpty();
+    this.admin = user.isAdmin();
   }
 
   @Nullable

src/main/java/de/ph87/tools/user/UserPublicDto.java

@@ -19,9 +19,12 @@ public class UserPublicDto extends UserPublicAbstract {
   @NonNull
   public final String name;
 
+  public final boolean admin;
+
   public UserPublicDto(@NonNull final User user) {
     this.publicUuid = user.getPublicUuid();
     this.name = user.getName();
+    this.admin = user.isAdmin();
   }
 
 }

src/main/java/de/ph87/tools/user/uuid/UserPrivateUuidArgumentResolver.java

@@ -31,7 +31,14 @@ public class UserPrivateUuidArgumentResolver implements HandlerMethodArgumentRes
     if (!(webRequest.getNativeRequest() instanceof final HttpServletRequest request)) {
       throw new RuntimeException();
     }
-    final String uuid = Arrays.stream(request.getCookies()).filter(cookie -> USER_UUID_COOKIE_NAME.equalsIgnoreCase(cookie.getName())).findFirst().map(Cookie::getValue).orElse(null);
+    final Cookie[] cookies = request.getCookies();
+    if (cookies == null) {
+      if (!nullable) {
+        throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+      }
+      return null;
+    }
+    final String uuid = Arrays.stream(cookies).filter(cookie -> USER_UUID_COOKIE_NAME.equalsIgnoreCase(cookie.getName())).findFirst().map(Cookie::getValue).orElse(null);
     if (uuid == null || uuid.length() != 36) {
       if (!nullable) {
         throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);

src/main/java/de/ph87/tools/user/uuid/UserPublicUuidDeserializer.java

@@ -0,0 +1,18 @@
+package de.ph87.tools.user.uuid;
+
+import de.ph87.tools.common.uuid.AbstractUuidDeserializer;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+
+@Getter
+@NoArgsConstructor
+public class UserPublicUuidDeserializer extends AbstractUuidDeserializer {
+
+  @NonNull
+  @Override
+  protected UserPublicUuid create(@NonNull final String s) {
+    return new UserPublicUuid(s);
+  }
+
+}