F2 8 separate content and formatting in article

build.gradle

@@ -0,0 +1,51 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.1.3.RELEASE")
+    }
+}
+
+apply plugin: 'java'
+apply plugin: 'idea'
+apply plugin: 'org.springframework.boot'
+apply plugin: 'io.spring.dependency-management'
+
+bootJar {
+    baseName = 'writer-fic'
+    version = '0.1.0'
+}
+
+repositories {
+    mavenCentral()
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+compileJava.options.encoding = 'UTF-8'
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}
+dependencies {
+    compile("org.springframework.boot:spring-boot-starter-data-jpa")
+    compile("org.springframework.boot:spring-boot-starter-web")
+    compile("org.springframework.boot:spring-boot-starter-test")
+    compile("org.springframework.boot:spring-boot-starter-hateoas")
+    compile("org.springframework.boot:spring-boot-starter-security")
+    compile("org.springframework.security:spring-security-test")
+    compile("org.springframework.security:spring-security-oauth2-client")
+
+    compile("org.apache.poi:poi:4.1.0")
+    compile("io.jsonwebtoken:jjwt:0.5.1")
+    compile("fr.opensagres.xdocreport:org.apache.poi.xwpf.converter.xhtml:1.0.4")
+    compile("org.apache.poi:poi-ooxml:4.1.0")
+    compile("es.nitaur.markdown:txtmark:0.16")
+    compile("org.projectlombok:lombok")
+    compile("mysql:mysql-connector-java")
+    compile("org.postgresql:postgresql")
+    compile("com.h2database:h2")
+
+    testCompile("junit:junit")
+}

src/main/java/fic/writer/Application.java

@@ -0,0 +1,14 @@
+package fic.writer;
+
+import fic.writer.web.config.properties.AppProperties;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+
+@SpringBootApplication
+@EnableConfigurationProperties(AppProperties.class)
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}

src/main/java/fic/writer/domain/aspect/DenyAccessToNotAuthorAspect.java

@@ -0,0 +1,64 @@
+package fic.writer.domain.aspect;
+
+import fic.writer.domain.entity.Book;
+import fic.writer.domain.entity.Profile;
+import fic.writer.domain.service.BookService;
+import fic.writer.exception.DoesNotHavePermissionException;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.AuditorAware;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@Aspect
+@Component
+public class DenyAccessToNotAuthorAspect {
+    @Autowired
+    private BookService bookService;
+    @Autowired
+    private UserDetailsService userDetailsService;
+    @Autowired
+    private AuditorAware<Profile> profileAuditorAware;
+
+
+    @Pointcut("execution(*  fic.writer.domain.service.BookService.deleteById(..)) && args(bookId,..))")
+    public void deleteBook(Long bookId) {
+    }
+
+    @Pointcut("execution(*  fic.writer.domain.service.BookService.addArticle(..)) && args(bookId,..)) ")
+    public void addArticle(Long bookId) {
+    }
+
+    @Pointcut("execution(*  fic.writer.domain.service.BookService.removeArticle(..)) && args(bookId,..))")
+    public void removedArticle(Long bookId) {
+    }
+
+    @Before("deleteBook(bookId) || addArticle(bookId) || removedArticle(bookId)")
+    public void denyModifyBookForNoneAuthors(Long bookId) {
+        Optional<Profile> optionalProfile = profileAuditorAware.getCurrentAuditor();
+        Book book = bookService.findById(bookId).get();
+
+        optionalProfile.ifPresent(p -> {
+            if (checkForPermissions(book, p)) {
+                throw new DoesNotHavePermissionException();
+            }
+        });
+    }
+
+    private boolean checkForPermissions(Book book, Profile profile) {
+        return !(isAuthor(book, profile) || isCoauthor(book, profile));
+    }
+
+    private boolean isAuthor(Book book, Profile profile) {
+        return book.getAuthor().getId().equals(profile.getId());
+    }
+
+    private boolean isCoauthor(Book book, Profile profile) {
+        return book.getCoauthors().contains(profile);
+    }
+
+}

src/main/java/fic/writer/domain/audit/SpringSecurityAuditorAware.java

@@ -0,0 +1,22 @@
+package fic.writer.domain.audit;
+
+import fic.writer.domain.entity.Profile;
+import fic.writer.web.config.security.authorization.UserPrincipal;
+import org.springframework.data.domain.AuditorAware;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import java.util.Optional;
+
+public class SpringSecurityAuditorAware implements AuditorAware<Profile> {
+    @Override
+    public Optional<Profile> getCurrentAuditor() {
+        Optional<Profile> user = Optional.empty();
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication != null) {
+            UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();
+            user = Optional.ofNullable(userPrincipal.getProfileDetails().getProfile());
+        }
+        return user;
+    }
+}

