tpeetz/kontor
1
0
Fork 0
Code Issues 7 Pull Requests 2 Actions Packages Projects Releases 3 Wiki Activity

setup multi-module project
Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s
Details

Browse Source
This commit is contained in:
Thomas Peetz
2026-08-12 15:13:06 +02:00
parent fe63a80b23
commit de2f2f34b2
444 changed files with 172041 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kontor-data/build.gradle
-39
View File
@@ -1,39 +0,0 @@
plugins {
id 'java'
id 'java-library'
id 'maven-publish'
id 'jacoco'
id 'test-report-aggregation'
id 'jacoco-report-aggregation'
alias(libs.plugins.lombok)
}
repositories {
//maven { setUrl("https://nexus.thpeetz.de/repository/maven-central") }
mavenCentral()
maven { setUrl("https://repo.spring.io/milestone") }
}
java {
sourceCompatibility = JavaVersion.VERSION_21
}
configurations {
developmentOnly
runtimeClasspath {
extendsFrom developmentOnly
}
}
dependencies {
//implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
//implementation 'org.postgresql:postgresql'
//implementation 'org.hibernate.orm:hibernate-community-dialects'
compileOnly libs.spring.data
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
}
wrapper {
gradleVersion = "8.6"
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/data/Assignment.java
-34
View File
@@ -1,34 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Assignment extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "profile_id")
@NotNull
private Profile profile;
@ManyToOne
@JoinColumn(name = "permission_id")
@NotNull
private Permission permission;
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Assignment{");
sb.append("profile=").append(profile.getUserName());
sb.append(", permission=").append(permission.getName());
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/data/Permission.java
-29
View File
@@ -1,29 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Nullable;
import java.util.List;
@Slf4j
@Getter
@Setter
@ToString
@Entity
public class Permission extends AbstractEntity {
@NotEmpty
private String name;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "permission")
@Nullable
private List<Assignment> assignments;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/data/Profile.java
-57
View File
@@ -1,57 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Nullable;
import java.util.LinkedList;
import java.util.List;
@Slf4j
@Getter
@Setter
@ToString
@Entity
@Table(indexes = @Index(columnList = "userName"), uniqueConstraints = @UniqueConstraint(columnNames = {"userName"}))
public class Profile extends AbstractEntity {
private String firstName;
private String lastName;
@NotEmpty
private String userName;
private String email;
private String password;
private boolean enabled;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "profile")
@Nullable
private List<Assignment> assignments = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "profile")
@Nullable
private List<Token> tokens = new LinkedList<>();
public String getFullName() {
StringBuilder fullNameBuilder = new StringBuilder();
if (firstName != null) {
fullNameBuilder.append(firstName);
}
if (lastName != null) {
if (!fullNameBuilder.isEmpty()) {
fullNameBuilder.append(" ");
}
fullNameBuilder.append(lastName);
}
return fullNameBuilder.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/data/Token.java
-37
View File
@@ -1,37 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import java.util.Date;
@Slf4j
@Getter
@Setter
@ToString
@Entity
@Table(indexes = @Index(columnList = "token"), uniqueConstraints = @UniqueConstraint(columnNames = {"token"}))
public class Token extends AbstractEntity {
private String token;
private String name;
private Date lastUsedDate;
private boolean enabled;
@ManyToOne
@JoinColumn(name="profile_id")
@NotNull
private Profile profile;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/repository/AssignmentRepository.java
-13
View File
@@ -1,13 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.admin.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface AssignmentRepository extends JpaRepository<Assignment, String> {
List<Assignment> findByProfile(Profile profile);
List<Assignment> findByPermission(Permission permission);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/repository/MailAccountRepository.java
-8
View File
@@ -1,8 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.mailclient.data.MailAccount;
import org.springframework.data.jpa.repository.JpaRepository;
public interface MailAccountRepository extends JpaRepository<MailAccount, String> {
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/repository/PermissionRepository.java
-19
View File
@@ -1,19 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.admin.data.Permission;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface PermissionRepository extends JpaRepository<Permission, String> {
@Query("select p from Permission p " +
"where lower(p.name) like lower(concat('%', :searchTerm, '%')) ")
List<Permission> search(@Param("searchTerm") String searchTerm);
@Query("select p from Permission p " +
"where lower(p.name) like lower(:name) ")
Permission findByName(@Param("name") String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/admin/repository/ProfileRepository.java
-17
View File
@@ -1,17 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.admin.data.Profile;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface ProfileRepository extends JpaRepository<Profile, String> {
@Query("select p from Profile p " +
"where lower(p.lastName) like lower(concat('%', :searchTerm, '%')) ")
List<Profile> search(@Param("searchTerm") String searchTerm);
Profile findByUserName(String userName);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/Article.java
-27
View File
@@ -1,27 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@Entity
@Table(indexes = @Index(columnList = "title"), uniqueConstraints = @UniqueConstraint(columnNames = {"title"}))
public class Article extends AbstractEntity {
@NotEmpty
private String title;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "article")
@Nullable
private List<ArticleAuthor> authors = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/ArticleAuthor.java
-29
View File
@@ -1,29 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(indexes = @Index(columnList = "author_id, article_id"), uniqueConstraints = @UniqueConstraint(columnNames = {"author_id", "article_id"}))
public class ArticleAuthor extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "author_id")
@NotNull
private Author author;
@ManyToOne
@JoinColumn(name = "article_id")
@NotNull
private Article article;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/ArticleAuthorRepository.java
-12
View File
@@ -1,12 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
public interface ArticleAuthorRepository extends JpaRepository<ArticleAuthor, String> {
List<ArticleAuthor> findByAuthor(Author author);
List<ArticleAuthor> findByArticle(Article article);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/ArticleRepository.java
-16
View File
@@ -1,16 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface ArticleRepository extends JpaRepository<Article, String> {
@Query("select a from Article a " +
"where lower(a.title) like lower(concat('%', :searchTerm, '%'))")
List<Article> search(@Param("searchTerm") String searchTerm);
List<Article> findByTitle(String title);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/Author.java
-44
View File
@@ -1,44 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@Entity
@Table(indexes = {
@Index(columnList = "firstName, lastName"),
@Index(columnList = "lastName, firstName")
}, uniqueConstraints = {
@UniqueConstraint(columnNames = { "firstName", "lastName" })
})
public class Author extends AbstractEntity {
@NotEmpty
private String firstName;
@NotEmpty
private String lastName;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "author")
@Nullable
private List<BookAuthor> bookAuthors = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "author")
@Nullable
private List<ArticleAuthor> articleAuthors = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/AuthorRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface AuthorRepository extends JpaRepository<Author, String> {
@Query("select a from Author a " +
"where lower(a.firstName) like lower(concat('%', :searchTerm, '%')) " +
"or lower(a.lastName) like lower(concat('%', :searchTerm, '%'))")
List<Author> search(@Param("searchTerm") String searchTerm);
Author findByFirstNameAndLastName(String firstName, String lastName);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/Book.java
-42
View File
@@ -1,42 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.LinkedList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@Entity
@Table(indexes = @Index(columnList = "title, isbn"), uniqueConstraints = @UniqueConstraint(columnNames = {"isbn"}))
public class Book extends AbstractEntity {
@NotEmpty
private String title;
@NotEmpty
private String isbn;
@Nullable
private int year;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "book")
@Nullable
private List<BookAuthor> authors = new LinkedList<>();
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "publisher_id")
@NotNull
@JsonIgnoreProperties({ "books" })
private BookshelfPublisher publisher;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/BookAuthor.java
-29
View File
@@ -1,29 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(indexes = @Index(columnList = "author_id, book_id"), uniqueConstraints = @UniqueConstraint(columnNames = {"author_id", "book_id"}))
public class BookAuthor extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "author_id")
@NotNull
private Author author;
@ManyToOne
@JoinColumn(name = "book_id")
@NotNull
private Book book;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/BookAuthorRepository.java
-12
View File
@@ -1,12 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
public interface BookAuthorRepository extends JpaRepository<BookAuthor, String> {
List<BookAuthor> findByAuthor(Author author);
List<BookAuthor> findByBook(Book book);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/BookRepository.java
-21
View File
@@ -1,21 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface BookRepository extends JpaRepository<Book, String> {
@Query("select b from Book b " +
"where lower(b.title) like lower(concat('%', :searchTerm, '%')) " +
"or lower(b.isbn) like lower(concat('%', :searchTerm, '%'))")
List<Book> search(@Param("searchTerm") String searchTerm);
List<Book> findByTitle(String name);
List<Book> findByTitleIgnoreCase(String name);
List<Book> findByIsbn(String isbn);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/BookshelfPublisher.java
-32
View File
@@ -1,32 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@Entity
@Table(indexes = @Index(columnList = "name"), uniqueConstraints = @UniqueConstraint(columnNames = { "name" }))
public class BookshelfPublisher extends AbstractEntity {
@NotEmpty
private String name;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "publisher", orphanRemoval = true)
@Nullable
List<Book> books = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/bookshelf/data/BookshelfPublisherRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.bookshelf.data;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface BookshelfPublisherRepository extends JpaRepository<BookshelfPublisher, String> {
@Query("select p from BookshelfPublisher p " +
"where lower(p.name) like lower(concat('%', :searchTerm, '%')) ")
List<BookshelfPublisher> search(@Param("searchTerm") String searchTerm);
BookshelfPublisher findByName(String name);
List<BookshelfPublisher> findByNameIgnoreCase(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Artist.java
-50
View File
@@ -1,50 +0,0 @@
package de.thpeetz.kontor.comics.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import io.micrometer.common.lang.Nullable;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* Represents an artist in the system.
*/
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Slf4j
@Entity
public class Artist extends AbstractEntity {
@NotEmpty
@Column(unique = true)
private String name;
private String weblink;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "artist", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<ComicWork> comicWorks = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "artist", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<IssueWork> issueWorks = new LinkedList<>();
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Artist{");
sb.append("name='").append(name).append('\'');
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Comic.java
-83
View File
@@ -1,83 +0,0 @@
package de.thpeetz.kontor.comics.data;
import java.util.LinkedList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* Represents a comic entity.
*/
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class Comic extends AbstractEntity {
@NotEmpty
@Column(unique = true)
private String title;
@ManyToOne
@JoinColumn(name = "publisher_id")
@NotNull
@JsonIgnoreProperties({ "comics" })
private Publisher publisher;
private Boolean currentOrder = false;
private Boolean completed = false;
@Nullable
private String weblink;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "comic", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<ComicWork> comicWorks;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "comic", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
private List<Issue> issues = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "comic", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
private List<StoryArc> storyArcs = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "comic", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
private List<TradePaperback> tradePaperbacks = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "comic", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
private List<Volume> volumes = new LinkedList<>();
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Comic{");
sb.append("title='").append(title).append('\'');
sb.append(", publisher=").append(publisher);
sb.append(", currentOrder=").append(currentOrder);
sb.append(", completed=").append(completed);
sb.append('}');
return sb.toString();
}
public String getPublisherName() {
return this.publisher.getName();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/ComicWork.java
-48
View File
@@ -1,48 +0,0 @@
package de.thpeetz.kontor.comics.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(indexes = {@Index(columnList = "comic_id, artist_id, workType_id") },
uniqueConstraints = @UniqueConstraint(columnNames = {"comic_id", "artist_id", "workType_id" })
)
public class ComicWork extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "comic_id")
@NotNull
private Comic comic;
@ManyToOne
@JoinColumn(name = "artist_id")
@NotNull
private Artist artist;
@ManyToOne
@JoinColumn(name = "workType_id")
@NotNull
private Worktype workType;
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("ComicWork{");
sb.append("comic=").append(comic);
sb.append(", artist=").append(artist);
sb.append(", workType=").append(workType);
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Issue.java
-108
View File
@@ -1,108 +0,0 @@
package de.thpeetz.kontor.comics.data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.*;
import io.hypersistence.utils.hibernate.type.basic.YearMonthDateType;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.Type;
import java.time.YearMonth;
import java.util.*;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class Issue extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "comic_id")
@NotNull
@JsonIgnoreProperties({ "issues" })
private Comic comic;
@ManyToOne
@JoinColumn(name = "volume_id")
@JsonIgnoreProperties({ "issues" })
@Nullable
private Volume volume;
@ManyToOne
@JoinColumn(name = "storyArc_id")
@JsonIgnoreProperties({ "issues" })
@Nullable
private StoryArc storyArc;
@NotEmpty
private String issueNumber;
@Nullable
private String title;
@Nullable
@Type(YearMonthDateType.class)
@Column(name = "published_on", columnDefinition = "date")
private YearMonth publishedOn;
private Boolean isRead;
private Boolean inStock;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "issue", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<IssueWork> issueWorks;
public String getComicTitle() {
return comic.getTitle();
}
public String getVolumeName() {
if (volume != null) {
return volume.getName();
}
return null;
}
public String getFullTitle() {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(this.getComic().getTitle());
stringBuilder.append(" #");
stringBuilder.append(this.getIssueNumber());
if (this.title !=null && !this.title.isEmpty()) {
stringBuilder.append(": ");
stringBuilder.append(this.title);
}
return stringBuilder.toString();
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append("Issue{");
result.append("comic=");
result.append(comic);
result.append(", volume=");
result.append(volume);
result.append(", storyArc=");
result.append(storyArc);
result.append(", issueNumber='");
result.append(issueNumber);
result.append(", title='");
result.append(title);
result.append(", publishedOn=");
result.append(publishedOn);
result.append(", isRead=");
result.append(isRead);
result.append(", inStock=");
result.append(inStock);
result.append("}");
return result.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/IssueWork.java
-48
View File
@@ -1,48 +0,0 @@
package de.thpeetz.kontor.comics.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(indexes = {@Index(columnList = "issue_id, artist_id, workType_id") },
uniqueConstraints = @UniqueConstraint(columnNames = {"issue_id", "artist_id", "workType_id" })
)
public class IssueWork extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "issue_id")
@NotNull
private Issue issue;
@ManyToOne
@JoinColumn(name = "artist_id")
@NotNull
private Artist artist;
@ManyToOne
@JoinColumn(name = "workType_id")
@NotNull
private Worktype workType;
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("IssueWork{");
sb.append("issue=").append(issue);
sb.append(", artist=").append(artist);
sb.append(", workType=").append(workType);
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Publisher.java
-63
View File
@@ -1,63 +0,0 @@
package de.thpeetz.kontor.comics.data;
import java.util.LinkedList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.Column;
import jakarta.persistence.OneToMany;
import jakarta.persistence.ManyToOne;
import jakarta.validation.constraints.*;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class Publisher extends AbstractEntity {
@NotEmpty
@Column(unique = true)
private String name;
private String weblink;
@JsonBackReference
@ManyToOne
@JoinColumn(name = "parent_publisher_id")
@Nullable
@JsonIgnoreProperties({ "comics" })
private Publisher parentCompany;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "parentCompany", cascade = CascadeType.ALL, orphanRemoval = true)
@Nullable
private List<Publisher> imprints = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "publisher", cascade = CascadeType.ALL, orphanRemoval = true)
@Nullable
private List<Comic> comics = new LinkedList<>();
public String getParentCompanyName() {
if (parentCompany != null) {
return parentCompany.name;
}
return null;
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Publisher{");
sb.append("name='").append(name).append('\'');
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/StoryArc.java
-46
View File
@@ -1,46 +0,0 @@
package de.thpeetz.kontor.comics.data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import jakarta.annotation.Nullable;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.util.*;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper = false)
@Entity
public class StoryArc extends AbstractEntity {
@NotEmpty
private String name;
@ManyToOne
@JoinColumn(name = "comic_id")
@NotNull
@JsonIgnoreProperties({ "storyArcs" })
private Comic comic;
@ManyToOne
@JoinColumn(name = "volume_id")
@JsonIgnoreProperties({ "storyArcs" })
@Nullable
private Volume volume;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "storyArc", cascade = CascadeType.REMOVE, orphanRemoval = true)
@Nullable
private List<Issue> issues = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/TradePaperback.java
-32
View File
@@ -1,32 +0,0 @@
package de.thpeetz.kontor.comics.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper = false)
@Entity
public class TradePaperback extends AbstractEntity {
@NotEmpty
private String name;
@ManyToOne
@JoinColumn(name = "comic_id")
@NotNull
private Comic comic;
private Integer issueStart;
private Integer issueEnd;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Volume.java
-55
View File
@@ -1,55 +0,0 @@
package de.thpeetz.kontor.comics.data;
import java.util.LinkedList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.*;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class Volume extends AbstractEntity {
@NotEmpty
private String name;
@ManyToOne
@JoinColumn(name = "comic_id")
@NotNull
@JsonIgnoreProperties({ "volumes" })
private Comic comic;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "volume", cascade = CascadeType.REMOVE, orphanRemoval = true)
@Nullable
private List<StoryArc> storyArcs = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "volume", cascade = CascadeType.REMOVE, orphanRemoval = true)
@Nullable
private List<Issue> issues = new LinkedList<>();
@Override
public String toString() {
StringBuilder result = new StringBuilder("Volume{");
result.append("name=");
result.append(name);
result.append("comic=Comic{title=");
result.append(comic.getTitle());
result.append("}}");
return result.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/data/Worktype.java
-47
View File
@@ -1,47 +0,0 @@
package de.thpeetz.kontor.comics.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import io.micrometer.common.lang.Nullable;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.OneToMany;
import jakarta.validation.constraints.NotEmpty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* Represents a work type in the application.
* This class extends the AbstractEntity class.
*/
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class Worktype extends AbstractEntity {
@NotEmpty
@Column(unique = true)
private String name;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "workType", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<ComicWork> comicWorks = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "workType", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<IssueWork> issueWorks = new LinkedList<>();
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Worktype{");
sb.append("name='").append(name).append('\'');
sb.append('}');
return sb.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/ArtistRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface ArtistRepository extends JpaRepository<Artist, String> {
@Query("select a from Artist a " +
"where lower(a.name) like lower(concat('%', :searchTerm, '%')) ")
List<Artist> search(@Param("searchTerm") String searchTerm);
List<Artist> findByNameIgnoreCase(String name);
Artist findByName(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/ComicRepository.java
-39
View File
@@ -1,39 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface ComicRepository extends JpaRepository<Comic, String> {
@Query("select c from Comic c " +
"where lower(c.title) like lower(concat('%', :searchTerm, '%')) ")
List<Comic> search(@Param("searchTerm") String searchTerm);
@Query("select c from Comic c " +
"where lower(c.title) like lower(concat('%', :searchTerm, '%')) " +
"AND c.currentOrder=:currentOrder AND c.completed=:completed")
List<Comic> search(@Param("searchTerm") String searchTerm, Boolean currentOrder, Boolean completed);
Comic findByTitleAndPublisher(String title, Publisher publisher);
List<Comic> findByTitle(String title);
List<Comic> findByTitleIgnoreCase(String title);
List<Comic> findByCurrentOrderAndCompleted(Boolean currentOrder, Boolean completed);
List<Comic> findByCurrentOrder(Boolean currentOrder);
List<Comic> findByCompleted(Boolean completed);
@Query("select c from Comic c " +
"where lower(c.title) like lower(concat('%', :searchTerm, '%')) AND c.currentOrder=:currentOrder")
List<Comic> searchAndFilterByCurrentOrder(String searchTerm, Boolean currentOrder);
@Query("select c from Comic c " +
"where lower(c.title) like lower(concat('%', :searchTerm, '%')) AND c.completed=:completed")
List<Comic> searchAndFilterByCompleted(String searchTerm, Boolean completed);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/ComicWorkRepository.java
-16
View File
@@ -1,16 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
public interface ComicWorkRepository extends JpaRepository<ComicWork, String> {
@Query("SELECT c from ComicWork c where c.comic = ?1 and c.artist = ?2 and c.workType = ?3")
ComicWork findbyComicAndArtistAndWorktype(Comic comic, Artist artist, Worktype worktype);
@Query("select c from ComicWork c where c.comic = ?1")
List<ComicWork> findByComic(Comic comic);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/IssueRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface IssueRepository extends JpaRepository<Issue, String> {
@Query("select i from Issue i " +
"where lower(i.issueNumber) like lower(concat('%', :searchTerm, '%')) ")
List<Issue> search(@Param("searchTerm") String searchTerm);
List<Issue> findByComic(Comic comic);
Issue findByComicAndIssueNumber(Comic comic, String issueNumber);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/IssueWorkRepository.java
-15
View File
@@ -1,15 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.*;
import java.util.*;
public interface IssueWorkRepository extends JpaRepository<IssueWork, String> {
@Query("SELECT i from IssueWork i where i.issue = ?1 and i.artist = ?2 and i.workType = ?3")
IssueWork findbyIssueAndArtistAndWorktype(Issue issue, Artist artist, Worktype worktype);
@Query("select i from IssueWork i where i.issue = ?1")
List<IssueWork> findByIssue(Issue issue);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/PublisherRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface PublisherRepository extends JpaRepository<Publisher, String> {
@Query("select p from Publisher p " +
"where lower(p.name) like lower(concat('%', :searchTerm, '%')) ")
List<Publisher> search(@Param("searchTerm") String searchTerm);
Publisher findByName(String name);
List<Publisher> findByNameIgnoreCase(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/StoryArcRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface StoryArcRepository extends JpaRepository<StoryArc, String> {
@Query("select s from StoryArc s " +
"where lower(s.name) like lower(concat('%', :searchTerm, '%')) ")
List<StoryArc> search(@Param("searchTerm") String searchTerm);
StoryArc findByNameAndComic(String name, Comic comic);
List<StoryArc> findByComic(Comic comic);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/TradePaperbackRepository.java
-21
View File
@@ -1,21 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface TradePaperbackRepository extends JpaRepository<TradePaperback, String> {
@Query("select t from TradePaperback t " +
"where lower(t.name) like lower(concat('%', :searchTerm, '%')) ")
List<TradePaperback> search(@Param("searchTerm") String searchTerm);
List<TradePaperback> findByComic(Comic comic);
List<TradePaperback> findByNameAndComic(String name, Comic comic);
@Query("select t from TradePaperback t where t.name = ?1 and t.comic = ?2 and t.issueStart = ?3 and t.issueEnd = ?4")
TradePaperback findByFields(String name, Comic comic, int start, int end);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/VolumeRepository.java
-14
View File
@@ -1,14 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
public interface VolumeRepository extends JpaRepository<Volume, String> {
List<Volume> findByName(String name);
List<Volume> findByComic(Comic comic);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/comics/repository/WorktypeRepository.java
-19
View File
@@ -1,19 +0,0 @@
package de.thpeetz.kontor.comics.repository;
import java.util.List;
import de.thpeetz.kontor.comics.data.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface WorktypeRepository extends JpaRepository<Worktype, String> {
@Query("select w from Worktype w " +
"where lower(w.name) like lower(concat('%', :searchTerm, '%')) ")
List<Worktype> search(@Param("searchTerm") String searchTerm);
Worktype findByName(String name);
List<Worktype> findByNameIgnoreCase(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/common/data/AbstractEntity.java
-45
View File
@@ -1,45 +0,0 @@
package de.thpeetz.kontor.common.data;
import jakarta.persistence.*;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.util.Date;
@Slf4j
@Getter
@Setter
@EqualsAndHashCode
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class AbstractEntity {
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;
@Version
private int version;
@CreatedDate
private Date createdDate;
@LastModifiedDate
private Date lastModifiedDate;
public void updateVersion(String value) {
if (value == null) {
log.info("value not given");
return;
}
if (version != Integer.valueOf(value).intValue()) {
log.info("update version");
version = Integer.valueOf(value).intValue();
}
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/common/data/AbstractLinkEntity.java
-55
View File
@@ -1,55 +0,0 @@
package de.thpeetz.kontor.common.data;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.util.Date;
@Slf4j
@Getter
@Setter
@EqualsAndHashCode
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class AbstractLinkEntity {
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;
@Version
private int version;
@CreatedDate
private Date createdDate;
@LastModifiedDate
private Date lastModifiedDate;
@Nullable
private String url;
private boolean review;
private boolean shouldDownload;
@Nullable
private String title;
@Nullable
private String cloudLink;
@Nullable
private String fileName;
@Nullable
private String path;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/mailclient/data/Mail.java
-20
View File
@@ -1,20 +0,0 @@
package de.thpeetz.kontor.mailclient.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
@Data
@EqualsAndHashCode(callSuper=false)
@Entity
public class Mail extends AbstractEntity {
private String folder;
private String subject;
private String body;
private Date sentDate;
private Date receivedDate;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/mailclient/data/MailAccount.java
-29
View File
@@ -1,29 +0,0 @@
package de.thpeetz.kontor.mailclient.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Getter
@Setter
@Entity
public class MailAccount extends AbstractEntity {
@NotEmpty
private String host;
private Integer port;
@NotEmpty
private String protocol;
private String userName;
private String password;
private Boolean startTls;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/data/MediaActor.java
-32
View File
@@ -1,32 +0,0 @@
package de.thpeetz.kontor.media.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotEmpty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import java.util.LinkedList;
import java.util.List;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Slf4j
@Entity
public class MediaActor extends AbstractEntity {
@NotEmpty
private String name;
@Nullable
@Column(unique = true)
private String url;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "media_actor", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<MediaActorFile> mediaActorFiles = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/data/MediaActorFile.java
-34
View File
@@ -1,34 +0,0 @@
package de.thpeetz.kontor.media.data;
import de.thpeetz.kontor.comics.data.Artist;
import de.thpeetz.kontor.comics.data.Comic;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(indexes = {@Index(columnList = "media_file_id, media_actor_id") },
uniqueConstraints = @UniqueConstraint(columnNames = {"media_file_id", "media_actor_id" })
)
public class MediaActorFile extends AbstractEntity {
@ManyToOne
@JoinColumn(name = "media_file_id")
@NotNull
private MediaFile media_file;
@ManyToOne
@JoinColumn(name = "media_actor_id")
@NotNull
private MediaActor media_actor;
public String getTitle() {
return media_file.getTitle();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/data/MediaArticle.java
-29
View File
@@ -1,29 +0,0 @@
package de.thpeetz.kontor.media.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.OneToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Getter
@Setter
@Entity
@Table(indexes = @Index(columnList = "url"), uniqueConstraints = @UniqueConstraint(columnNames = {"url"}))
public class MediaArticle extends AbstractEntity {
@NotEmpty
private String url;
private boolean review;
@Nullable
private String title;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/data/MediaFile.java
-43
View File
@@ -1,43 +0,0 @@
package de.thpeetz.kontor.media.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import java.util.LinkedList;
import java.util.List;
@Slf4j
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
public class MediaFile extends AbstractEntity {
@Nullable
private String url;
private boolean review;
private boolean shouldDownload;
@Nullable
private String title;
@Nullable
private String cloudLink;
@Nullable
private String fileName;
@Nullable
private String path;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "media_file", cascade = CascadeType.REFRESH, orphanRemoval = true)
@Nullable
List<MediaActorFile> mediaActorFiles = new LinkedList<>();
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/data/MediaVideo.java
-40
View File
@@ -1,40 +0,0 @@
package de.thpeetz.kontor.media.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(uniqueConstraints = { @UniqueConstraint(columnNames = { "url" }) })
public class MediaVideo extends AbstractEntity {
@Nullable
private String url;
private boolean review;
private boolean shouldDownload;
@Nullable
private String title;
@Nullable
private String cloudLink;
@Nullable
private String fileName;
@Nullable
private String path;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/repository/MediaActorFileRepository.java
-8
View File
@@ -1,8 +0,0 @@
package de.thpeetz.kontor.media.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import de.thpeetz.kontor.media.data.MediaActorFile;
public interface MediaActorFileRepository extends JpaRepository<MediaActorFile, String> {
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/repository/MediaActorRepository.java
-19
View File
@@ -1,19 +0,0 @@
package de.thpeetz.kontor.media.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import de.thpeetz.kontor.media.data.MediaActor;
import java.util.List;
public interface MediaActorRepository extends JpaRepository<MediaActor, String> {
@Query("select m from MediaActor m " +
"where lower(m.name) like lower(concat('%', :searchTerm, '%')) ")
List<MediaActor> search(@Param("searchTerm") String searchTerm);
List<MediaActor> findByNameIgnoreCase(String name);
MediaActor findByName(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/repository/MediaArticleRepository.java
-15
View File
@@ -1,15 +0,0 @@
package de.thpeetz.kontor.media.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import de.thpeetz.kontor.media.data.MediaArticle;
import java.util.List;
public interface MediaArticleRepository extends JpaRepository<MediaArticle, String> {
@Query("select m from MediaArticle m " +
"where lower(m.url) like lower(concat('%', :searchTerm, '%')) or lower(m.title) like lower(concat('%', :searchTerm, '%'))")
List<MediaArticle> search(@Param("searchTerm") String searchTerm);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/repository/MediaFileRepository.java
-31
View File
@@ -1,31 +0,0 @@
package de.thpeetz.kontor.media.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import de.thpeetz.kontor.media.data.MediaFile;
public interface MediaFileRepository extends JpaRepository<MediaFile, String> {
@Query("select m from MediaFile m " +
"where lower(m.url) like lower(concat('%', :searchTerm, '%')) or lower(m.title) like lower(concat('%', :searchTerm, '%'))")
List<MediaFile> search(@Param("searchTerm") String searchTerm);
List<MediaFile> findByShouldDownload(Boolean shouldDownload);
List<MediaFile> findByReview(Boolean review);
List<MediaFile> findByReviewAndShouldDownload(Boolean review, Boolean shouldDownload);
MediaFile findByUrl(String url);
@Query("select m from MediaFile m " +
"where lower(m.url) like lower(concat('%', :searchTerm, '%')) or lower(m.title) like lower(concat('%', :searchTerm, '%')) " +
"AND m.review=:review AND m.shouldDownload=:download")
List<MediaFile> search(
@Param("searchTerm") String searchTerm,
@Param("review") boolean searchReview,
@Param("download") boolean searchDownload);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/media/repository/MediaVideoRepository.java
-17
View File
@@ -1,17 +0,0 @@
package de.thpeetz.kontor.media.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import de.thpeetz.kontor.media.data.MediaVideo;
import java.util.List;
public interface MediaVideoRepository extends JpaRepository<MediaVideo, String> {
@Query("select m from MediaVideo m " +
"where lower(m.url) like lower(concat('%', :searchTerm, '%')) or lower(m.title) like lower(concat('%', :searchTerm, '%'))")
List<MediaVideo> search(@Param("searchTerm") String searchTerm);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Card.java
-62
View File
@@ -1,62 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {@Index(columnList = "cardNumber, year")},
uniqueConstraints = {@UniqueConstraint(columnNames = { "cardNumber", "year", "vendor_id", "cardSet_id" })}
)
public class Card extends AbstractEntity {
private int cardNumber;
private int year;
@ManyToOne
@JoinColumn(name = "vendor_id")
@NotNull
@JsonIgnoreProperties({ "cards" })
private Vendor vendor;
@ManyToOne
@JoinColumn(name = "cardSet_id")
@NotNull
@JsonIgnoreProperties({ "cards" })
private CardSet cardSet;
@ManyToOne
@JoinColumn(name = "rooster_id")
@NotNull
@JsonIgnoreProperties({ "cards" })
private Rooster rooster;
public String getVendorName() {
return this.vendor.getName();
}
public String getCardSetName() {
return this.cardSet.getName();
}
public String getPlayerName() {
return this.rooster.getPlayer().getFullName();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/CardSet.java
-45
View File
@@ -1,45 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {@Index(columnList = "name, vendor_id")},
uniqueConstraints = {@UniqueConstraint(columnNames = { "name", "vendor_id" })}
)
public class CardSet extends AbstractEntity {
@NotEmpty
private String name;
@ManyToOne()
@JoinColumn(name = "vendor_id")
@NotNull
@JsonIgnoreProperties({ "cardSets" })
private Vendor vendor;
private boolean parallelSet = false;
private boolean insertSet = false;
public String getVendorName() {
return vendor.getName();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/FieldPosition.java
-52
View File
@@ -1,52 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {@Index(columnList = "name, sport_id")},
uniqueConstraints = {
@UniqueConstraint(columnNames = { "name", "sport_id" }),
@UniqueConstraint(columnNames = { "shortName", "sport_id" })
}
)
public class FieldPosition extends AbstractEntity {
@NotEmpty
private String name;
@NotEmpty
private String shortName;
@ManyToOne
@JoinColumn(name = "sport_id")
@NotNull
@JsonIgnoreProperties({ "positions" })
private Sport sport;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "position")
@Nullable
private List<Rooster> roosters;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Player.java
-49
View File
@@ -1,49 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {
@Index(columnList = "firstName, lastName"),
@Index(columnList = "lastName, firstName")
}, uniqueConstraints = {
@UniqueConstraint(columnNames = { "firstName", "lastName" })
})
public class Player extends AbstractEntity {
@NotNull
private String firstName;
@NotNull
private String lastName;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "player")
@Nullable
private List<Rooster> roosters;
public String getFullName() {
StringBuilder fullName = new StringBuilder();
fullName.append(this.lastName);
fullName.append(", ");
fullName.append(this.firstName);
return fullName.toString();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Rooster.java
-49
View File
@@ -1,49 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(indexes = { @Index(columnList = "team_id, player_id, position_id") }, uniqueConstraints = {
@UniqueConstraint(name = "uniqueRooster", columnNames = { "year", "team_id", "player_id", "position_id" }) })
public class Rooster extends AbstractEntity {
private int year;
@ManyToOne
@JoinColumn(name = "team_id")
@NotNull
private Team team;
@ManyToOne
@JoinColumn(name = "player_id")
@NotNull
private Player player;
@ManyToOne
@JoinColumn(name = "position_id")
@NotNull
private FieldPosition position;
@Override
public String toString() {
return "Rooster{" +
"year=" + year +
", team=" + team.getName() +
", player=" + player.getFullName() +
", position=" + position.getName() +
'}';
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Sport.java
-53
View File
@@ -1,53 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import java.util.LinkedList;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {@Index(columnList = "name")},
uniqueConstraints = {@UniqueConstraint(columnNames = { "name" })}
)
public class Sport extends AbstractEntity {
@NotEmpty
@Column(unique = true)
private String name;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "sport")
@Nullable
private List<Team> teams = new LinkedList<>();
@OneToMany(fetch = FetchType.EAGER, mappedBy = "sport")
@Nullable
private List<FieldPosition> positions = new LinkedList<>();
public String updateName(String value) {
if (!this.getName().equals(value)) {
this.setName(value);
log.info("update name");
return "updated " + this.getId() + " with " + value;
}
return "no changes for " + this.getId();
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Team.java
-49
View File
@@ -1,49 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper=false)
@Entity
@Table(indexes = {@Index(columnList = "name")},
uniqueConstraints = {@UniqueConstraint(columnNames = { "name" })}
)
public class Team extends AbstractEntity {
@NotEmpty
private String name;
@NotEmpty
private String shortName;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "team")
@Nullable
private List<Rooster> roosters;
@ManyToOne
@JoinColumn(name = "sport_id")
@NotNull
@JsonIgnoreProperties({ "teams" })
private Sport sport;
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/data/Vendor.java
-39
View File
@@ -1,39 +0,0 @@
package de.thpeetz.kontor.tysc.data;
import java.util.List;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Index;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.validation.constraints.NotEmpty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* Represents a vendor entity.
*/
@Getter
@Setter
@EqualsAndHashCode(callSuper = false)
@Entity
@Table(indexes = { @Index(columnList = "name") }, uniqueConstraints = { @UniqueConstraint(columnNames = "name") })
public class Vendor extends AbstractEntity {
@NotEmpty
private String name;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "vendor")
@Nullable
private List<CardSet> cardSets;
@Override
public String toString() {
return "Vendor{id=" + this.getId() + ", name=" + name + '}';
}
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/CardRepository.java
-21
View File
@@ -1,21 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import de.thpeetz.kontor.tysc.data.Card;
import de.thpeetz.kontor.tysc.data.CardSet;
import de.thpeetz.kontor.tysc.data.Rooster;
import de.thpeetz.kontor.tysc.data.Vendor;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface CardRepository extends JpaRepository<Card, String> {
@Query("SELECT c FROM Card c WHERE c.vendor = ?1 AND c.cardSet = ?2 and c.rooster = ?3 and c.cardNumber = ?4 and c.year = ?5")
Card search(Vendor vendor, CardSet cardset, Rooster rooster, int cardNumber, int year);
@Query("select c from Card c " +
"where str(c.cardNumber) like lower(concat('%', :searchTerm, '%')) ")
List<Card> search(@Param("searchTerm") String searchTerm);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/CardSetRepository.java
-20
View File
@@ -1,20 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.CardSet;
import de.thpeetz.kontor.tysc.data.Vendor;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface CardSetRepository extends JpaRepository<CardSet, String> {
List<CardSet> findByName(String name);
CardSet findByNameAndVendor(String name, Vendor vendor);
@Query("select c from CardSet c " +
"where lower(c.name) like lower(concat('%', :searchTerm, '%')) ")
List<CardSet> search(@Param("searchTerm") String searchTerm);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/FieldPositionRepository.java
-24
View File
@@ -1,24 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.FieldPosition;
import de.thpeetz.kontor.tysc.data.Sport;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface FieldPositionRepository extends JpaRepository<FieldPosition, String> {
@Query("select p from FieldPosition p " +
"where lower(p.name) like lower(concat('%', :searchTerm, '%')) ")
List<FieldPosition> search(@Param("searchTerm") String searchTerm);
List<FieldPosition> findBySport(Sport sport);
FieldPosition findByShortName(String searchTerm);
List<FieldPosition> findByShortNameIgnoreCase(String shortName);
FieldPosition findByShortNameAndSport(String shortName, Sport sport);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/PlayerRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.Player;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface PlayerRepository extends JpaRepository<Player, String> {
@Query("select p from Player p " +
"where lower(p.firstName) like lower(concat('%', :searchTerm, '%')) " +
"or lower(p.lastName) like lower(concat('%', :searchTerm, '%'))")
List<Player> search(@Param("searchTerm") String searchTerm);
Player findByFirstNameAndLastName(String firstName, String lastName);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/RoosterRepository.java
-15
View File
@@ -1,15 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import de.thpeetz.kontor.tysc.data.FieldPosition;
import de.thpeetz.kontor.tysc.data.Player;
import de.thpeetz.kontor.tysc.data.Rooster;
import de.thpeetz.kontor.tysc.data.Team;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
public interface RoosterRepository extends JpaRepository<Rooster, String>{
@Query("SELECT r FROM Rooster r WHERE r.player = ?1 AND r.team = ?2 AND r.position = ?3 AND r.year = ?4")
Rooster findByReferences(Player player, Team team, FieldPosition position, int year);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/SportRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.Sport;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface SportRepository extends JpaRepository<Sport, String> {
@Query("select s from Sport s " +
"where lower(s.name) like lower(concat('%', :searchTerm, '%')) ")
List<Sport> search(@Param("searchTerm") String searchTerm);
Sport findByName(String name);
List<Sport> findByNameIgnoreCase(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/TeamRepository.java
-28
View File
@@ -1,28 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.Team;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
/**
* The repository interface for managing teams.
*/
public interface TeamRepository extends JpaRepository<Team, String> {
/**
* Searches for teams based on a search term.
*
* @param searchTerm the search term to match against team names
* @return a list of teams matching the search term
*/
@Query("select t from Team t " +
"where lower(t.name) like lower(concat('%', :searchTerm, '%')) ")
List<Team> search(@Param("searchTerm") String searchTerm);
Team findByName(String name);
List<Team> findByNameIgnoreCase(String name);
}
kontor-data/src/main/java/de/thpeetz/kontor/data/tysc/repository/VendorRepository.java
-18
View File
@@ -1,18 +0,0 @@
package de.thpeetz.kontor.tysc.repository;
import java.util.List;
import de.thpeetz.kontor.tysc.data.Vendor;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface VendorRepository extends JpaRepository<Vendor, String> {
@Query("select v from Vendor v where lower(v.name) like lower(concat('%', :searchTerm, '%')) ")
List<Vendor> search(@Param("searchTerm") String searchTerm);
Vendor findByName(String name);
List<Vendor> findByNameIgnoreCase(String name);
}