patrick/Tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: patrick:3881f9b15fa30371d8ab51117f4670c016ef06a4
Branches Tags
patrick:master
..
compare: patrick:24c873f0ba74c68f8f39e833eadd6cbd957c2f75
Branches Tags
patrick:master

No commits in common. "3881f9b15fa30371d8ab51117f4670c016ef06a4" and "24c873f0ba74c68f8f39e833eadd6cbd957c2f75" have entirely different histories.
3881f9b15f ... 24c873f0ba

52 changed files with 394 additions and 908 deletions
Show Stats Expand all files Collapse all files

12
src/main/angular/src/app/api/Subscribed.ts
View File

@ -20,7 +20,10 @@ export class Subscribed<T> {
set value(value: T | null) {
if (!this.isSame(value)) {
this.unsubscribe();
if (this.subscription) {
this.subscription.unsubscribe();
this.subscription = null;
}
if (value) {
this.subscription = this.subscribe(value, next => this.value = next);
}
@ -28,13 +31,6 @@ export class Subscribed<T> {
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;

8
src/main/angular/src/app/api/User/user.service.ts
View File

@ -7,17 +7,15 @@ import {EventType, Router} from "@angular/router";
import {BehaviorSubject, filter, Subject, Subscription} from "rxjs";
import {Group} from "../group/Group";
import {StompService} from "@stomp/ng2-stompjs";
import {Numbers} from "../tools/Numbers/Numbers";
import {NumbersPrivateDto} from "../tools/Numbers/NumbersPrivateDto";
function userPushMessageFromJson(json: any): object {
const type = json['_type_'];
switch (type) {
case 'NumbersDto':
return Numbers.fromJson(json['payload']);
case 'NumbersPrivateDto':
return NumbersPrivateDto.fromJson(json['payload']);
case 'UserPrivateDto':
return UserPrivate.fromJson(json['payload']);
case 'GroupDto':
return Group.fromJson(json['payload']);
}
throw new Error("Not implemented UserPushMessage._type_ = " + type);
}

4
src/main/angular/src/app/api/common/api.service.ts
View File

@ -52,10 +52,6 @@ export class ApiService {
return this.http.get<any>(getApiUrl('http', path), {withCredentials: true}).pipe(map(fromJson)).subscribe(next);
}
getPage<T>(path: any[], fromJson: FromJson<T>, next: Next<Page<T>> | undefined = undefined): Subscription {
return this.http.get<any>(getApiUrl('http', path), {withCredentials: true}).pipe(map(Page.fromJson(fromJson))).subscribe(next);
}
getList<T>(path: any[], fromJson: FromJson<T>, next: Next<T[]> | undefined = undefined): Subscription {
return this.http.get<any[]>(getApiUrl('http', path), {withCredentials: true}).pipe(map(list => list.map(fromJson))).subscribe(next);
}

16
src/main/angular/src/app/api/group/group.service.ts
View File

@ -32,7 +32,7 @@ export class GroupService {
this.api.postList(['Group', 'findAllCommon'], uuid, Group.fromJson, next);
}
findAllJoined(next: Next<Group[]>): void {
findAllJoined(next: Next<Group[]>) {
this.api.getList(['Group', 'findAllJoined'], Group.fromJson, next);
}
@ -40,7 +40,7 @@ export class GroupService {
this.api.getSingle(['Group', 'create'], Group.fromJson, next);
}
changeTitle(group: Group, title: string, next?: Next<Group>): void {
changeTitle(group: Group, title: string, next?: Next<Group>) {
const data = {
uuid: group.uuid,
title: title,
@ -48,7 +48,7 @@ export class GroupService {
this.api.postSingle(['Group', 'changeTitle'], data, Group.fromJson, next);
}
changePassword(group: Group, password: string, next?: Next<Group>): void {
changePassword(group: Group, password: string, next?: Next<Group>) {
const data = {
uuid: group.uuid,
password: password,
@ -68,7 +68,7 @@ export class GroupService {
this.api.postNone(['Group', 'leave'], group, next);
}
goto(uuid: string): void {
goto(uuid: string) {
this.router.navigate(['Group', uuid]);
}
@ -76,13 +76,5 @@ export class GroupService {
return new Subscribed<Group>(Group.sameUuid, (group, next) => this.api.subscribe(['Group', group.uuid], Group.fromJson, next));
}
gotoGroups(): void {
this.router.navigate(['Groups']);
}
delete(group: Group, next: Next<void>): void {
this.api.postNone(['Group', 'delete'], group.uuid, next);
}
}

6
src/main/angular/src/app/api/tools/Numbers/Numbers.ts → src/main/angular/src/app/api/tools/Numbers/NumbersPrivateDto.ts
View File

@ -1,7 +1,7 @@
import {Group} from "../../group/Group";
import {validateDate, validateNumber, validateString} from "../../common/validators";
export class Numbers {
export class NumbersPrivateDto {
constructor(
readonly uuid: string,
@ -12,8 +12,8 @@ export class Numbers {
// -
}
static fromJson(json: any): Numbers {
return new Numbers(
static fromJson(json: any): NumbersPrivateDto {
return new NumbersPrivateDto(
validateString(json['uuid']),
Group.fromJson(json['group']),
validateDate(json['date']),

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

@ -3,9 +3,8 @@ import {ApiService} from "../../common/api.service";
import {Router} from "@angular/router";
import {UserService} from "../../User/user.service";
import {Next} from "../../common/types";
import {Numbers} from "./Numbers";
import {NumbersPrivateDto} from "./NumbersPrivateDto";
import {validateBoolean, validateString} from "../../common/validators";
import {Page} from "../../common/Page";
@Injectable({
providedIn: 'root'
@ -17,29 +16,25 @@ export class NumbersService {
protected readonly router: Router,
protected readonly userService: UserService
) {
this.userService.subscribePush<Numbers>(m => m instanceof Numbers, message => {
this.userService.subscribePush<NumbersPrivateDto>(m => m instanceof NumbersPrivateDto, message => {
this.router.navigate(['Numbers', message.uuid])
});
}
create(groupUuid: string): void {
create(groupUuid: string) {
this.api.getNone(['Numbers', 'create', groupUuid]);
}
page(groupUuid: string, page: number, pageSize: number, next: Next<Page<Numbers>>): void {
this.api.getPage(['Numbers', 'page', groupUuid, page, pageSize], Numbers.fromJson, next);
byUuid(uuid: string, next: Next<NumbersPrivateDto>) {
this.api.postSingle(['Numbers', 'byUuid'], uuid, NumbersPrivateDto.fromJson, next);
}
byUuid(numbersUuid: string, next: Next<Numbers>): void {
this.api.postSingle(['Numbers', 'byUuid'], numbersUuid, Numbers.fromJson, next);
canAccess(uuid: string, next: Next<boolean>) {
this.api.postSingle(['Numbers', 'canAccess'], uuid, validateBoolean, next);
}
canAccess(numbersUuid: string, next: Next<boolean>): void {
this.api.postSingle(['Numbers', 'canAccess'], numbersUuid, validateBoolean, next);
}
getGroupUuid(numbersUuid: string | null, next: Next<string>): void {
this.api.postSingle(['Numbers', 'getGroupUuid'], numbersUuid, validateString, next);
getGroupUuid(uuid: string | null, next: Next<string>) {
this.api.postSingle(['Numbers', 'getGroupUuid'], uuid, validateString, next);
}
}

114
src/main/angular/src/app/pages/group/group/group.component.html
View File

@ -1,86 +1,34 @@
<div class="tileContainer">
<ng-container *ngIf="group.value">
<h1>Gruppe</h1>
<table>
<tr>
<th>Erstellt</th>
<td>{{ group.value.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>
</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>
</td>
</tr>
</table>
<div class="tile" *ngIf="granted === false">
<div class="tileInner">
<div class="tileTitle">
Passwort
</div>
</div>
<div class="tileContent">
<app-password [visible]="true" (join)="join($event)"></app-password>
</div>
</div>
<button *ngIf="userService.iOwn(group.value)" (click)="numbersService.create(group.value.uuid)">Numbers</button>
<ng-container *ngIf="group.value">
</ng-container>
<div class="tile">
<div class="tileInner">
<div class="tileTitle">
Gruppe
</div>
<div class="tileContent">
<table>
<tr>
<th>Erstellt</th>
<td>{{ group.value.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>
</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>
</td>
</tr>
</table>
</div>
</div>
</div>
<div class="tile">
<div class="tileInner">
<div class="tileTitle">
Nummern
</div>
<div class="tileContent">
<div class="numbers">
<table>
<tr class="number" *ngFor="let numbers of numbersList.content">
<td>{{ numbers.date | relative:now }}</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>
</ng-container>
</div>
<app-password [visible]="granted === false" (join)="join($event)"></app-password>

47
src/main/angular/src/app/pages/group/group/group.component.ts
View File

@ -1,4 +1,4 @@
import {Component, OnDestroy, OnInit} from '@angular/core';
import {Component, OnInit} from '@angular/core';
import {DatePipe, NgForOf, NgIf} from "@angular/common";
import {FormsModule, ReactiveFormsModule} from "@angular/forms";
import {TextComponent} from "../../../shared/text/text.component";
@ -9,10 +9,6 @@ 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";
@Component({
selector: 'app-group',
@ -24,26 +20,19 @@ import {Subscription, timer} from "rxjs";
ReactiveFormsModule,
TextComponent,
FormsModule,
PasswordComponent,
RelativePipe
PasswordComponent
],
templateUrl: './group.component.html',
styleUrl: './group.component.less'
})
export class GroupComponent implements OnInit, OnDestroy {
export class GroupComponent implements OnInit {
protected readonly group: Subscribed<Group>;
protected numbersList: Page<Numbers> = Page.EMPTY;
protected granted: boolean | null = null;
protected uuid: string | null = null;
protected now: Date = new Date();
private timer?: Subscription;
constructor(
protected readonly router: Router,
protected readonly activatedRoute: ActivatedRoute,
@ -55,47 +44,33 @@ export class GroupComponent implements OnInit, OnDestroy {
}
ngOnInit(): void {
this.timer = timer(1000, 1000).subscribe(() => this.now = new Date());
this.activatedRoute.params.subscribe(params => {
const groupUuid = params['uuid'];
this.uuid = groupUuid;
const uuid = params['uuid'];
this.uuid = uuid;
this.granted = null;
if (groupUuid) {
this.groupService.canAccess(groupUuid, granted => {
if (uuid) {
this.groupService.canAccess(uuid, 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(uuid, group => this.group.value = group);
}
});
}
});
}
ngOnDestroy(): void {
if (this.timer) {
this.timer.unsubscribe();
this.timer = undefined;
}
this.group.unsubscribe();
}
protected changeTitle(group: Group, title: string): void {
protected changeTitle(group: Group, title: string) {
this.groupService.changeTitle(group, title, group => this.group.value = group);
}
protected changePassword(group: Group, password: string): void {
protected changePassword(group: Group, password: string) {
this.groupService.changePassword(group, password, group => this.group.value = group);
}
protected join(password: string): void {
protected join(password: string) {
if (this.uuid) {
this.groupService.join(this.uuid, password, group => this.group.value = group);
}
}
protected delete(group: Group): void {
this.groupService.delete(group, () => this.groupService.gotoGroups());
}
}

4
src/main/angular/src/app/pages/tools/numbers/numbers.component.ts
View File

@ -1,5 +1,5 @@
import {Component, OnDestroy, OnInit} from '@angular/core';
import {Numbers} from "../../../api/tools/Numbers/Numbers";
import {NumbersPrivateDto} from "../../../api/tools/Numbers/NumbersPrivateDto";
import {ActivatedRoute} from "@angular/router";
import {NumbersService} from "../../../api/tools/Numbers/numbers.service";
import {NgIf} from "@angular/common";
@ -24,7 +24,7 @@ import {Subscription, timer} from "rxjs";
})
export class NumbersComponent implements OnInit, OnDestroy {
protected numbers: Numbers | null = null;
protected numbers: NumbersPrivateDto | null = null;
protected now: Date = new Date();

40
src/main/java/de/ph87/tools/UserArgumentResolver.java Normal file
View File

@ -0,0 +1,40 @@
package de.ph87.tools;
import de.ph87.tools.user.User;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import lombok.NonNull;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import java.util.Arrays;
@Component
public class UserArgumentResolver implements HandlerMethodArgumentResolver {
public static final String USER_UUID_COOKIE_NAME = "PatrixToolsUserUuid";
@Override
public boolean supportsParameter(@NonNull final MethodParameter parameter) {
return parameter.getParameterType() == User.class;
}
@Override
public User resolveArgument(@NonNull final MethodParameter parameter, final ModelAndViewContainer mavContainer, @NonNull final NativeWebRequest webRequest, final WebDataBinderFactory binderFactory) {
if (!(webRequest instanceof final HttpServletRequest request)) {
return null;
}
final String uuid = Arrays.stream(request.getCookies()).filter(cookie -> USER_UUID_COOKIE_NAME.equalsIgnoreCase(cookie.getName())).findFirst().map(Cookie::getValue).orElse(null);
if (uuid == null) {
return null;
}
return null;
}
}

43
src/main/java/de/ph87/tools/common/uuid/AbstractUuid.java
View File

@ -1,43 +0,0 @@
package de.ph87.tools.common.uuid;
import lombok.Getter;
import lombok.NonNull;
import java.util.UUID;
@Getter
public abstract class AbstractUuid {
public final String uuid;
@SuppressWarnings("unused") // used by lombok @NoArgsConstructor
protected AbstractUuid() {
this(UUID.randomUUID().toString());
}
protected AbstractUuid(@NonNull final String uuid) {
if (uuid.length() != 36) {
throw new RuntimeException();
}
this.uuid = uuid;
}
@Override
public String toString() {
return uuid;
}
@Override
public int hashCode() {
return uuid.hashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj instanceof final AbstractUuid casted) {
return uuid.equals(casted.uuid);
}
return false;
}
}

20
src/main/java/de/ph87/tools/common/uuid/AbstractUuidDeserializer.java
View File

@ -1,20 +0,0 @@
package de.ph87.tools.common.uuid;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import lombok.NonNull;
import java.io.IOException;
public abstract class AbstractUuidDeserializer extends JsonDeserializer<AbstractUuid> {
@Override
public AbstractUuid deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException {
return create(jsonParser.readValueAs(String.class));
}
@NonNull
protected abstract AbstractUuid create(@NonNull final String s);
}

20
src/main/java/de/ph87/tools/common/uuid/UuidSerializer.java
View File

@ -1,20 +0,0 @@
package de.ph87.tools.common.uuid;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
public class UuidSerializer extends JsonSerializer<AbstractUuid> {
@Override
public void serialize(final AbstractUuid t, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider) throws IOException {
if (t == null) {
jsonGenerator.writeNull();
} else {
jsonGenerator.writeString(t.uuid);
}
}
}

2
src/main/java/de/ph87/tools/group/GroupAccess.java → src/main/java/de/ph87/tools/group/Access.java
View File

@ -4,7 +4,7 @@ import de.ph87.tools.user.User;
import lombok.Data;
@Data
public class GroupAccess {
public class Access {
public final User user;

43
src/main/java/de/ph87/tools/group/Group.java
View File

@ -1,7 +1,5 @@
package de.ph87.tools.group;
import de.ph87.tools.group.uuid.GroupAbstract;
import de.ph87.tools.group.uuid.GroupUuid;
import de.ph87.tools.user.User;
import de.ph87.tools.web.IWebSocketMessage;
import jakarta.persistence.*;
@ -18,36 +16,17 @@ import java.util.UUID;
@ToString
@NoArgsConstructor
@Table(name = "`group`")
public class Group extends GroupAbstract implements IWebSocketMessage {
public class Group implements IWebSocketMessage {
@Id
@NonNull
@Getter(AccessLevel.NONE)
@Column(nullable = false)
private String uuid = UUID.randomUUID().toString();
@Transient
@ToString.Exclude
private GroupUuid _uuid;
@NonNull
public GroupUuid getUuid() {
if (_uuid == null) {
_uuid = new GroupUuid(uuid);
}
return _uuid;
}
@NonNull
@ToString.Exclude
@ManyToOne(optional = false)
private User owner;
@NonNull
@ToString.Include
public String ownerPublicUuid() {
return getOwner().getPublicUuid().toString();
}
@NonNull
@Column(nullable = false)
private ZonedDateTime created = ZonedDateTime.now();
@ -89,4 +68,22 @@ public class Group extends GroupAbstract implements IWebSocketMessage {
return List.of("Number", uuid);
}
@SuppressWarnings("BooleanMethodIsAlwaysInverted")
public boolean isOwnedBy(@NonNull final User user) {
return owner.equals(user);
}
@Override
public boolean equals(final Object obj) {
if (!(obj instanceof final Group group)) {
return false;
}
return group.uuid.equals(this.uuid);
}
@Override
public int hashCode() {
return uuid.hashCode();
}
}

31
src/main/java/de/ph87/tools/group/GroupAccessService.java
View File

@ -1,10 +1,7 @@
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;
import jakarta.annotation.Nullable;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
@ -24,9 +21,7 @@ public class GroupAccessService {
private final UserService userService;
private final NumbersRepository numbersRepository;
public boolean canAccess(@Nullable final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
public boolean canAccess(@NonNull final String groupUuid, @Nullable final String userPrivateUuid) {
final User user = userService.accessOrNull(userPrivateUuid);
if (user == null) {
return false;
@ -35,32 +30,24 @@ 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) {
public Access access(@NonNull final String groupUuid, @NonNull final String userPrivateUuid) {
final User user = userService.access(userPrivateUuid);
final Group group = getByUuidOrThrow(groupUuid);
return new GroupAccess(user, group);
return new Access(user, group);
}
@NonNull
public GroupAccess accessAsOwner(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
final GroupAccess groupAccess = access(userPrivateUuid, groupUuid);
if (!groupAccess.group.isOwnedBy(groupAccess.user)) {
public Access accessAsOwner(@NonNull final String userPrivateUuid, @NonNull final String groupUuid) {
final Access access = access(groupUuid, userPrivateUuid);
if (!access.group.isOwnedBy(access.user)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
}
return groupAccess;
return access;
}
@NonNull
private Group getByUuidOrThrow(@NonNull final GroupUuid groupUuid) {
return groupRepository.findByUuid(groupUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
private Group getByUuidOrThrow(@NonNull final String groupUuid) {
return groupRepository.findById(groupUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
}
}

19
src/main/java/de/ph87/tools/group/GroupChangePasswordInbound.java Normal file
View File

@ -0,0 +1,19 @@
package de.ph87.tools.group;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupChangePasswordInbound {
@NonNull
public final String uuid;
@NonNull
public final String password;
}

19
src/main/java/de/ph87/tools/group/GroupChangeTitleRequest.java Normal file
View File

@ -0,0 +1,19 @@
package de.ph87.tools.group;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupChangeTitleRequest {
@NonNull
public final String uuid;
@NonNull
public final String title;
}

33
src/main/java/de/ph87/tools/group/GroupController.java
View File

@ -1,11 +1,5 @@
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;
@ -14,6 +8,8 @@ import org.springframework.web.bind.annotation.*;
import java.util.Set;
import static de.ph87.tools.UserArgumentResolver.USER_UUID_COOKIE_NAME;
@CrossOrigin
@RestController
@RequiredArgsConstructor
@ -25,54 +21,49 @@ public class GroupController {
private final GroupAccessService groupAccessService;
@GetMapping("create")
public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
public GroupDto create(@CookieValue(name = USER_UUID_COOKIE_NAME, required = false) @Nullable final String 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);
public boolean canAccess(@CookieValue(name = USER_UUID_COOKIE_NAME, required = false) @Nullable final String privateUuid, @NonNull @RequestBody final String groupUuid) {
return groupAccessService.canAccess(groupUuid, privateUuid);
}
@PostMapping("get")
public GroupDto get(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
public GroupDto get(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @NonNull @RequestBody final String groupUuid) {
return groupService.get(privateUuid, groupUuid);
}
@NonNull
@GetMapping("findAllJoined")
public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid userUuid) {
public Set<GroupDto> findAllJoined(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String userUuid) {
return groupService.findAllJoined(userUuid);
}
@NonNull
@PostMapping("findAllCommon")
public Set<GroupDto> findAllCommon(@NonNull final UserPrivateUuid userUuid, @NonNull final UserPublicUuid targetUuid) {
public Set<GroupDto> findAllCommon(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String userUuid, @NonNull @RequestBody final String targetUuid) {
return groupService.findAllCommon(userUuid, targetUuid);
}
@PostMapping("join")
public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull @RequestBody final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
public GroupDto join(@CookieValue(name = USER_UUID_COOKIE_NAME, required = false) @Nullable final String 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) {
public GroupDto changeTitle(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String 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) {
public GroupDto changePassword(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @NonNull @RequestBody final GroupChangePasswordInbound request) {
return groupService.changePassword(privateUuid, request);
}
@PostMapping("leave")
public void leave(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid) {
public void leave(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @NonNull @RequestBody final String groupUuid) {
groupService.leave(privateUuid, groupUuid);
}

6
src/main/java/de/ph87/tools/group/GroupDto.java
View File

@ -1,8 +1,5 @@
package de.ph87.tools.group;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import de.ph87.tools.common.uuid.UuidSerializer;
import de.ph87.tools.group.uuid.GroupUuid;
import de.ph87.tools.user.UserPublicDto;
import lombok.Getter;
import lombok.NonNull;
@ -16,8 +13,7 @@ import java.util.Set;
public class GroupDto {
@NonNull
@JsonSerialize(using = UuidSerializer.class)
public final GroupUuid uuid;
public final String uuid;
@NonNull
public final String title;

19
src/main/java/de/ph87/tools/group/GroupJoinRequest.java Normal file
View File

@ -0,0 +1,19 @@
package de.ph87.tools.group;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupJoinRequest {
@NonNull
public final String uuid;
@NonNull
public final String password;
}

32
src/main/java/de/ph87/tools/group/GroupService.java
View File

@ -1,15 +1,9 @@
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;
@ -38,20 +32,20 @@ public class GroupService {
private final UserService userService;
@NonNull
public GroupDto create(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
public GroupDto create(@Nullable final String 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);
public GroupDto get(@NonNull final String privateUuid, @NonNull final String groupUuid) {
final Access ug = groupAccessService.access(groupUuid, privateUuid);
return toDto(ug.group);
}
@NonNull
public GroupDto join(@Nullable final UserPrivateUuid privateUuid, @NonNull final GroupJoinRequest request, @NonNull final HttpServletResponse response) {
public GroupDto join(@Nullable final String 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)) {
@ -62,13 +56,13 @@ public class GroupService {
}
@NonNull
private Group getByGroupByGroupUuid(@NonNull final GroupUuid groupUuid) {
return groupRepository.findByUuid(groupUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
private Group getByGroupByGroupUuid(@NonNull final String groupUuid) {
return groupRepository.findByUuid(groupUuid).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);
public GroupDto changeTitle(@NonNull final String privateUuid, @NonNull final GroupChangeTitleRequest request) {
final Access ug = groupAccessService.access(request.uuid, privateUuid);
if (!ug.group.isOwnedBy(ug.user)) {
throw new ResponseStatusException(HttpStatus.FORBIDDEN);
}
@ -77,13 +71,13 @@ public class GroupService {
}
@NonNull
public GroupDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupChangePasswordRequest request) {
final GroupAccess access = groupAccessService.accessAsOwner(privateUuid, request.uuid);
public GroupDto changePassword(@NonNull final String privateUuid, @NonNull final GroupChangePasswordInbound request) {
final Access 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) {
public void leave(@NonNull final String privateUuid, @NonNull final String groupUuid) {
final User user = userService.access(privateUuid);
final Group group = getByGroupByGroupUuid(groupUuid);
doLeaveUnchecked(group, user);
@ -141,13 +135,13 @@ public class GroupService {
}
@NonNull
public Set<GroupDto> findAllJoined(@NonNull final UserPrivateUuid privateUuid) {
public Set<GroupDto> findAllJoined(@NonNull final String 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) {
public Set<GroupDto> findAllCommon(@NonNull final String privateUuid, @NonNull final String targetUuid) {
final User principal = userService.access(privateUuid);
final User target = userService.getByPublicUuid(targetUuid);
return findAllCommonGroups(principal, target);

23
src/main/java/de/ph87/tools/group/requests/GroupChangePasswordRequest.java
View File

@ -1,23 +0,0 @@
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 lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupChangePasswordRequest {
@NonNull
@JsonDeserialize(using = GroupUuidDeserializer.class)
public final GroupUuid uuid;
@NonNull
public final String password;
}

23
src/main/java/de/ph87/tools/group/requests/GroupChangeTitleRequest.java
View File

@ -1,23 +0,0 @@
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 lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupChangeTitleRequest {
@NonNull
@JsonDeserialize(using = GroupUuidDeserializer.class)
public final GroupUuid uuid;
@NonNull
public final String title;
}

23
src/main/java/de/ph87/tools/group/requests/GroupJoinRequest.java
View File

@ -1,23 +0,0 @@
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 lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
@AllArgsConstructor
public class GroupJoinRequest {
@NonNull
@JsonDeserialize(using = GroupUuidDeserializer.class)
public final GroupUuid uuid;
@NonNull
public final String password;
}

30
src/main/java/de/ph87/tools/group/uuid/GroupAbstract.java
View File

@ -1,30 +0,0 @@
package de.ph87.tools.group.uuid;
import de.ph87.tools.user.uuid.UserPublicAbstract;
import lombok.NonNull;
public abstract class GroupAbstract {
public abstract GroupUuid getUuid();
public abstract UserPublicAbstract getOwner();
@SuppressWarnings("BooleanMethodIsAlwaysInverted")
public boolean isOwnedBy(@NonNull final UserPublicAbstract user) {
return getOwner().equals(user);
}
@Override
public boolean equals(final Object obj) {
if (obj instanceof final GroupAbstract casted) {
return casted.getUuid().equals(this.getUuid());
}
return false;
}
@Override
public int hashCode() {
return getUuid().hashCode();
}
}

16
src/main/java/de/ph87/tools/group/uuid/GroupUuid.java
View File

@ -1,16 +0,0 @@
package de.ph87.tools.group.uuid;
import de.ph87.tools.common.uuid.AbstractUuid;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
@Getter
@NoArgsConstructor
public class GroupUuid extends AbstractUuid {
public GroupUuid(@NonNull final String uuid) {
super(uuid);
}
}

33
src/main/java/de/ph87/tools/group/uuid/GroupUuidArgumentResolver.java
View File

@ -1,33 +0,0 @@
package de.ph87.tools.group.uuid;
import jakarta.servlet.http.HttpServletRequest;
import lombok.NonNull;
import lombok.SneakyThrows;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import java.io.IOException;
@Component
public class GroupUuidArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(@NonNull final MethodParameter parameter) {
return parameter.getParameterType() == GroupUuid.class;
}
@Override
@SneakyThrows(IOException.class)
public GroupUuid resolveArgument(@NonNull final MethodParameter parameter, final ModelAndViewContainer mavContainer, @NonNull final NativeWebRequest webRequest, final WebDataBinderFactory binderFactory) {
if (!(webRequest.getNativeRequest() instanceof final HttpServletRequest request)) {
throw new RuntimeException();
}
final String uuid = new String(request.getInputStream().readAllBytes());
return new GroupUuid(uuid);
}
}

18
src/main/java/de/ph87/tools/group/uuid/GroupUuidDeserializer.java
View File

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

39
src/main/java/de/ph87/tools/tools/numbers/Numbers.java
View File

@ -1,12 +1,13 @@
package de.ph87.tools.tools.numbers;
import de.ph87.tools.group.Group;
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.persistence.*;
import lombok.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.ToString;
import java.time.ZonedDateTime;
import java.util.List;
@ -17,24 +18,13 @@ import java.util.UUID;
@ToString
@NoArgsConstructor
@Table(name = "`numbers`")
public class Numbers extends NumbersAbstract {
public class Numbers {
@Id
@NonNull
@Getter(AccessLevel.NONE)
@Column(nullable = false)
private String uuid = UUID.randomUUID().toString();
@Transient
private NumbersUuid _uuid;
@NonNull
public NumbersUuid getUuid() {
if (_uuid == null) {
_uuid = new NumbersUuid(uuid);
}
return _uuid;
}
@NonNull
@ManyToOne(optional = false)
private Group group;
@ -52,18 +42,31 @@ public class Numbers extends NumbersAbstract {
this.users = users;
}
@Override
public boolean equals(final Object obj) {
if (!(obj instanceof final Numbers numbers)) {
return false;
}
return numbers.uuid.equals(this.uuid);
}
@Override
public int hashCode() {
return uuid.hashCode();
}
public int 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;
return userReferenceIndex;
}
}
throw new RuntimeException();
}
public boolean containsUser(@NonNull final User user) {
return users.stream().anyMatch(u -> user.equals(u.getUser()));
return users.stream().anyMatch(u -> user.equalsIUser(u.getUser()));
}
}

20
src/main/java/de/ph87/tools/tools/numbers/NumbersAccess.java
View File

@ -1,20 +0,0 @@
package de.ph87.tools.tools.numbers;
import de.ph87.tools.user.User;
import lombok.Getter;
import lombok.ToString;
@Getter
@ToString
class NumbersAccess {
public final Numbers numbers;
public final User user;
public NumbersAccess(final Numbers numbers, final User user) {
this.numbers = numbers;
this.user = user;
}
}

26
src/main/java/de/ph87/tools/tools/numbers/NumbersController.java
View File

@ -1,14 +1,12 @@
package de.ph87.tools.tools.numbers;
import de.ph87.tools.group.uuid.GroupUuid;
import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
import de.ph87.tools.user.uuid.UserPrivateUuid;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;
import static de.ph87.tools.UserArgumentResolver.USER_UUID_COOKIE_NAME;
@Slf4j
@CrossOrigin
@RestController
@ -19,31 +17,25 @@ public class NumbersController {
private final NumbersService numbersService;
@GetMapping("create/{groupUuid}")
public void create(@NonNull final UserPrivateUuid privateUuid, @PathVariable final GroupUuid groupUuid) {
public void create(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @PathVariable final String groupUuid) {
numbersService.create(privateUuid, groupUuid);
}
@NonNull
@GetMapping("page/{groupUuid}/{page}/{pageSize}")
public Page<NumbersDto> page(@NonNull final UserPrivateUuid privateUuid, @PathVariable final GroupUuid groupUuid, @PathVariable final int page, @PathVariable final int pageSize) {
return numbersService.page(privateUuid, groupUuid, page, pageSize);
}
@PostMapping("canAccess")
public boolean canAccess(@NonNull final UserPrivateUuid privateUuid, final NumbersUuid numbersUuid) {
return numbersService.canAccess(privateUuid, numbersUuid);
public boolean canAccess(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @RequestBody final String groupUuid) {
return numbersService.canAccess(privateUuid, groupUuid);
}
@NonNull
@PostMapping("getGroupUuid")
public GroupUuid getGroupUuid(final NumbersUuid numbersUuid) {
return numbersService.getGroupUuid(numbersUuid);
public String getGroupUuid(@RequestBody final String groupUuid) {
return numbersService.getGroupUuid(groupUuid);
}
@NonNull
@PostMapping("byUuid")
public NumbersDto byUuid(@NonNull final UserPrivateUuid privateUuid, final NumbersUuid numbersUuid) {
return numbersService.dtoByUuid(privateUuid, numbersUuid);
public NumbersPrivateDto byUuid(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String privateUuid, @RequestBody final String groupUuid) {
return numbersService.dtoByUuid(privateUuid, groupUuid);
}
}

11
src/main/java/de/ph87/tools/tools/numbers/NumbersDto.java → src/main/java/de/ph87/tools/tools/numbers/NumbersPrivateDto.java
View File

@ -1,10 +1,6 @@
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.tools.numbers.uuid.NumbersAbstract;
import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@ -13,11 +9,10 @@ import java.time.ZonedDateTime;
@Getter
@ToString(callSuper = true)
public class NumbersDto extends NumbersAbstract {
public class NumbersPrivateDto {
@NonNull
@JsonSerialize(using = UuidSerializer.class)
private final NumbersUuid uuid;
private final String uuid;
@NonNull
private final GroupDto group;
@ -27,7 +22,7 @@ public class NumbersDto extends NumbersAbstract {
private final int number;
public NumbersDto(@NonNull final Numbers numbers, @NonNull final GroupDto group, final int number) {
public NumbersPrivateDto(@NonNull final Numbers numbers, @NonNull final GroupDto group, final int number) {
this.uuid = numbers.getUuid();
this.date = numbers.getDate();
this.group = group;

9
src/main/java/de/ph87/tools/tools/numbers/NumbersRepository.java
View File

@ -1,16 +1,7 @@
package de.ph87.tools.tools.numbers;
import de.ph87.tools.group.Group;
import lombok.NonNull;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.ListCrudRepository;
public interface NumbersRepository extends ListCrudRepository<Numbers, String> {
@NonNull
Page<Numbers> findAllByGroup(@NonNull Group group, @NonNull Pageable pageable);
void deleteAllByGroup(@NonNull Group group);
}

57
src/main/java/de/ph87/tools/tools/numbers/NumbersService.java
View File

@ -1,23 +1,18 @@
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.uuid.GroupUuid;
import de.ph87.tools.tools.numbers.uuid.NumbersUuid;
import de.ph87.tools.user.User;
import de.ph87.tools.user.UserService;
import de.ph87.tools.user.push.UserPushService;
import de.ph87.tools.user.reference.UserReference;
import de.ph87.tools.user.reference.UserReferenceService;
import de.ph87.tools.user.uuid.UserPrivateUuid;
import lombok.Getter;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -46,8 +41,8 @@ public class NumbersService {
private final UserService userService;
public void create(@NonNull final UserPrivateUuid userPrivateUuid, @NonNull final GroupUuid groupUuid) {
final GroupAccess access = groupAccessService.accessAsOwner(userPrivateUuid, groupUuid);
public void create(@NonNull final String userPrivateUuid, @NonNull final String groupUuid) {
final de.ph87.tools.group.Access access = groupAccessService.accessAsOwner(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));
@ -63,51 +58,59 @@ public class NumbersService {
}
private void publish(@NonNull final Numbers numbers, @NonNull final User user) {
final NumbersDto dto = toDto(numbers, user);
final NumbersPrivateDto dto = toPrivateDto(numbers, user);
log.debug("Sending event: {}", dto);
userPushService.push(user, dto);
}
@NonNull
public NumbersDto toDto(@NonNull final Numbers numbers, @NonNull final User user) {
public NumbersPrivateDto toPrivateDto(@NonNull final Numbers numbers, @NonNull final User user) {
final GroupDto group = groupService.toDto(numbers.getGroup());
final int number = numbers.getNumberForUser(user);
return new NumbersDto(numbers, group, number);
return new NumbersPrivateDto(numbers, group, number);
}
public boolean canAccess(@NonNull final UserPrivateUuid privateUuid, @NonNull final NumbersUuid numbersUuid) {
public boolean canAccess(@NonNull final String privateUuid, @NonNull final String numbersUuid) {
final User user = userService.access(privateUuid);
final Numbers numbers = numbersRepository.findById(numbersUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
final Numbers numbers = numbersRepository.findById(numbersUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
return numbers.containsUser(user);
}
@NonNull
public GroupUuid getGroupUuid(@NonNull final NumbersUuid numbersUuid) {
final Numbers numbers = numbersRepository.findById(numbersUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
public String getGroupUuid(@NonNull final String numbersUuid) {
final Numbers numbers = numbersRepository.findById(numbersUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
return numbers.getGroup().getUuid();
}
@NonNull
public NumbersDto dtoByUuid(@NonNull final UserPrivateUuid privateUuid, @NonNull final NumbersUuid numbersUuid) {
final NumbersAccess access = access(privateUuid, numbersUuid);
return toDto(access.numbers, access.user);
public NumbersPrivateDto dtoByUuid(@NonNull final String privateUuid, @NonNull final String numbersUuid) {
final Access access = access(privateUuid, numbersUuid);
return toPrivateDto(access.numbers, access.user);
}
@NonNull
private NumbersAccess access(@NonNull final UserPrivateUuid privateUuid, @NonNull final NumbersUuid numbersUuid) {
private Access access(@NonNull final String privateUuid, @NonNull final String numbersUuid) {
final User user = userService.access(privateUuid);
final Numbers numbers = numbersRepository.findById(numbersUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
final Numbers numbers = numbersRepository.findById(numbersUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
if (!numbers.containsUser(user)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
}
return new NumbersAccess(numbers, user);
return new Access(numbers, user);
}
@NonNull
public Page<NumbersDto> page(@NonNull final UserPrivateUuid privateUuid, @NonNull final GroupUuid groupUuid, final int page, final int pageSize) {
final GroupAccess access = groupAccessService.access(privateUuid, groupUuid);
final PageRequest pageable = PageRequest.of(page, pageSize, Sort.by(new Sort.Order(Sort.Direction.DESC, "date")));
return numbersRepository.findAllByGroup(access.group, pageable).map(numbers -> toDto(numbers, access.user));
@Getter
@ToString
private static class Access {
public final Numbers numbers;
public final User user;
public Access(final Numbers numbers, final User user) {
this.numbers = numbers;
this.user = user;
}
}
}

20
src/main/java/de/ph87/tools/tools/numbers/uuid/NumbersAbstract.java
View File

@ -1,20 +0,0 @@
package de.ph87.tools.tools.numbers.uuid;
public abstract class NumbersAbstract {
public abstract NumbersUuid getUuid();
@Override
public boolean equals(final Object obj) {
if (obj instanceof final NumbersAbstract casted) {
return casted.getUuid().equals(this.getUuid());
}
return false;
}
@Override
public int hashCode() {
return getUuid().hashCode();
}
}

16
src/main/java/de/ph87/tools/tools/numbers/uuid/NumbersUuid.java
View File

@ -1,16 +0,0 @@
package de.ph87.tools.tools.numbers.uuid;
import de.ph87.tools.common.uuid.AbstractUuid;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
@Getter
@NoArgsConstructor
public class NumbersUuid extends AbstractUuid {
public NumbersUuid(@NonNull final String uuid) {
super(uuid);
}
}

33
src/main/java/de/ph87/tools/tools/numbers/uuid/NumbersUuidArgumentResolver.java
View File

@ -1,33 +0,0 @@
package de.ph87.tools.tools.numbers.uuid;
import jakarta.servlet.http.HttpServletRequest;
import lombok.NonNull;
import lombok.SneakyThrows;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import java.io.IOException;
@Component
public class NumbersUuidArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(@NonNull final MethodParameter parameter) {
return parameter.getParameterType() == NumbersUuid.class;
}
@Override
@SneakyThrows(IOException.class)
public NumbersUuid resolveArgument(@NonNull final MethodParameter parameter, final ModelAndViewContainer mavContainer, @NonNull final NativeWebRequest webRequest, final WebDataBinderFactory binderFactory) {
if (!(webRequest.getNativeRequest() instanceof final HttpServletRequest request)) {
throw new RuntimeException();
}
final String uuid = new String(request.getInputStream().readAllBytes());
return new NumbersUuid(uuid);
}
}

4
src/main/java/de/ph87/tools/user/requests/UserLoginRequest.java → src/main/java/de/ph87/tools/user/LoginRequest.java
View File

@ -1,4 +1,4 @@
package de.ph87.tools.user.requests;
package de.ph87.tools.user;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@ -7,7 +7,7 @@ import lombok.ToString;
@Getter
@ToString
@RequiredArgsConstructor
public class UserLoginRequest {
public class LoginRequest {
public final String name;

40
src/main/java/de/ph87/tools/user/User.java
View File

@ -1,9 +1,10 @@
package de.ph87.tools.user;
import de.ph87.tools.user.uuid.UserPrivateUuid;
import de.ph87.tools.user.uuid.UserPublicAbstract;
import de.ph87.tools.user.uuid.UserPublicUuid;
import jakarta.persistence.*;
import de.ph87.tools.user.reference.IUser;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.*;
import org.springframework.security.crypto.password.PasswordEncoder;
@ -15,39 +16,16 @@ import java.util.UUID;
@ToString
@NoArgsConstructor
@Table(name = "`user`")
public class User extends UserPublicAbstract {
public class User extends IUser {
@Id
@NonNull
@Getter(AccessLevel.NONE)
private String publicUuid = UUID.randomUUID().toString();
@Transient
private UserPublicUuid _publicUuid;
@NonNull
public UserPublicUuid getPublicUuid() {
if (_publicUuid == null) {
_publicUuid = new UserPublicUuid(publicUuid);
}
return _publicUuid;
}
@NonNull
@Getter(AccessLevel.NONE)
@Column(nullable = false, unique = true, updatable = false)
@Column(nullable = false)
private String privateUuid = UUID.randomUUID().toString();
@Transient
private UserPrivateUuid _privateUuid;
@NonNull
public UserPrivateUuid getPrivateUuid() {
if (_privateUuid == null) {
_privateUuid = new UserPrivateUuid(privateUuid);
}
return _privateUuid;
}
@Column(nullable = false)
private String publicUuid = UUID.randomUUID().toString();
@NonNull
@Column(nullable = false)

29
src/main/java/de/ph87/tools/user/UserCommonDto.java Normal file
View File

@ -0,0 +1,29 @@
package de.ph87.tools.user;
import de.ph87.tools.group.GroupDto;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
import java.util.Set;
@Getter
@ToString
public class UserCommonDto {
@NonNull
public final String publicUuid;
@NonNull
public final String name;
@NonNull
public final Set<GroupDto> commonGroups;
public UserCommonDto(@NonNull final User target, @NonNull final Set<GroupDto> commonGroups) {
this.publicUuid = target.getPublicUuid();
this.name = target.getName();
this.commonGroups = commonGroups;
}
}

17
src/main/java/de/ph87/tools/user/UserController.java
View File

@ -1,8 +1,5 @@
package de.ph87.tools.user;
import de.ph87.tools.user.requests.UserLoginRequest;
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;
@ -10,6 +7,8 @@ import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import static de.ph87.tools.UserArgumentResolver.USER_UUID_COOKIE_NAME;
@Slf4j
@CrossOrigin
@RestController
@ -21,36 +20,36 @@ public class UserController {
@Nullable
@GetMapping("whoAmI")
public UserPrivateDto whoAmI(@Nullable final UserPrivateUuid userUuid, @NonNull final HttpServletResponse response) {
public UserPrivateDto whoAmI(@CookieValue(name = USER_UUID_COOKIE_NAME, required = false) @Nullable final String userUuid, @NonNull final HttpServletResponse response) {
return userService.whoAmI(userUuid, response);
}
@NonNull
@PostMapping("getByPublicUuid")
public UserPublicDto getByPublicUuid(@NonNull final UserPublicUuid publicUuid) {
public UserPublicDto getByPublicUuid(@NonNull @RequestBody final String publicUuid) {
return userService.getDtoByPublicUuid(publicUuid);
}
@Nullable
@GetMapping("login")
public UserPrivateDto login(@NonNull @RequestBody final UserLoginRequest loginRequest, @NonNull final HttpServletResponse response) {
public UserPrivateDto login(@NonNull @RequestBody final LoginRequest loginRequest, @NonNull final HttpServletResponse response) {
return userService.login(loginRequest, response);
}
@NonNull
@PostMapping("changeName")
public UserPrivateDto changeName(@NonNull final UserPrivateUuid userUuid, @NonNull @RequestBody final String name) {
public UserPrivateDto changeName(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String userUuid, @NonNull @RequestBody final String name) {
return userService.changeName(userUuid, name);
}
@NonNull
@PostMapping("changePassword")
public UserPrivateDto changePassword(@NonNull final UserPrivateUuid userUuid, @NonNull @RequestBody final String password) {
public UserPrivateDto changePassword(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String userUuid, @NonNull @RequestBody final String password) {
return userService.changePassword(userUuid, password);
}
@GetMapping("delete")
public void delete(@NonNull final UserPrivateUuid userUuid, @NonNull final HttpServletResponse response) {
public void delete(@CookieValue(name = USER_UUID_COOKIE_NAME) @NonNull final String userUuid, @NonNull final HttpServletResponse response) {
userService.delete(userUuid, response);
}

20
src/main/java/de/ph87/tools/user/UserPrivateDto.java
View File

@ -1,10 +1,6 @@
package de.ph87.tools.user;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import de.ph87.tools.common.uuid.UuidSerializer;
import de.ph87.tools.user.uuid.UserPrivateUuid;
import de.ph87.tools.user.uuid.UserPublicAbstract;
import de.ph87.tools.user.uuid.UserPublicUuid;
import de.ph87.tools.user.reference.IUser;
import jakarta.annotation.Nullable;
import lombok.Getter;
import lombok.NonNull;
@ -14,22 +10,20 @@ import java.time.ZonedDateTime;
@Getter
@ToString
public class UserPrivateDto extends UserPublicAbstract {
public class UserPrivateDto extends IUser {
@NonNull
private final String pushType = "UserPrivate";
@NonNull
@JsonSerialize(using = UuidSerializer.class)
public final UserPublicUuid publicUuid;
@NonNull
@JsonSerialize(using = UuidSerializer.class)
public final UserPrivateUuid privateUuid;
public final String publicUuid;
@NonNull
public final String name;
@NonNull
public final String privateUuid;
@NonNull
public final ZonedDateTime created;
@ -37,8 +31,8 @@ public class UserPrivateDto extends UserPublicAbstract {
public UserPrivateDto(@NonNull final User user) {
this.publicUuid = user.getPublicUuid();
this.privateUuid = user.getPrivateUuid();
this.name = user.getName();
this.privateUuid = user.getPrivateUuid();
this.created = user.getCreated();
this.password = !user.getPassword().isEmpty();
}

10
src/main/java/de/ph87/tools/user/UserPublicDto.java
View File

@ -1,20 +1,16 @@
package de.ph87.tools.user;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import de.ph87.tools.common.uuid.UuidSerializer;
import de.ph87.tools.user.uuid.UserPublicAbstract;
import de.ph87.tools.user.uuid.UserPublicUuid;
import de.ph87.tools.user.reference.IUser;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
@Getter
@ToString
public class UserPublicDto extends UserPublicAbstract {
public class UserPublicDto extends IUser {
@NonNull
@JsonSerialize(using = UuidSerializer.class)
public final UserPublicUuid publicUuid;
public final String publicUuid;
@NonNull
public final String name;

50
src/main/java/de/ph87/tools/user/UserService.java
View File

@ -1,9 +1,5 @@
package de.ph87.tools.user;
import de.ph87.tools.common.uuid.AbstractUuid;
import de.ph87.tools.user.requests.UserLoginRequest;
import de.ph87.tools.user.uuid.UserPrivateUuid;
import de.ph87.tools.user.uuid.UserPublicUuid;
import jakarta.annotation.Nullable;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletResponse;
@ -22,7 +18,7 @@ import java.util.Random;
import java.util.function.Consumer;
import java.util.regex.Pattern;
import static de.ph87.tools.user.uuid.UserPrivateUuidArgumentResolver.USER_UUID_COOKIE_NAME;
import static de.ph87.tools.UserArgumentResolver.USER_UUID_COOKIE_NAME;
@Slf4j
@Service
@ -46,7 +42,7 @@ public class UserService {
private final PasswordEncoder passwordEncoder;
@NonNull
public UserPrivateDto login(@NonNull final UserLoginRequest loginRequest, @NonNull final HttpServletResponse response) {
public UserPrivateDto login(@NonNull final LoginRequest loginRequest, @NonNull final HttpServletResponse response) {
final User user = userRepository.findByName(loginRequest.name).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
if (passwordEncoder.matches(loginRequest.password, user.getPassword())) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
@ -57,30 +53,24 @@ public class UserService {
}
@NonNull
public User getUserByPrivateUuidOrElseCreate(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
final User user = Optional
.ofNullable(privateUuid)
.map(AbstractUuid::getUuid)
.map(userRepository::findByPrivateUuid)
.filter(Optional::isPresent)
.map(Optional::get)
.orElseGet(this::createUnchecked);
public User getUserByPrivateUuidOrElseCreate(@Nullable final String privateUuid, @NonNull final HttpServletResponse response) {
final User user = Optional.ofNullable(privateUuid).map(userRepository::findByPrivateUuid).filter(Optional::isPresent).map(Optional::get).orElseGet(this::createUnchecked);
writeUserUuidCookie(response, user);
return user;
}
@Nullable
public UserPrivateDto whoAmI(@Nullable final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
if (privateUuid == null) {
public UserPrivateDto whoAmI(@Nullable final String privateUuid, final @NonNull HttpServletResponse response) {
if (privateUuid == null || privateUuid.isEmpty()) {
return null;
}
final User user = userRepository.findByPrivateUuid(privateUuid.uuid).orElse(null);
final User user = userRepository.findByPrivateUuid(privateUuid).orElse(null);
writeUserUuidCookie(response, user);
return UserPrivateDto.orNull(user);
}
@NonNull
public UserPrivateDto changeName(@NonNull final UserPrivateUuid privateUuid, @NonNull final String name) {
public UserPrivateDto changeName(@NonNull final String privateUuid, @NonNull final String name) {
return modify(privateUuid, user -> {
if (user.getName().equals(name)) {
return;
@ -104,7 +94,7 @@ public class UserService {
}
@NonNull
public UserPrivateDto changePassword(@NonNull final UserPrivateUuid privateUuid, @NonNull final String password) {
public UserPrivateDto changePassword(@NonNull final String privateUuid, @NonNull final String password) {
return modify(privateUuid, user -> {
if (password.length() < PASSWORD_MIN_LENGTH) {
log.warn("Cannot change User password: too short: length={}/{}, user={}", password.length(), PASSWORD_MIN_LENGTH, user);
@ -119,8 +109,8 @@ public class UserService {
});
}
public void delete(@NonNull final UserPrivateUuid privateUuid, @NonNull final HttpServletResponse response) {
final User user = userRepository.findByPrivateUuid(privateUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
public void delete(@NonNull final String privateUuid, final @NonNull HttpServletResponse response) {
final User user = userRepository.findByPrivateUuid(privateUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
deleteUnchecked(response, user);
}
@ -146,7 +136,7 @@ public class UserService {
}
@NonNull
private UserPrivateDto modify(@NonNull final UserPrivateUuid privateUuid, @NonNull Consumer<User> modifier) {
private UserPrivateDto modify(@NonNull final String privateUuid, @NonNull Consumer<User> modifier) {
final User user = access(privateUuid);
modifier.accept(user);
return new UserPrivateDto(user);
@ -161,8 +151,8 @@ public class UserService {
/* ACCESS --------------------------------------------------------------------------------------- */
@Nullable
public User accessOrNull(@Nullable final UserPrivateUuid userPrivateUuid) {
if (userPrivateUuid == null) {
public User accessOrNull(@Nullable final String userPrivateUuid) {
if (userPrivateUuid == null || userPrivateUuid.isEmpty()) {
return null;
}
return access(userPrivateUuid);
@ -171,18 +161,18 @@ public class UserService {
/* GETTERS & FINDERS ---------------------------------------------------------------------------- */
@NonNull
public UserPublicDto getDtoByPublicUuid(@NonNull final UserPublicUuid publicUuid) {
public UserPublicDto getDtoByPublicUuid(@NonNull final String publicUuid) {
return new UserPublicDto(getByPublicUuid(publicUuid));
}
@NonNull
public User access(@NonNull final UserPrivateUuid privateUuid) {
return userRepository.findByPrivateUuid(privateUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
public User access(@NonNull final String privateUuid) {
return userRepository.findByPrivateUuid(privateUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
}
@NonNull
public User getByPublicUuid(@NonNull final UserPublicUuid publicUuid) {
return userRepository.findByPublicUuid(publicUuid.uuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
public User getByPublicUuid(@NonNull final String publicUuid) {
return userRepository.findByPublicUuid(publicUuid).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
}
/* COOKIES -------------------------------------------------------------------------------------- */
@ -190,7 +180,7 @@ public class UserService {
private static void writeUserUuidCookie(@NonNull final HttpServletResponse response, @Nullable final User user) {
final Cookie cookie = new Cookie(USER_UUID_COOKIE_NAME, "");
if (user != null) {
cookie.setValue(user.getPrivateUuid().uuid);
cookie.setValue(user.getPrivateUuid());
}
cookie.setMaxAge(PASSWORD_MIN_LENGTH * 365 * 24 * 60 * 60);
cookie.setPath("/");

31
src/main/java/de/ph87/tools/user/reference/IUser.java Normal file
View File

@ -0,0 +1,31 @@
package de.ph87.tools.user.reference;
import jakarta.annotation.Nullable;
import lombok.NonNull;
public abstract class IUser {
@NonNull
public abstract String getPublicUuid();
@Override
public boolean equals(final Object obj) {
if (!(obj instanceof final IUser user)) {
return false;
}
return equalsIUser(user);
}
public boolean equalsIUser(@Nullable final IUser user) {
if (user == null) {
return false;
}
return user.getPublicUuid().equals(this.getPublicUuid());
}
@Override
public int hashCode() {
return getPublicUuid().hashCode();
}
}

16
src/main/java/de/ph87/tools/user/uuid/UserPrivateUuid.java
View File

@ -1,16 +0,0 @@
package de.ph87.tools.user.uuid;
import de.ph87.tools.common.uuid.AbstractUuid;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
@Getter
@NoArgsConstructor
public class UserPrivateUuid extends AbstractUuid {
public UserPrivateUuid(@NonNull final String uuid) {
super(uuid);
}
}

44
src/main/java/de/ph87/tools/user/uuid/UserPrivateUuidArgumentResolver.java
View File

@ -1,44 +0,0 @@
package de.ph87.tools.user.uuid;
import jakarta.annotation.Nullable;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import lombok.NonNull;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.server.ResponseStatusException;
import java.util.Arrays;
@Component
public class UserPrivateUuidArgumentResolver implements HandlerMethodArgumentResolver {
public static final String USER_UUID_COOKIE_NAME = "PatrixToolsUserUuid";
@Override
public boolean supportsParameter(@NonNull final MethodParameter parameter) {
return parameter.getParameterType() == UserPrivateUuid.class;
}
@Override
public UserPrivateUuid resolveArgument(@NonNull final MethodParameter parameter, final ModelAndViewContainer mavContainer, @NonNull final NativeWebRequest webRequest, final WebDataBinderFactory binderFactory) {
final boolean nullable = Arrays.stream(parameter.getParameterAnnotations()).anyMatch(annotation -> annotation.annotationType().equals(Nullable.class));
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);
if (uuid == null || uuid.length() != 36) {
if (!nullable) {
throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
}
return null;
}
return new UserPrivateUuid(uuid);
}
}

20
src/main/java/de/ph87/tools/user/uuid/UserPublicAbstract.java
View File

@ -1,20 +0,0 @@
package de.ph87.tools.user.uuid;
public abstract class UserPublicAbstract {
public abstract UserPublicUuid getPublicUuid();
@Override
public boolean equals(final Object obj) {
if (obj instanceof final UserPublicAbstract casted) {
return casted.getPublicUuid().equals(this.getPublicUuid());
}
return false;
}
@Override
public int hashCode() {
return getPublicUuid().hashCode();
}
}

16
src/main/java/de/ph87/tools/user/uuid/UserPublicUuid.java
View File

@ -1,16 +0,0 @@
package de.ph87.tools.user.uuid;
import de.ph87.tools.common.uuid.AbstractUuid;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
@Getter
@NoArgsConstructor
public class UserPublicUuid extends AbstractUuid {
public UserPublicUuid(@NonNull final String uuid) {
super(uuid);
}
}

33
src/main/java/de/ph87/tools/user/uuid/UserPublicUuidArgumentResolver.java
View File

@ -1,33 +0,0 @@
package de.ph87.tools.user.uuid;
import jakarta.servlet.http.HttpServletRequest;
import lombok.NonNull;
import lombok.SneakyThrows;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import java.io.IOException;
@Component
public class UserPublicUuidArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(@NonNull final MethodParameter parameter) {
return parameter.getParameterType() == UserPublicUuid.class;
}
@Override
@SneakyThrows(IOException.class)
public UserPublicUuid resolveArgument(@NonNull final MethodParameter parameter, final ModelAndViewContainer mavContainer, @NonNull final NativeWebRequest webRequest, final WebDataBinderFactory binderFactory) {
if (!(webRequest.getNativeRequest() instanceof final HttpServletRequest request)) {
throw new RuntimeException();
}
final String uuid = new String(request.getInputStream().readAllBytes());
return new UserPublicUuid(uuid);
}
}

14
src/main/java/de/ph87/tools/web/WebConfig.java
View File

@ -1,15 +1,11 @@
package de.ph87.tools.web;
import de.ph87.tools.group.uuid.GroupUuidArgumentResolver;
import de.ph87.tools.tools.numbers.uuid.NumbersUuidArgumentResolver;
import de.ph87.tools.user.uuid.UserPrivateUuidArgumentResolver;
import de.ph87.tools.user.uuid.UserPublicUuidArgumentResolver;
import de.ph87.tools.UserArgumentResolver;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.data.web.config.EnableSpringDataWebSupport;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
@ -19,19 +15,13 @@ import org.springframework.web.servlet.resource.PathResourceResolver;
import java.io.IOException;
import java.util.List;
import static org.springframework.data.web.config.EnableSpringDataWebSupport.PageSerializationMode.VIA_DTO;
@Configuration
@RequiredArgsConstructor
@EnableSpringDataWebSupport(pageSerializationMode = VIA_DTO)
public class WebConfig implements WebMvcConfigurer {
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
argumentResolvers.add(new UserPrivateUuidArgumentResolver());
argumentResolvers.add(new UserPublicUuidArgumentResolver());
argumentResolvers.add(new GroupUuidArgumentResolver());
argumentResolvers.add(new NumbersUuidArgumentResolver());
argumentResolvers.add(new UserArgumentResolver());
}
@Override