src/main/java/fic/writer/domain/entity/Actor.java

@@ -0,0 +1,25 @@
+package fic.writer.domain.entity;
+
+import lombok.*;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
+import java.util.Set;
+
+@Entity
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class Actor {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(updatable = false)
+    private Long id;
+    @NotBlank
+    private String name;
+    private String description;
+    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "actors")
+    private Set<Book> books;
+}

src/main/java/fic/writer/domain/entity/Article.java

@@ -0,0 +1,44 @@
+package fic.writer.domain.entity;
+
+import lombok.*;
+import org.hibernate.annotations.Formula;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
+import java.util.Date;
+import java.util.Set;
+
+@Entity
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@EntityListeners(AuditingEntityListener.class)
+public class Article {
+    private static final int CHARS_IN_PAGE = 1800;
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    @NotBlank
+    private String title;
+    @CreatedDate
+    private Date created;
+    @LastModifiedDate
+    private Date lastModify;
+    @Column(columnDefinition = "TEXT")
+    @NotBlank
+    private String content;
+    private String annotation;
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Book book;
+    @Formula("ceil( CHAR_LENGTH(content)/" + CHARS_IN_PAGE + ")")
+    private long pageCount;
+    @Singular("formatters")
+    @OneToMany(fetch = FetchType.LAZY)
+    Set<Formatting> formattings;
+
+}

src/main/java/fic/writer/domain/entity/Book.java

@@ -0,0 +1,83 @@
+package fic.writer.domain.entity;
+
+import fic.writer.domain.entity.enums.Size;
+import fic.writer.domain.entity.enums.State;
+import lombok.*;
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import java.util.Set;
+
+@Entity
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@EntityListeners(AuditingEntityListener.class)
+public class Book {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    @NotBlank
+    private String title;
+    @ManyToOne
+    @CreatedBy
+    @NotNull
+    private Profile author;
+
+    @ManyToMany(fetch = FetchType.LAZY)
+    @JoinTable(name = "book_subauthors",
+            joinColumns = {@JoinColumn(name = "book_id")},
+            inverseJoinColumns = {@JoinColumn(name = "user_id")}
+    )
+    @Singular("coauthors")
+    private Set<Profile> coauthors;
+
+    @OneToMany(fetch = FetchType.EAGER)
+    @Singular("source")
+    private Set<Book> source;
+
+    @Column(columnDefinition = "text")
+    private String description;
+
+    @Enumerated
+    private Size size;
+
+    @Enumerated
+    private State state;
+
+    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+    @Singular("articles")
+    private Set<Article> articles;
+
+    @Transient
+    private Long pageCount;
+
+    @ManyToMany(fetch = FetchType.LAZY)
+    @JoinTable(name = "book_genres",
+            joinColumns = {@JoinColumn(name = "book_id")},
+            inverseJoinColumns = {@JoinColumn(name = "genre_id")}
+    )
+    private Set<Genre> genres;
+
+    @ManyToMany(fetch = FetchType.LAZY)
+    @JoinTable(name = "book_actors",
+            joinColumns = {@JoinColumn(name = "book_id")},
+            inverseJoinColumns = {@JoinColumn(name = "actor_id")}
+    )
+    @Singular("actors")
+    private Set<Actor> actors;
+
+    @PostLoad
+    private void calculatePageCount() {
+        this.pageCount = 0L;
+        if (articles != null) {
+            pageCount = articles.stream().mapToLong(Article::getPageCount).sum();
+        }
+    }
+
+}

src/main/java/fic/writer/domain/entity/Formatting.java

@@ -0,0 +1,27 @@
+package fic.writer.domain.entity;
+
+import fic.writer.domain.entity.enums.FormattingType;
+import lombok.*;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+
+@Entity
+@Getter
+@Setter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Formatting {
+    @Id
+    private Long id;
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Article article;
+    @NotNull
+    private Long startIndex;
+    @NotNull
+    private Long endIndex;
+    @NotNull
+    @Enumerated(value = EnumType.ORDINAL)
+    private FormattingType type;
+}

src/main/java/fic/writer/domain/entity/Genre.java

@@ -0,0 +1,23 @@
+package fic.writer.domain.entity;
+
+import lombok.*;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
+import java.util.Set;
+
+@Entity
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class Genre {
+    @Id
+    private Long id;
+    @NotBlank
+    @Column(unique = true)
+    private String name;
+    @ManyToMany(mappedBy = "genres", fetch = FetchType.LAZY)
+    private Set<Book> book;
+}