Full Stack Reddit Clone - Spring Boot, React, Electron App - Part 2
Tags: react, java, webdev, typescript
Published: 2020-07-27 14:03:23

# Full Stack Reddit Clone - Spring Boot, React, Electron App - Part 2

## Introduction

Welcome to Part 2 of creating a Reddit clone using Spring Boot, and React.

In [Part 1](https://dev.to/maxicb/full-stack-reddit-clone-spring-boot-react-electron-app-part-1-1c22) we initialized our project, and added all of the dependencies we will need. In this article we will cover creating all of the entities and repositories we will need to complete our backend!

## Important Links

- Backend Source: https://github.com/MaxiCB/vox-nobis/tree/master/backend
- Frontend Source: https://github.com/MaxiCB/vox-nobis/tree/master/client
- Live URL: In Progress

## Part 1: Creating Domain Entities 📝

Let's cover all of the different domain entities our application will have. Inside **com.your-name.backend** create a new package called **models**, and add the following classes.

_Note: We installed Lombok as a dependency in part 1. We will be using varying Lombok Annotations throughout the development process. To access these annotations you will have to enable Annotation Processing in your IDE. For further instructions on this, you can view the Setting up Lombok guide here - https://www.baeldung.com/lombok-ide_

_Note: In some cases you may need to add the following dependency to your pom.xml file for field validation_

```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>
```

- User: Have a unique userId, a username, password, emailAddress, creationDate, accountStatus

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    import javax.persistence.*;
    import javax.validation.constraints.Email;
    import javax.validation.constraints.NotBlank;
    import java.time.Instant;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Table(name = "users")
    @Entity
    public class User {
        @Id
        @SequenceGenerator(name = "USER_GEN", sequenceName = "SEQ_USER", allocationSize = 1)
        @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "USER_GEN")
        private Long userId;
        @NotBlank(message = "Username is required")
        private String username;
        @NotBlank(message = "Password is required")
        private String password;
        @Email
        @NotBlank(message = "Email is required")
        private String email;
        private Instant creationDate;
        private boolean accountStatus;
    }

  ```

- Post: Have a unique postId, postName, url, description, voteCount, user, creationDate, subreddit

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.lang.Nullable;

    import javax.persistence.*;
    import javax.validation.constraints.NotBlank;
    import java.time.Instant;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Entity
    public class Post {
        @Id
        @SequenceGenerator(name = "POST_GEN", sequenceName = "SEQ_POST", allocationSize = 1)
        @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "POST_GEN")
        private Long postId;
        @NotBlank(message = "Post Title is required")
        private String postTitle;
        @Nullable
        private String url;
        @Nullable
        @Lob
        private String description;
        private Integer voteCount;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "userId", referencedColumnName = "userId")
        private User user;
        private Instant creationDate;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "id", referencedColumnName = "id")
        private Subreddit subreddit;
    }

  ```

- Subreddit: Have a unique id, name, description, posts, creationDate, users

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    import javax.persistence.*;
    import javax.validation.constraints.NotBlank;
    import java.time.Instant;
    import java.util.List;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Entity
    public class Subreddit {
        @Id
        @SequenceGenerator(name = "SUB_GEN", sequenceName = "SEQ_SUB", allocationSize = 1)
        @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SUB_GEN")
        private Long id;
        @NotBlank(message = "Subreddit name is required")
        private String name;
        @NotBlank(message = "Subreddit description is required")
        private String description;
        @OneToMany(fetch = FetchType.LAZY)
        private List<Post> posts;
        private Instant creationDate;
        @ManyToOne(fetch = FetchType.LAZY)
        private User user;
    }

  ```

- Vote: Have a unique id, post, user

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    import javax.persistence.*;
    import javax.validation.constraints.NotNull;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Entity
    public class Vote {
        @Id
        @GeneratedValue(strategy = GenerationType.SEQUENCE)
        private Long voteId;
        private VoteType voteType;
        @NotNull
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "postId", referencedColumnName = "postId")
        private Post post;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "userId", referencedColumnName = "userId")
        private User user;
    }

  ```

- Comment: Have a unique id, text, post, creationDate, user

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    import javax.persistence.*;
    import javax.validation.constraints.NotEmpty;
    import java.time.Instant;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Entity
    public class Comment {
        @Id
        @GeneratedValue(strategy = GenerationType.SEQUENCE)
        private Long id;
        @NotEmpty
        private String text;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "postId", referencedColumnName = "postId")
        private Post post;
        private Instant creationDate;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "userId", referencedColumnName = "userId")
        private User user;
    }

  ```

- VoteType ENUM: Upvote, Downvote

  ```
    public enum VoteType {
        UPVOTE(1), DOWNVOTE(-1);

        VoteType(int direction) {}
    }

  ```

- AccountVerificationToken: Have a unique id, token, user, expirationDate

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    import javax.persistence.*;
    import java.time.Instant;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Table(name = "token")
    @Entity
    public class AccountVerificationToken {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String token;
        @OneToOne(fetch = FetchType.LAZY)
        private User user;
        private Instant expirationDate;
    }

  ```

- NotificationEmail: subject, recepient, body

  ```
  package com.maxicb.backend.model;

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class NotificationEmail {
        private String subject;
        private String recepient;
        private String body;
    }

  ```

## Part 2: Creating Repositories 👩‍

Now we need to cover the repositories which will be responsible for storing the entites in the database. Inside **com.you-name.backend** create a new package called **repository**, and add the following interfaces.

- User Repository:

  ```
    package com.maxicb.backend.repository;

    import com.maxicb.backend.model.User;
    import org.springframework.data.repository.CrudRepository;

    import java.util.Optional;

    public interface UserRepository extends CrudRepository<User, Long> {
        Optional<User> findByUsername(String username);
    }
  ```

- Post Repository:

  ```
    package com.maxicb.backend.repository;

    import com.maxicb.backend.model.Post;
    import com.maxicb.backend.model.Subreddit;
    import com.maxicb.backend.model.User;
    import org.springframework.data.repository.CrudRepository;

    import java.util.List;

    public interface PostRepository extends CrudRepository<Post, Long> {
        List<Post> findAllBySubreddit(Subreddit subreddit);

        List<Post> findByUser(User user);
    }
  ```

- Subreddit Repository:

  ```
  package com.maxicb.backend.repository;

  import com.maxicb.backend.model.Subreddit;
  import org.springframework.data.repository.CrudRepository;

  import java.util.Optional;

  public interface SubredditRepository extends CrudRepository<Subreddit, Long> {
      Optional<Subreddit> findByName(String subredditName);
  }
  ```

- Vote Repository:

  ```
    package com.maxicb.backend.repository;

    import com.maxicb.backend.model.Post;
    import com.maxicb.backend.model.User;
    import com.maxicb.backend.model.Vote;
    import org.springframework.data.repository.CrudRepository;

    import java.util.Optional;

    public interface VoteRepository extends CrudRepository<Vote, Long> {
        Optional<Vote> findTopByPostAndUserOrderByVoteIdDesc(Post post, User currentUser);
    }
  ```

- Comment Repository:

  ```
    package com.maxicb.backend.repository;

    import com.maxicb.backend.model.Comment;
    import com.maxicb.backend.model.Post;
    import com.maxicb.backend.model.User;
    import org.springframework.data.repository.CrudRepository;

    import java.util.List;

    public interface CommentRepository extends CrudRepository<Comment, Long> {
        List<Comment> findByPost(Post post);

        List<Comment> findAllByUser(User user);
    }
  ```

- Token Repository:

  ```
  package com.maxicb.backend.repository;

import com.maxicb.backend.model.AccountVerificationToken;
import org.springframework.data.repository.CrudRepository;

import java.util.Optional;

public interface TokenRepository extends CrudRepository<AccountVerificationToken, Long> {
    Optional<AccountVerificationToken> findByToken(String token);
}
  ```

## Conclusion 🔍

- To ensure everything is configured correctly you can run the application, and ensure there are no error in the console. Towards the bottom of the console you should see output similar to below

  ![alt text](https://imgur.com/ujCpRgd.png "Successful Run")

- In this article we created the entities, and repositories needed within our Spring Boot backend. Laying the foundation for all of the logic that will follow.

## Next

## [Part 3 ](https://dev.to/maxicb/full-stack-reddit-clone-spring-boot-react-electron-app-part-3-4a4n) Implementing registration, email sending, and account activation/verification.