Merge branch 'home' of ElliottStansbury/JhipsterGroupProject-Client into home

.jhipster/AccountDetails.json

+{
+    "name": "AccountDetails",
+    "fields": [
+        {
+            "fieldName": "securityQuestion",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "securityAnswer",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "phoneNumber",
+            "fieldType": "String"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "one-to-one",
+            "relationshipName": "userAccount",
+            "otherEntityName": "user",
+            "otherEntityField": "email",
+            "ownerSide": true,
+            "otherEntityRelationshipName": "accountDetails"
+        }
+    ],
+    "changelogDate": "20190102220056",
+    "entityTableName": "account_details",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Album.json

+{
+    "name": "Album",
+    "fields": [
+        {
+            "fieldName": "name",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "description",
+            "fieldType": "String"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "owner",
+            "otherEntityName": "user",
+            "otherEntityField": "email"
+        }
+    ],
+    "changelogDate": "20190102220059",
+    "entityTableName": "album",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Comment.json

+{
+    "name": "Comment",
+    "fields": [
+        {
+            "fieldName": "content",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "likes",
+            "fieldType": "Long"
+        },
+        {
+            "fieldName": "dislikes",
+            "fieldType": "Long"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "commenter",
+            "otherEntityName": "user",
+            "otherEntityField": "email"
+        },
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "post",
+            "otherEntityName": "post",
+            "otherEntityField": "id"
+        }
+    ],
+    "changelogDate": "20190102220103",
+    "entityTableName": "comment",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Friend.json

+{
+    "name": "Friend",
+    "fields": [
+        {
+            "fieldName": "topFriend",
+            "fieldType": "Boolean"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "user",
+            "otherEntityName": "user",
+            "otherEntityField": "email"
+        },
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "friend",
+            "otherEntityName": "user",
+            "otherEntityField": "email"
+        }
+    ],
+    "changelogDate": "20190102220058",
+    "entityTableName": "friend",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Photo.json

+{
+    "name": "Photo",
+    "fields": [
+        {
+            "fieldName": "imageURL",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "size",
+            "fieldType": "Long"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "post",
+            "otherEntityName": "post",
+            "otherEntityField": "id"
+        },
+        {
+            "relationshipType": "many-to-many",
+            "otherEntityRelationshipName": "",
+            "relationshipName": "album",
+            "otherEntityName": "album",
+            "otherEntityField": "name",
+            "ownerSide": true
+        }
+    ],
+    "changelogDate": "20190102220100",
+    "entityTableName": "photo",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Post.json

+{
+    "name": "Post",
+    "fields": [
+        {
+            "fieldName": "numberOfComments",
+            "fieldType": "Long"
+        },
+        {
+            "fieldName": "content",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "likes",
+            "fieldType": "Long"
+        },
+        {
+            "fieldName": "dislikes",
+            "fieldType": "Long"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "owner",
+            "otherEntityName": "user",
+            "otherEntityField": "email"
+        }
+    ],
+    "changelogDate": "20190102220102",
+    "entityTableName": "post",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Profile.json

+{
+    "name": "Profile",
+    "fields": [
+        {
+            "fieldName": "bio",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "accessible",
+            "fieldType": "Boolean"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "one-to-one",
+            "relationshipName": "userProfile",
+            "otherEntityName": "user",
+            "otherEntityField": "email",
+            "ownerSide": true,
+            "otherEntityRelationshipName": "profile"
+        }
+    ],
+    "changelogDate": "20190102220057",
+    "entityTableName": "profile",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.jhipster/Video.json

+{
+    "name": "Video",
+    "fields": [
+        {
+            "fieldName": "videoURL",
+            "fieldType": "String"
+        },
+        {
+            "fieldName": "size",
+            "fieldType": "Long"
+        }
+    ],
+    "relationships": [
+        {
+            "relationshipType": "many-to-one",
+            "relationshipName": "post",
+            "otherEntityName": "post",
+            "otherEntityField": "id"
+        }
+    ],
+    "changelogDate": "20190102220101",
+    "entityTableName": "video",
+    "dto": "no",
+    "pagination": "no",
+    "service": "no",
+    "jpaMetamodelFiltering": false,
+    "fluentMethods": true,
+    "clientRootFolder": "",
+    "applications": "*"
+}

.yo-rc.json

     "authenticationType": "jwt",
     "cacheProvider": "hazelcast",
     "enableHibernateCache": true,
-    "websocket": false,
+    "websocket": "spring-websocket",
     "databaseType": "sql",
     "devDatabaseType": "h2Memory",
     "prodDatabaseType": "postgresql",
       "en"
     ]
   }
-}
+}

jdl.jh

+entity AccountDetails{
+    securityQuestion String,
+    securityAnswer String,
+    phoneNumber String
+}
+
+entity Profile{
+    bio String,
+    accessible Boolean
+}
+
+entity Friend{
+    topFriend Boolean
+}
+
+entity Album{
+    name String,
+    description String,
+}
+
+entity Photo {
+ 	imageURL String,
+    size Long
+}
+
+entity Video {
+    videoURL String,
+    size Long,
+}
+
+entity Post {
+    numberOfComments Long,
+    content String,
+  	likes Long,
+    dislikes Long
+}
+
+entity Comment {
+    content String,
+    likes Long,
+    dislikes Long
+}
+
+relationship ManyToOne {
+	Comment{commenter(email)} to User
+}
+
+relationship ManyToOne {
+	Comment{post} to Post
+}
+
+relationship ManyToOne {
+	Post{owner(email)} to User
+}
+
+relationship ManyToOne {
+	Photo{post} to Post
+}
+
+relationship ManyToOne {
+	Video{post} to Post
+}
+
+relationship ManyToOne {
+	Album{owner(email)} to User
+}
+
+relationship ManyToMany {
+	Photo{album(name)} to Album
+}
+
+relationship OneToOne {
+	AccountDetails{userAccount(email)} to User
+}
+
+relationship OneToOne {
+	Profile{userProfile(email)} to User
+}
+
+relationship ManyToOne{
+	Friend{user(email)} to User
+}
+
+relationship ManyToOne{
+	Friend{friend(email)} to User
+}
+
+
+
+
+
+
+
+
+

src/main/java/rocks/zipcode/io/FaeBooApp.java

     }
 
     /**
-     * Initializes FaeBoo.
+     * Initializes FaeBoo.np
      * <p>
      * Spring profiles can be configured with a program argument --spring.profiles.active=your-active-profile
      * <p>

src/main/java/rocks/zipcode/io/domain/AccountDetails.java

+package rocks.zipcode.io.domain;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A AccountDetails.
+ */
+@Entity
+@Table(name = "account_details")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class AccountDetails implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "security_question")
+    private String securityQuestion;
+
+    @Column(name = "security_answer")
+    private String securityAnswer;
+
+    @Column(name = "phone_number")
+    private String phoneNumber;
+
+    @OneToOne    @JoinColumn(unique = true)
+    private User userAccount;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getSecurityQuestion() {
+        return securityQuestion;
+    }
+
+    public AccountDetails securityQuestion(String securityQuestion) {
+        this.securityQuestion = securityQuestion;
+        return this;
+    }
+
+    public void setSecurityQuestion(String securityQuestion) {
+        this.securityQuestion = securityQuestion;
+    }
+
+    public String getSecurityAnswer() {
+        return securityAnswer;
+    }
+
+    public AccountDetails securityAnswer(String securityAnswer) {
+        this.securityAnswer = securityAnswer;
+        return this;
+    }
+
+    public void setSecurityAnswer(String securityAnswer) {
+        this.securityAnswer = securityAnswer;
+    }
+
+    public String getPhoneNumber() {
+        return phoneNumber;
+    }
+
+    public AccountDetails phoneNumber(String phoneNumber) {
+        this.phoneNumber = phoneNumber;
+        return this;
+    }
+
+    public void setPhoneNumber(String phoneNumber) {
+        this.phoneNumber = phoneNumber;
+    }
+
+    public User getUserAccount() {
+        return userAccount;
+    }
+
+    public AccountDetails userAccount(User user) {
+        this.userAccount = user;
+        return this;
+    }
+
+    public void setUserAccount(User user) {
+        this.userAccount = user;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        AccountDetails accountDetails = (AccountDetails) o;
+        if (accountDetails.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), accountDetails.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "AccountDetails{" +
+            "id=" + getId() +
+            ", securityQuestion='" + getSecurityQuestion() + "'" +
+            ", securityAnswer='" + getSecurityAnswer() + "'" +
+            ", phoneNumber='" + getPhoneNumber() + "'" +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Album.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Album.
+ */
+@Entity
+@Table(name = "album")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Album implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private User owner;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Album name(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public Album description(String description) {
+        this.description = description;
+        return this;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public User getOwner() {
+        return owner;
+    }
+
+    public Album owner(User user) {
+        this.owner = user;
+        return this;
+    }
+
+    public void setOwner(User user) {
+        this.owner = user;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Album album = (Album) o;
+        if (album.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), album.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Album{" +
+            "id=" + getId() +
+            ", name='" + getName() + "'" +
+            ", description='" + getDescription() + "'" +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Comment.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Comment.
+ */
+@Entity
+@Table(name = "comment")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Comment implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "content")
+    private String content;
+
+    @Column(name = "likes")
+    private Long likes;
+
+    @Column(name = "dislikes")
+    private Long dislikes;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private User commenter;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private Post post;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public Comment content(String content) {
+        this.content = content;
+        return this;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public Long getLikes() {
+        return likes;
+    }
+
+    public Comment likes(Long likes) {
+        this.likes = likes;
+        return this;
+    }
+
+    public void setLikes(Long likes) {
+        this.likes = likes;
+    }
+
+    public Long getDislikes() {
+        return dislikes;
+    }
+
+    public Comment dislikes(Long dislikes) {
+        this.dislikes = dislikes;
+        return this;
+    }
+
+    public void setDislikes(Long dislikes) {
+        this.dislikes = dislikes;
+    }
+
+    public User getCommenter() {
+        return commenter;
+    }
+
+    public Comment commenter(User user) {
+        this.commenter = user;
+        return this;
+    }
+
+    public void setCommenter(User user) {
+        this.commenter = user;
+    }
+
+    public Post getPost() {
+        return post;
+    }
+
+    public Comment post(Post post) {
+        this.post = post;
+        return this;
+    }
+
+    public void setPost(Post post) {
+        this.post = post;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Comment comment = (Comment) o;
+        if (comment.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), comment.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Comment{" +
+            "id=" + getId() +
+            ", content='" + getContent() + "'" +
+            ", likes=" + getLikes() +
+            ", dislikes=" + getDislikes() +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Friend.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Friend.
+ */
+@Entity
+@Table(name = "friend")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Friend implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "top_friend")
+    private Boolean topFriend;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private User user;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private User friend;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Boolean isTopFriend() {
+        return topFriend;
+    }
+
+    public Friend topFriend(Boolean topFriend) {
+        this.topFriend = topFriend;
+        return this;
+    }
+
+    public void setTopFriend(Boolean topFriend) {
+        this.topFriend = topFriend;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public Friend user(User user) {
+        this.user = user;
+        return this;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
+
+    public User getFriend() {
+        return friend;
+    }
+
+    public Friend friend(User user) {
+        this.friend = user;
+        return this;
+    }
+
+    public void setFriend(User user) {
+        this.friend = user;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Friend friend = (Friend) o;
+        if (friend.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), friend.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Friend{" +
+            "id=" + getId() +
+            ", topFriend='" + isTopFriend() + "'" +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Photo.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Objects;
+
+/**
+ * A Photo.
+ */
+@Entity
+@Table(name = "photo")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Photo implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "image_url")
+    private String imageURL;
+
+    @Column(name = "jhi_size")
+    private Long size;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private Post post;
+
+    @ManyToMany
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    @JoinTable(name = "photo_album",
+               joinColumns = @JoinColumn(name = "photos_id", referencedColumnName = "id"),
+               inverseJoinColumns = @JoinColumn(name = "albums_id", referencedColumnName = "id"))
+    private Set<Album> albums = new HashSet<>();
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getImageURL() {
+        return imageURL;
+    }
+
+    public Photo imageURL(String imageURL) {
+        this.imageURL = imageURL;
+        return this;
+    }
+
+    public void setImageURL(String imageURL) {
+        this.imageURL = imageURL;
+    }
+
+    public Long getSize() {
+        return size;
+    }
+
+    public Photo size(Long size) {
+        this.size = size;
+        return this;
+    }
+
+    public void setSize(Long size) {
+        this.size = size;
+    }
+
+    public Post getPost() {
+        return post;
+    }
+
+    public Photo post(Post post) {
+        this.post = post;
+        return this;
+    }
+
+    public void setPost(Post post) {
+        this.post = post;
+    }
+
+    public Set<Album> getAlbums() {
+        return albums;
+    }
+
+    public Photo albums(Set<Album> albums) {
+        this.albums = albums;
+        return this;
+    }
+
+    public Photo addAlbum(Album album) {
+        this.albums.add(album);
+        return this;
+    }
+
+    public Photo removeAlbum(Album album) {
+        this.albums.remove(album);
+        return this;
+    }
+
+    public void setAlbums(Set<Album> albums) {
+        this.albums = albums;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Photo photo = (Photo) o;
+        if (photo.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), photo.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Photo{" +
+            "id=" + getId() +
+            ", imageURL='" + getImageURL() + "'" +
+            ", size=" + getSize() +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Post.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Post.
+ */
+@Entity
+@Table(name = "post")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Post implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "number_of_comments")
+    private Long numberOfComments;
+
+    @Column(name = "content")
+    private String content;
+
+    @Column(name = "likes")
+    private Long likes;
+
+    @Column(name = "dislikes")
+    private Long dislikes;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private User owner;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getNumberOfComments() {
+        return numberOfComments;
+    }
+
+    public Post numberOfComments(Long numberOfComments) {
+        this.numberOfComments = numberOfComments;
+        return this;
+    }
+
+    public void setNumberOfComments(Long numberOfComments) {
+        this.numberOfComments = numberOfComments;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public Post content(String content) {
+        this.content = content;
+        return this;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public Long getLikes() {
+        return likes;
+    }
+
+    public Post likes(Long likes) {
+        this.likes = likes;
+        return this;
+    }
+
+    public void setLikes(Long likes) {
+        this.likes = likes;
+    }
+
+    public Long getDislikes() {
+        return dislikes;
+    }
+
+    public Post dislikes(Long dislikes) {
+        this.dislikes = dislikes;
+        return this;
+    }
+
+    public void setDislikes(Long dislikes) {
+        this.dislikes = dislikes;
+    }
+
+    public User getOwner() {
+        return owner;
+    }
+
+    public Post owner(User user) {
+        this.owner = user;
+        return this;
+    }
+
+    public void setOwner(User user) {
+        this.owner = user;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Post post = (Post) o;
+        if (post.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), post.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Post{" +
+            "id=" + getId() +
+            ", numberOfComments=" + getNumberOfComments() +
+            ", content='" + getContent() + "'" +
+            ", likes=" + getLikes() +
+            ", dislikes=" + getDislikes() +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Profile.java

+package rocks.zipcode.io.domain;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Profile.
+ */
+@Entity
+@Table(name = "profile")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Profile implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "bio")
+    private String bio;
+
+    @Column(name = "jhi_accessible")
+    private Boolean accessible;
+
+    @OneToOne    @JoinColumn(unique = true)
+    private User userProfile;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getBio() {
+        return bio;
+    }
+
+    public Profile bio(String bio) {
+        this.bio = bio;
+        return this;
+    }
+
+    public void setBio(String bio) {
+        this.bio = bio;
+    }
+
+    public Boolean isAccessible() {
+        return accessible;
+    }
+
+    public Profile accessible(Boolean accessible) {
+        this.accessible = accessible;
+        return this;
+    }
+
+    public void setAccessible(Boolean accessible) {
+        this.accessible = accessible;
+    }
+
+    public User getUserProfile() {
+        return userProfile;
+    }
+
+    public Profile userProfile(User user) {
+        this.userProfile = user;
+        return this;
+    }
+
+    public void setUserProfile(User user) {
+        this.userProfile = user;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Profile profile = (Profile) o;
+        if (profile.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), profile.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Profile{" +
+            "id=" + getId() +
+            ", bio='" + getBio() + "'" +
+            ", accessible='" + isAccessible() + "'" +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/domain/Video.java

+package rocks.zipcode.io.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * A Video.
+ */
+@Entity
+@Table(name = "video")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Video implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    private Long id;
+
+    @Column(name = "video_url")
+    private String videoURL;
+
+    @Column(name = "jhi_size")
+    private Long size;
+
+    @ManyToOne
+    @JsonIgnoreProperties("")
+    private Post post;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getVideoURL() {
+        return videoURL;
+    }
+
+    public Video videoURL(String videoURL) {
+        this.videoURL = videoURL;
+        return this;
+    }
+
+    public void setVideoURL(String videoURL) {
+        this.videoURL = videoURL;
+    }
+
+    public Long getSize() {
+        return size;
+    }
+
+    public Video size(Long size) {
+        this.size = size;
+        return this;
+    }
+
+    public void setSize(Long size) {
+        this.size = size;
+    }
+
+    public Post getPost() {
+        return post;
+    }
+
+    public Video post(Post post) {
+        this.post = post;
+        return this;
+    }
+
+    public void setPost(Post post) {
+        this.post = post;
+    }
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Video video = (Video) o;
+        if (video.getId() == null || getId() == null) {
+            return false;
+        }
+        return Objects.equals(getId(), video.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getId());
+    }
+
+    @Override
+    public String toString() {
+        return "Video{" +
+            "id=" + getId() +
+            ", videoURL='" + getVideoURL() + "'" +
+            ", size=" + getSize() +
+            "}";
+    }
+}

src/main/java/rocks/zipcode/io/repository/AccountDetailsRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.AccountDetails;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+
+/**
+ * Spring Data  repository for the AccountDetails entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface AccountDetailsRepository extends JpaRepository<AccountDetails, Long> {
+
+}

src/main/java/rocks/zipcode/io/repository/AlbumRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Album;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Spring Data  repository for the Album entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface AlbumRepository extends JpaRepository<Album, Long> {
+
+    @Query("select album from Album album where album.owner.login = ?#{principal.username}")
+    List<Album> findByOwnerIsCurrentUser();
+
+}

src/main/java/rocks/zipcode/io/repository/CommentRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Comment;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Spring Data  repository for the Comment entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+
+    @Query("select comment from Comment comment where comment.commenter.login = ?#{principal.username}")
+    List<Comment> findByCommenterIsCurrentUser();
+
+}

src/main/java/rocks/zipcode/io/repository/FriendRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Friend;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Spring Data  repository for the Friend entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface FriendRepository extends JpaRepository<Friend, Long> {
+
+    @Query("select friend from Friend friend where friend.user.login = ?#{principal.username}")
+    List<Friend> findByUserIsCurrentUser();
+
+    @Query("select friend from Friend friend where friend.friend.login = ?#{principal.username}")
+    List<Friend> findByFriendIsCurrentUser();
+
+}

src/main/java/rocks/zipcode/io/repository/PhotoRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Photo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Spring Data  repository for the Photo entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PhotoRepository extends JpaRepository<Photo, Long> {
+
+    @Query(value = "select distinct photo from Photo photo left join fetch photo.albums",
+        countQuery = "select count(distinct photo) from Photo photo")
+    Page<Photo> findAllWithEagerRelationships(Pageable pageable);
+
+    @Query(value = "select distinct photo from Photo photo left join fetch photo.albums")
+    List<Photo> findAllWithEagerRelationships();
+
+    @Query("select photo from Photo photo left join fetch photo.albums where photo.id =:id")
+    Optional<Photo> findOneWithEagerRelationships(@Param("id") Long id);
+
+}

src/main/java/rocks/zipcode/io/repository/PostRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Post;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Spring Data  repository for the Post entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PostRepository extends JpaRepository<Post, Long> {
+
+    @Query("select post from Post post where post.owner.login = ?#{principal.username}")
+    List<Post> findByOwnerIsCurrentUser();
+
+}

src/main/java/rocks/zipcode/io/repository/ProfileRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Profile;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+
+/**
+ * Spring Data  repository for the Profile entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface ProfileRepository extends JpaRepository<Profile, Long> {
+
+}

src/main/java/rocks/zipcode/io/repository/UserRepository.java

 package rocks.zipcode.io.repository;
 
+import org.springframework.data.jpa.repository.Query;
 import rocks.zipcode.io.domain.User;
 
 import org.springframework.cache.annotation.Cacheable;
 
     Optional<User> findOneByLogin(String login);
 
+    @Query("select user from User user where user.login = ?#{principal.username}")
+    Optional<User> findOneByCurrentUser();
+
     @EntityGraph(attributePaths = "authorities")
     Optional<User> findOneWithAuthoritiesById(Long id);
 

src/main/java/rocks/zipcode/io/repository/VideoRepository.java

+package rocks.zipcode.io.repository;
+
+import rocks.zipcode.io.domain.Video;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+
+/**
+ * Spring Data  repository for the Video entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface VideoRepository extends JpaRepository<Video, Long> {
+
+}

src/main/java/rocks/zipcode/io/service/UserService.java

 package rocks.zipcode.io.service;
 
 import rocks.zipcode.io.config.Constants;
+import rocks.zipcode.io.domain.AccountDetails;
 import rocks.zipcode.io.domain.Authority;
+import rocks.zipcode.io.domain.Profile;
 import rocks.zipcode.io.domain.User;
+import rocks.zipcode.io.repository.AccountDetailsRepository;
 import rocks.zipcode.io.repository.AuthorityRepository;
+import rocks.zipcode.io.repository.ProfileRepository;
 import rocks.zipcode.io.repository.UserRepository;
 import rocks.zipcode.io.security.AuthoritiesConstants;
 import rocks.zipcode.io.security.SecurityUtils;
 
     private final UserRepository userRepository;
 
+    private final ProfileRepository profileRepository;
+
+    private final AccountDetailsRepository accountDetailsRepository;
+
     private final PasswordEncoder passwordEncoder;
 
     private final AuthorityRepository authorityRepository;
 
     private final CacheManager cacheManager;
 
-    public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder, AuthorityRepository authorityRepository, CacheManager cacheManager) {
+    public UserService(UserRepository userRepository, AccountDetailsRepository accountDetailsRepository, ProfileRepository profileRepository, PasswordEncoder passwordEncoder, AuthorityRepository authorityRepository, CacheManager cacheManager) {
         this.userRepository = userRepository;
         this.passwordEncoder = passwordEncoder;
         this.authorityRepository = authorityRepository;
         this.cacheManager = cacheManager;
+        this.profileRepository = profileRepository;
+        this.accountDetailsRepository = accountDetailsRepository;
     }
 
     public Optional<User> activateRegistration(String key) {
         user.setLastName(userDTO.getLastName());
         user.setEmail(userDTO.getEmail().toLowerCase());
         user.setImageUrl(userDTO.getImageUrl());
+
+        //create default profile
+        Profile profile = new Profile();
+        profile.setBio("");
+        profile.setUserProfile(user);
+        profile.setAccessible(true);
+
+        //create default account details
+        AccountDetails accountDetails = new AccountDetails();
+        accountDetails.setSecurityQuestion("");
+        accountDetails.setSecurityAnswer("");
+
         if (userDTO.getLangKey() == null) {
             user.setLangKey(Constants.DEFAULT_LANGUAGE); // default language
         } else {
                 .collect(Collectors.toSet());
             user.setAuthorities(authorities);
         }
+
         userRepository.save(user);
+
+        //save the default profile
+        profileRepository.save(profile);
+
+        //save the default account details
+        accountDetailsRepository.save(accountDetails);
+
         this.clearUserCaches(user);
         log.debug("Created Information for User: {}", user);
         return user;

src/main/java/rocks/zipcode/io/web/rest/AccountDetailsResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.AccountDetails;
+import rocks.zipcode.io.repository.AccountDetailsRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing AccountDetails.
+ */
+@RestController
+@RequestMapping("/api")
+public class AccountDetailsResource {
+
+    private final Logger log = LoggerFactory.getLogger(AccountDetailsResource.class);
+
+    private static final String ENTITY_NAME = "accountDetails";
+
+    private final AccountDetailsRepository accountDetailsRepository;
+
+    public AccountDetailsResource(AccountDetailsRepository accountDetailsRepository) {
+        this.accountDetailsRepository = accountDetailsRepository;
+    }
+
+    /**
+     * POST  /account-details : Create a new accountDetails.
+     *
+     * @param accountDetails the accountDetails to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new accountDetails, or with status 400 (Bad Request) if the accountDetails has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/account-details")
+    @Timed
+    public ResponseEntity<AccountDetails> createAccountDetails(@RequestBody AccountDetails accountDetails) throws URISyntaxException {
+        log.debug("REST request to save AccountDetails : {}", accountDetails);
+        if (accountDetails.getId() != null) {
+            throw new BadRequestAlertException("A new accountDetails cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        AccountDetails result = accountDetailsRepository.save(accountDetails);
+        return ResponseEntity.created(new URI("/api/account-details/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /account-details : Updates an existing accountDetails.
+     *
+     * @param accountDetails the accountDetails to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated accountDetails,
+     * or with status 400 (Bad Request) if the accountDetails is not valid,
+     * or with status 500 (Internal Server Error) if the accountDetails couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/account-details")
+    @Timed
+    public ResponseEntity<AccountDetails> updateAccountDetails(@RequestBody AccountDetails accountDetails) throws URISyntaxException {
+        log.debug("REST request to update AccountDetails : {}", accountDetails);
+        if (accountDetails.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        AccountDetails result = accountDetailsRepository.save(accountDetails);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, accountDetails.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /account-details : get all the accountDetails.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of accountDetails in body
+     */
+    @GetMapping("/account-details")
+    @Timed
+    public List<AccountDetails> getAllAccountDetails() {
+        log.debug("REST request to get all AccountDetails");
+        return accountDetailsRepository.findAll();
+    }
+
+    /**
+     * GET  /account-details/:id : get the "id" accountDetails.
+     *
+     * @param id the id of the accountDetails to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the accountDetails, or with status 404 (Not Found)
+     */
+    @GetMapping("/account-details/{id}")
+    @Timed
+    public ResponseEntity<AccountDetails> getAccountDetails(@PathVariable Long id) {
+        log.debug("REST request to get AccountDetails : {}", id);
+        Optional<AccountDetails> accountDetails = accountDetailsRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(accountDetails);
+    }
+
+    /**
+     * DELETE  /account-details/:id : delete the "id" accountDetails.
+     *
+     * @param id the id of the accountDetails to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/account-details/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteAccountDetails(@PathVariable Long id) {
+        log.debug("REST request to delete AccountDetails : {}", id);
+
+        accountDetailsRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/AccountResource.java

-package rocks.zipcode.io.web.rest;
-
-import com.codahale.metrics.annotation.Timed;
-
-import rocks.zipcode.io.domain.User;
-import rocks.zipcode.io.repository.UserRepository;
-import rocks.zipcode.io.security.SecurityUtils;
-import rocks.zipcode.io.service.MailService;
-import rocks.zipcode.io.service.UserService;
-import rocks.zipcode.io.service.dto.PasswordChangeDTO;
-import rocks.zipcode.io.service.dto.UserDTO;
-import rocks.zipcode.io.web.rest.errors.*;
-import rocks.zipcode.io.web.rest.vm.KeyAndPasswordVM;
-import rocks.zipcode.io.web.rest.vm.ManagedUserVM;
-
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.*;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.validation.Valid;
-import java.util.*;
-
-
-/**
- * REST controller for managing the current user's account.
- */
-@RestController
-@RequestMapping("/api")
-public class AccountResource {
-
-    private final Logger log = LoggerFactory.getLogger(AccountResource.class);
-
-    private final UserRepository userRepository;
-
-    private final UserService userService;
-
-    private final MailService mailService;
-
-    public AccountResource(UserRepository userRepository, UserService userService, MailService mailService) {
-
-        this.userRepository = userRepository;
-        this.userService = userService;
-        this.mailService = mailService;
-    }
-
-    /**
-     * POST  /register : register the user.
-     *
-     * @param managedUserVM the managed user View Model
-     * @throws InvalidPasswordException 400 (Bad Request) if the password is incorrect
-     * @throws EmailAlreadyUsedException 400 (Bad Request) if the email is already used
-     * @throws LoginAlreadyUsedException 400 (Bad Request) if the login is already used
-     */
-    @PostMapping("/register")
-    @Timed
-    @ResponseStatus(HttpStatus.CREATED)
-    public void registerAccount(@Valid @RequestBody ManagedUserVM managedUserVM) {
-        if (!checkPasswordLength(managedUserVM.getPassword())) {
-            throw new InvalidPasswordException();
-        }
-        User user = userService.registerUser(managedUserVM, managedUserVM.getPassword());
-        mailService.sendActivationEmail(user);
-    }
-
-    /**
-     * GET  /activate : activate the registered user.
-     *
-     * @param key the activation key
-     * @throws RuntimeException 500 (Internal Server Error) if the user couldn't be activated
-     */
-    @GetMapping("/activate")
-    @Timed
-    public void activateAccount(@RequestParam(value = "key") String key) {
-        Optional<User> user = userService.activateRegistration(key);
-        if (!user.isPresent()) {
-            throw new InternalServerErrorException("No user was found for this activation key");
-        }
-    }
-
-    /**
-     * GET  /authenticate : check if the user is authenticated, and return its login.
-     *
-     * @param request the HTTP request
-     * @return the login if the user is authenticated
-     */
-    @GetMapping("/authenticate")
-    @Timed
-    public String isAuthenticated(HttpServletRequest request) {
-        log.debug("REST request to check if the current user is authenticated");
-        return request.getRemoteUser();
-    }
-
-    /**
-     * GET  /account : get the current user.
-     *
-     * @return the current user
-     * @throws RuntimeException 500 (Internal Server Error) if the user couldn't be returned
-     */
-    @GetMapping("/account")
-    @Timed
-    public UserDTO getAccount() {
-        return userService.getUserWithAuthorities()
-            .map(UserDTO::new)
-            .orElseThrow(() -> new InternalServerErrorException("User could not be found"));
-    }
-
-    /**
-     * POST  /account : update the current user information.
-     *
-     * @param userDTO the current user information
-     * @throws EmailAlreadyUsedException 400 (Bad Request) if the email is already used
-     * @throws RuntimeException 500 (Internal Server Error) if the user login wasn't found
-     */
-    @PostMapping("/account")
-    @Timed
-    public void saveAccount(@Valid @RequestBody UserDTO userDTO) {
-        final String userLogin = SecurityUtils.getCurrentUserLogin().orElseThrow(() -> new InternalServerErrorException("Current user login not found"));
-        Optional<User> existingUser = userRepository.findOneByEmailIgnoreCase(userDTO.getEmail());
-        if (existingUser.isPresent() && (!existingUser.get().getLogin().equalsIgnoreCase(userLogin))) {
-            throw new EmailAlreadyUsedException();
-        }
-        Optional<User> user = userRepository.findOneByLogin(userLogin);
-        if (!user.isPresent()) {
-            throw new InternalServerErrorException("User could not be found");
-        }
-        userService.updateUser(userDTO.getFirstName(), userDTO.getLastName(), userDTO.getEmail(),
-            userDTO.getLangKey(), userDTO.getImageUrl());
-    }
-
-    /**
-     * POST  /account/change-password : changes the current user's password
-     *
-     * @param passwordChangeDto current and new password
-     * @throws InvalidPasswordException 400 (Bad Request) if the new password is incorrect
-     */
-    @PostMapping(path = "/account/change-password")
-    @Timed
-    public void changePassword(@RequestBody PasswordChangeDTO passwordChangeDto) {
-        if (!checkPasswordLength(passwordChangeDto.getNewPassword())) {
-            throw new InvalidPasswordException();
-        }
-        userService.changePassword(passwordChangeDto.getCurrentPassword(), passwordChangeDto.getNewPassword());
-    }
-
-    /**
-     * POST   /account/reset-password/init : Send an email to reset the password of the user
-     *
-     * @param mail the mail of the user
-     * @throws EmailNotFoundException 400 (Bad Request) if the email address is not registered
-     */
-    @PostMapping(path = "/account/reset-password/init")
-    @Timed
-    public void requestPasswordReset(@RequestBody String mail) {
-       mailService.sendPasswordResetMail(
-           userService.requestPasswordReset(mail)
-               .orElseThrow(EmailNotFoundException::new)
-       );
-    }
-
-    /**
-     * POST   /account/reset-password/finish : Finish to reset the password of the user
-     *
-     * @param keyAndPassword the generated key and the new password
-     * @throws InvalidPasswordException 400 (Bad Request) if the password is incorrect
-     * @throws RuntimeException 500 (Internal Server Error) if the password could not be reset
-     */
-    @PostMapping(path = "/account/reset-password/finish")
-    @Timed
-    public void finishPasswordReset(@RequestBody KeyAndPasswordVM keyAndPassword) {
-        if (!checkPasswordLength(keyAndPassword.getNewPassword())) {
-            throw new InvalidPasswordException();
-        }
-        Optional<User> user =
-            userService.completePasswordReset(keyAndPassword.getNewPassword(), keyAndPassword.getKey());
-
-        if (!user.isPresent()) {
-            throw new InternalServerErrorException("No user was found for this reset key");
-        }
-    }
-
-    private static boolean checkPasswordLength(String password) {
-        return !StringUtils.isEmpty(password) &&
-            password.length() >= ManagedUserVM.PASSWORD_MIN_LENGTH &&
-            password.length() <= ManagedUserVM.PASSWORD_MAX_LENGTH;
-    }
-}

src/main/java/rocks/zipcode/io/web/rest/AlbumResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Album;
+import rocks.zipcode.io.repository.AlbumRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Album.
+ */
+@RestController
+@RequestMapping("/api")
+public class AlbumResource {
+
+    private final Logger log = LoggerFactory.getLogger(AlbumResource.class);
+
+    private static final String ENTITY_NAME = "album";
+
+    private final AlbumRepository albumRepository;
+
+    public AlbumResource(AlbumRepository albumRepository) {
+        this.albumRepository = albumRepository;
+    }
+
+    /**
+     * POST  /albums : Create a new album.
+     *
+     * @param album the album to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new album, or with status 400 (Bad Request) if the album has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/albums")
+    @Timed
+    public ResponseEntity<Album> createAlbum(@RequestBody Album album) throws URISyntaxException {
+        log.debug("REST request to save Album : {}", album);
+        if (album.getId() != null) {
+            throw new BadRequestAlertException("A new album cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Album result = albumRepository.save(album);
+        return ResponseEntity.created(new URI("/api/albums/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /albums : Updates an existing album.
+     *
+     * @param album the album to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated album,
+     * or with status 400 (Bad Request) if the album is not valid,
+     * or with status 500 (Internal Server Error) if the album couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/albums")
+    @Timed
+    public ResponseEntity<Album> updateAlbum(@RequestBody Album album) throws URISyntaxException {
+        log.debug("REST request to update Album : {}", album);
+        if (album.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Album result = albumRepository.save(album);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, album.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /albums : get all the albums.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of albums in body
+     */
+    @GetMapping("/albums")
+    @Timed
+    public List<Album> getAllAlbums() {
+        log.debug("REST request to get all Albums");
+        return albumRepository.findAll();
+    }
+
+    /**
+     * GET  /albums/:id : get the "id" album.
+     *
+     * @param id the id of the album to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the album, or with status 404 (Not Found)
+     */
+    @GetMapping("/albums/{id}")
+    @Timed
+    public ResponseEntity<Album> getAlbum(@PathVariable Long id) {
+        log.debug("REST request to get Album : {}", id);
+        Optional<Album> album = albumRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(album);
+    }
+
+    /**
+     * DELETE  /albums/:id : delete the "id" album.
+     *
+     * @param id the id of the album to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/albums/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteAlbum(@PathVariable Long id) {
+        log.debug("REST request to delete Album : {}", id);
+
+        albumRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/CommentResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Comment;
+import rocks.zipcode.io.repository.CommentRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Comment.
+ */
+@RestController
+@RequestMapping("/api")
+public class CommentResource {
+
+    private final Logger log = LoggerFactory.getLogger(CommentResource.class);
+
+    private static final String ENTITY_NAME = "comment";
+
+    private final CommentRepository commentRepository;
+
+    public CommentResource(CommentRepository commentRepository) {
+        this.commentRepository = commentRepository;
+    }
+
+    /**
+     * POST  /comments : Create a new comment.
+     *
+     * @param comment the comment to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new comment, or with status 400 (Bad Request) if the comment has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/comments")
+    @Timed
+    public ResponseEntity<Comment> createComment(@RequestBody Comment comment) throws URISyntaxException {
+        log.debug("REST request to save Comment : {}", comment);
+        if (comment.getId() != null) {
+            throw new BadRequestAlertException("A new comment cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Comment result = commentRepository.save(comment);
+        return ResponseEntity.created(new URI("/api/comments/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /comments : Updates an existing comment.
+     *
+     * @param comment the comment to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated comment,
+     * or with status 400 (Bad Request) if the comment is not valid,
+     * or with status 500 (Internal Server Error) if the comment couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/comments")
+    @Timed
+    public ResponseEntity<Comment> updateComment(@RequestBody Comment comment) throws URISyntaxException {
+        log.debug("REST request to update Comment : {}", comment);
+        if (comment.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Comment result = commentRepository.save(comment);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, comment.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /comments : get all the comments.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of comments in body
+     */
+    @GetMapping("/comments")
+    @Timed
+    public List<Comment> getAllComments() {
+        log.debug("REST request to get all Comments");
+        return commentRepository.findAll();
+    }
+
+    /**
+     * GET  /comments/:id : get the "id" comment.
+     *
+     * @param id the id of the comment to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the comment, or with status 404 (Not Found)
+     */
+    @GetMapping("/comments/{id}")
+    @Timed
+    public ResponseEntity<Comment> getComment(@PathVariable Long id) {
+        log.debug("REST request to get Comment : {}", id);
+        Optional<Comment> comment = commentRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(comment);
+    }
+
+    /**
+     * DELETE  /comments/:id : delete the "id" comment.
+     *
+     * @param id the id of the comment to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/comments/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteComment(@PathVariable Long id) {
+        log.debug("REST request to delete Comment : {}", id);
+
+        commentRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/FriendResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Friend;
+import rocks.zipcode.io.repository.FriendRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Friend.
+ */
+@RestController
+@RequestMapping("/api")
+public class FriendResource {
+
+    private final Logger log = LoggerFactory.getLogger(FriendResource.class);
+
+    private static final String ENTITY_NAME = "friend";
+
+    private final FriendRepository friendRepository;
+
+    public FriendResource(FriendRepository friendRepository) {
+        this.friendRepository = friendRepository;
+    }
+
+    /**
+     * POST  /friends : Create a new friend.
+     *
+     * @param friend the friend to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new friend, or with status 400 (Bad Request) if the friend has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/friends")
+    @Timed
+    public ResponseEntity<Friend> createFriend(@RequestBody Friend friend) throws URISyntaxException {
+        log.debug("REST request to save Friend : {}", friend);
+        if (friend.getId() != null) {
+            throw new BadRequestAlertException("A new friend cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Friend result = friendRepository.save(friend);
+        return ResponseEntity.created(new URI("/api/friends/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /friends : Updates an existing friend.
+     *
+     * @param friend the friend to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated friend,
+     * or with status 400 (Bad Request) if the friend is not valid,
+     * or with status 500 (Internal Server Error) if the friend couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/friends")
+    @Timed
+    public ResponseEntity<Friend> updateFriend(@RequestBody Friend friend) throws URISyntaxException {
+        log.debug("REST request to update Friend : {}", friend);
+        if (friend.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Friend result = friendRepository.save(friend);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, friend.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /friends : get all the friends.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of friends in body
+     */
+    @GetMapping("/friends")
+    @Timed
+    public List<Friend> getAllFriends() {
+        log.debug("REST request to get all Friends");
+        return friendRepository.findAll();
+    }
+
+    /**
+     * GET  /friends/:id : get the "id" friend.
+     *
+     * @param id the id of the friend to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the friend, or with status 404 (Not Found)
+     */
+    @GetMapping("/friends/{id}")
+    @Timed
+    public ResponseEntity<Friend> getFriend(@PathVariable Long id) {
+        log.debug("REST request to get Friend : {}", id);
+        Optional<Friend> friend = friendRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(friend);
+    }
+
+    /**
+     * DELETE  /friends/:id : delete the "id" friend.
+     *
+     * @param id the id of the friend to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/friends/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteFriend(@PathVariable Long id) {
+        log.debug("REST request to delete Friend : {}", id);
+
+        friendRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/PhotoResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Photo;
+import rocks.zipcode.io.repository.PhotoRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Photo.
+ */
+@RestController
+@RequestMapping("/api")
+public class PhotoResource {
+
+    private final Logger log = LoggerFactory.getLogger(PhotoResource.class);
+
+    private static final String ENTITY_NAME = "photo";
+
+    private final PhotoRepository photoRepository;
+
+    public PhotoResource(PhotoRepository photoRepository) {
+        this.photoRepository = photoRepository;
+    }
+
+    /**
+     * POST  /photos : Create a new photo.
+     *
+     * @param photo the photo to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new photo, or with status 400 (Bad Request) if the photo has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/photos")
+    @Timed
+    public ResponseEntity<Photo> createPhoto(@RequestBody Photo photo) throws URISyntaxException {
+        log.debug("REST request to save Photo : {}", photo);
+        if (photo.getId() != null) {
+            throw new BadRequestAlertException("A new photo cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Photo result = photoRepository.save(photo);
+        return ResponseEntity.created(new URI("/api/photos/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /photos : Updates an existing photo.
+     *
+     * @param photo the photo to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated photo,
+     * or with status 400 (Bad Request) if the photo is not valid,
+     * or with status 500 (Internal Server Error) if the photo couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/photos")
+    @Timed
+    public ResponseEntity<Photo> updatePhoto(@RequestBody Photo photo) throws URISyntaxException {
+        log.debug("REST request to update Photo : {}", photo);
+        if (photo.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Photo result = photoRepository.save(photo);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, photo.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /photos : get all the photos.
+     *
+     * @param eagerload flag to eager load entities from relationships (This is applicable for many-to-many)
+     * @return the ResponseEntity with status 200 (OK) and the list of photos in body
+     */
+    @GetMapping("/photos")
+    @Timed
+    public List<Photo> getAllPhotos(@RequestParam(required = false, defaultValue = "false") boolean eagerload) {
+        log.debug("REST request to get all Photos");
+        return photoRepository.findAllWithEagerRelationships();
+    }
+
+    /**
+     * GET  /photos/:id : get the "id" photo.
+     *
+     * @param id the id of the photo to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the photo, or with status 404 (Not Found)
+     */
+    @GetMapping("/photos/{id}")
+    @Timed
+    public ResponseEntity<Photo> getPhoto(@PathVariable Long id) {
+        log.debug("REST request to get Photo : {}", id);
+        Optional<Photo> photo = photoRepository.findOneWithEagerRelationships(id);
+        return ResponseUtil.wrapOrNotFound(photo);
+    }
+
+    /**
+     * DELETE  /photos/:id : delete the "id" photo.
+     *
+     * @param id the id of the photo to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/photos/{id}")
+    @Timed
+    public ResponseEntity<Void> deletePhoto(@PathVariable Long id) {
+        log.debug("REST request to delete Photo : {}", id);
+
+        photoRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/PostResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Post;
+import rocks.zipcode.io.repository.PostRepository;
+import rocks.zipcode.io.repository.UserRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Post.
+ */
+@RestController
+@RequestMapping("/api")
+public class PostResource {
+
+    private final Logger log = LoggerFactory.getLogger(PostResource.class);
+
+    private static final String ENTITY_NAME = "post";
+
+    private final PostRepository postRepository;
+
+    private final UserRepository userRepository;
+
+    public PostResource(PostRepository postRepository, UserRepository userRepository) {
+        this.postRepository = postRepository;
+        this.userRepository = userRepository;
+    }
+
+    /**
+     * POST  /posts : Create a new post.
+     *
+     * @param post the post to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new post, or with status 400 (Bad Request) if the post has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/posts")
+    @Timed
+    public ResponseEntity<Post> createPost(@RequestBody Post post) throws URISyntaxException {
+        post.setOwner(userRepository.findOneByCurrentUser().get());
+        log.debug("REST request to save Post : {}", post);
+        if (post.getId() != null) {
+            throw new BadRequestAlertException("A new post cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Post result = postRepository.save(post);
+        return ResponseEntity.created(new URI("/api/posts/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /posts : Updates an existing post.
+     *
+     * @param post the post to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated post,
+     * or with status 400 (Bad Request) if the post is not valid,
+     * or with status 500 (Internal Server Error) if the post couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/posts")
+    @Timed
+    public ResponseEntity<Post> updatePost(@RequestBody Post post) throws URISyntaxException {
+        log.debug("REST request to update Post : {}", post);
+        if (post.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Post result = postRepository.save(post);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, post.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /posts : get all the posts.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of posts in body
+     */
+    @GetMapping("/posts")
+    @Timed
+    public List<Post> getAllPosts() {
+        log.debug("REST request to get all Posts");
+        return postRepository.findByOwnerIsCurrentUser();
+    }
+
+    /**
+     * GET  /posts/:id : get the "id" post.
+     *
+     * @param id the id of the post to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the post, or with status 404 (Not Found)
+     */
+    @GetMapping("/posts/{id}")
+    @Timed
+    public ResponseEntity<Post> getPost(@PathVariable Long id) {
+        log.debug("REST request to get Post : {}", id);
+        Optional<Post> post = postRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(post);
+    }
+
+    /**
+     * DELETE  /posts/:id : delete the "id" post.
+     *
+     * @param id the id of the post to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/posts/{id}")
+    @Timed
+    public ResponseEntity<Void> deletePost(@PathVariable Long id) {
+        log.debug("REST request to delete Post : {}", id);
+
+        postRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/ProfileResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Profile;
+import rocks.zipcode.io.repository.ProfileRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Profile.
+ */
+@RestController
+@RequestMapping("/api")
+public class ProfileResource {
+
+    private final Logger log = LoggerFactory.getLogger(ProfileResource.class);
+
+    private static final String ENTITY_NAME = "profile";
+
+    private final ProfileRepository profileRepository;
+
+    public ProfileResource(ProfileRepository profileRepository) {
+        this.profileRepository = profileRepository;
+    }
+
+    /**
+     * POST  /profiles : Create a new profile.
+     *
+     * @param profile the profile to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new profile, or with status 400 (Bad Request) if the profile has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/profiles")
+    @Timed
+    public ResponseEntity<Profile> createProfile(@RequestBody Profile profile) throws URISyntaxException {
+        log.debug("REST request to save Profile : {}", profile);
+        if (profile.getId() != null) {
+            throw new BadRequestAlertException("A new profile cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Profile result = profileRepository.save(profile);
+        return ResponseEntity.created(new URI("/api/profiles/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /profiles : Updates an existing profile.
+     *
+     * @param profile the profile to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated profile,
+     * or with status 400 (Bad Request) if the profile is not valid,
+     * or with status 500 (Internal Server Error) if the profile couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/profiles")
+    @Timed
+    public ResponseEntity<Profile> updateProfile(@RequestBody Profile profile) throws URISyntaxException {
+        log.debug("REST request to update Profile : {}", profile);
+        if (profile.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Profile result = profileRepository.save(profile);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, profile.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /profiles : get all the profiles.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of profiles in body
+     */
+    @GetMapping("/profiles")
+    @Timed
+    public List<Profile> getAllProfiles() {
+        log.debug("REST request to get all Profiles");
+        return profileRepository.findAll();
+    }
+
+    /**
+     * GET  /profiles/:id : get the "id" profile.
+     *
+     * @param id the id of the profile to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the profile, or with status 404 (Not Found)
+     */
+    @GetMapping("/profiles/{id}")
+    @Timed
+    public ResponseEntity<Profile> getProfile(@PathVariable Long id) {
+        log.debug("REST request to get Profile : {}", id);
+        Optional<Profile> profile = profileRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(profile);
+    }
+
+    /**
+     * DELETE  /profiles/:id : delete the "id" profile.
+     *
+     * @param id the id of the profile to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/profiles/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteProfile(@PathVariable Long id) {
+        log.debug("REST request to delete Profile : {}", id);
+
+        profileRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/java/rocks/zipcode/io/web/rest/UserResource.java

 package rocks.zipcode.io.web.rest;
 
 import rocks.zipcode.io.config.Constants;
+import rocks.zipcode.io.domain.Profile;
 import rocks.zipcode.io.domain.User;
+import rocks.zipcode.io.repository.ProfileRepository;
 import rocks.zipcode.io.repository.UserRepository;
 import rocks.zipcode.io.security.AuthoritiesConstants;
 import rocks.zipcode.io.service.MailService;
             throw new EmailAlreadyUsedException();
         } else {
             User newUser = userService.createUser(userDTO);
+
             mailService.sendCreationEmail(newUser);
             return ResponseEntity.created(new URI("/api/users/" + newUser.getLogin()))
                 .headers(HeaderUtil.createAlert( "userManagement.created", newUser.getLogin()))

src/main/java/rocks/zipcode/io/web/rest/VideoResource.java

+package rocks.zipcode.io.web.rest;
+
+import com.codahale.metrics.annotation.Timed;
+import rocks.zipcode.io.domain.Video;
+import rocks.zipcode.io.repository.VideoRepository;
+import rocks.zipcode.io.web.rest.errors.BadRequestAlertException;
+import rocks.zipcode.io.web.rest.util.HeaderUtil;
+import io.github.jhipster.web.util.ResponseUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * REST controller for managing Video.
+ */
+@RestController
+@RequestMapping("/api")
+public class VideoResource {
+
+    private final Logger log = LoggerFactory.getLogger(VideoResource.class);
+
+    private static final String ENTITY_NAME = "video";
+
+    private final VideoRepository videoRepository;
+
+    public VideoResource(VideoRepository videoRepository) {
+        this.videoRepository = videoRepository;
+    }
+
+    /**
+     * POST  /videos : Create a new video.
+     *
+     * @param video the video to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new video, or with status 400 (Bad Request) if the video has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("/videos")
+    @Timed
+    public ResponseEntity<Video> createVideo(@RequestBody Video video) throws URISyntaxException {
+        log.debug("REST request to save Video : {}", video);
+        if (video.getId() != null) {
+            throw new BadRequestAlertException("A new video cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        Video result = videoRepository.save(video);
+        return ResponseEntity.created(new URI("/api/videos/" + result.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * PUT  /videos : Updates an existing video.
+     *
+     * @param video the video to update
+     * @return the ResponseEntity with status 200 (OK) and with body the updated video,
+     * or with status 400 (Bad Request) if the video is not valid,
+     * or with status 500 (Internal Server Error) if the video couldn't be updated
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PutMapping("/videos")
+    @Timed
+    public ResponseEntity<Video> updateVideo(@RequestBody Video video) throws URISyntaxException {
+        log.debug("REST request to update Video : {}", video);
+        if (video.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        Video result = videoRepository.save(video);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, video.getId().toString()))
+            .body(result);
+    }
+
+    /**
+     * GET  /videos : get all the videos.
+     *
+     * @return the ResponseEntity with status 200 (OK) and the list of videos in body
+     */
+    @GetMapping("/videos")
+    @Timed
+    public List<Video> getAllVideos() {
+        log.debug("REST request to get all Videos");
+        return videoRepository.findAll();
+    }
+
+    /**
+     * GET  /videos/:id : get the "id" video.
+     *
+     * @param id the id of the video to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the video, or with status 404 (Not Found)
+     */
+    @GetMapping("/videos/{id}")
+    @Timed
+    public ResponseEntity<Video> getVideo(@PathVariable Long id) {
+        log.debug("REST request to get Video : {}", id);
+        Optional<Video> video = videoRepository.findById(id);
+        return ResponseUtil.wrapOrNotFound(video);
+    }
+
+    /**
+     * DELETE  /videos/:id : delete the "id" video.
+     *
+     * @param id the id of the video to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("/videos/{id}")
+    @Timed
+    public ResponseEntity<Void> deleteVideo(@PathVariable Long id) {
+        log.debug("REST request to delete Video : {}", id);
+
+        videoRepository.deleteById(id);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
+    }
+}

src/main/resources/.h2.server.properties

 #H2 Server Properties
+#Wed Jan 09 09:38:54 EST 2019
 0=JHipster H2 (Memory)|org.h2.Driver|jdbc\:h2\:mem\:faeboo|FaeBoo
 webAllowOthers=true
 webPort=8082

src/main/resources/config/application-dev.yml

     liquibase:
         contexts: dev
     mail:
-        host: localhost
-        port: 25
-        username:
-        password:
+        host: smtp.gmail.com
+        port: 587
+        username: faebooreg@gmail.com
+        password: FaeBooBuzzK1ll!
+        protocol: smtp
+        properties.mail.smtp:
+            auth: true
+            starttls.enable: true
+            ssl.trust: smtp.gmail.com
     messages:
         cache-duration: PT1S # 1 second, see the ISO 8601 standard
     thymeleaf:

src/main/resources/config/liquibase/changelog/20190102220056_added_entity_AccountDetails.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity AccountDetails.
+    -->
+    <changeSet id="20190102220056-1" author="jhipster">
+        <createTable tableName="account_details">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="security_question" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="security_answer" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="phone_number" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+            <column name="user_account_id" type="bigint">
+                <constraints unique="true" nullable="true" uniqueConstraintName="ux_account_details_user_account_id" />
+            </column>
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220056_added_entity_constraints_AccountDetails.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity AccountDetails.
+    -->
+    <changeSet id="20190102220056-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="user_account_id"
+                                 baseTableName="account_details"
+                                 constraintName="fk_account_details_user_account_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220057_added_entity_Profile.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Profile.
+    -->
+    <changeSet id="20190102220057-1" author="jhipster">
+        <createTable tableName="profile">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="bio" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="jhi_accessible" type="boolean">
+                <constraints nullable="true" />
+            </column>
+            <column name="user_profile_id" type="bigint">
+                <constraints unique="true" nullable="true" uniqueConstraintName="ux_profile_user_profile_id" />
+            </column>
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220057_added_entity_constraints_Profile.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Profile.
+    -->
+    <changeSet id="20190102220057-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="user_profile_id"
+                                 baseTableName="profile"
+                                 constraintName="fk_profile_user_profile_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220058_added_entity_Friend.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Friend.
+    -->
+    <changeSet id="20190102220058-1" author="jhipster">
+        <createTable tableName="friend">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="top_friend" type="boolean">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="user_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="friend_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220058_added_entity_constraints_Friend.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Friend.
+    -->
+    <changeSet id="20190102220058-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="user_id"
+                                 baseTableName="friend"
+                                 constraintName="fk_friend_user_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+        <addForeignKeyConstraint baseColumnNames="friend_id"
+                                 baseTableName="friend"
+                                 constraintName="fk_friend_friend_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220059_added_entity_Album.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Album.
+    -->
+    <changeSet id="20190102220059-1" author="jhipster">
+        <createTable tableName="album">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="name" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="description" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="owner_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220059_added_entity_constraints_Album.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Album.
+    -->
+    <changeSet id="20190102220059-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="owner_id"
+                                 baseTableName="album"
+                                 constraintName="fk_album_owner_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220100_added_entity_Photo.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Photo.
+    -->
+    <changeSet id="20190102220100-1" author="jhipster">
+        <createTable tableName="photo">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="image_url" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="jhi_size" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="post_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+        <createTable tableName="photo_album">
+            <column name="albums_id" type="bigint">
+                <constraints nullable="false"/>
+            </column>
+            <column name="photos_id" type="bigint">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+
+        <addPrimaryKey columnNames="photos_id, albums_id" tableName="photo_album"/>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220100_added_entity_constraints_Photo.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Photo.
+    -->
+    <changeSet id="20190102220100-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="post_id"
+                                 baseTableName="photo"
+                                 constraintName="fk_photo_post_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="post"/>
+
+        <addForeignKeyConstraint baseColumnNames="photos_id"
+                                 baseTableName="photo_album"
+                                 constraintName="fk_photo_album_photos_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="photo"/>
+        <addForeignKeyConstraint baseColumnNames="albums_id"
+                                 baseTableName="photo_album"
+                                 constraintName="fk_photo_album_albums_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="album"/>
+        
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220101_added_entity_Video.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Video.
+    -->
+    <changeSet id="20190102220101-1" author="jhipster">
+        <createTable tableName="video">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="video_url" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="jhi_size" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="post_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220101_added_entity_constraints_Video.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Video.
+    -->
+    <changeSet id="20190102220101-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="post_id"
+                                 baseTableName="video"
+                                 constraintName="fk_video_post_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="post"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220102_added_entity_Post.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Post.
+    -->
+    <changeSet id="20190102220102-1" author="jhipster">
+        <createTable tableName="post">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="number_of_comments" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="content" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="likes" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="dislikes" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="owner_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220102_added_entity_constraints_Post.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Post.
+    -->
+    <changeSet id="20190102220102-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="owner_id"
+                                 baseTableName="post"
+                                 constraintName="fk_post_owner_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220103_added_entity_Comment.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <property name="now" value="now()" dbms="h2"/>
+
+    <property name="now" value="current_timestamp" dbms="postgresql"/>
+
+    <property name="floatType" value="float4" dbms="postgresql, h2"/>
+    <property name="floatType" value="float" dbms="mysql, oracle, mssql"/>
+
+    <!--
+        Added the entity Comment.
+    -->
+    <changeSet id="20190102220103-1" author="jhipster">
+        <createTable tableName="comment">
+            <column name="id" type="bigint" autoIncrement="${autoIncrement}">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="content" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="likes" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="dislikes" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="commenter_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <column name="post_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here, do not remove-->
+        </createTable>
+        
+    </changeSet>
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here, do not remove-->
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20190102220103_added_entity_constraints_Comment.xml

+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <!--
+        Added the constraints for entity Comment.
+    -->
+    <changeSet id="20190102220103-2" author="jhipster">
+        
+        <addForeignKeyConstraint baseColumnNames="commenter_id"
+                                 baseTableName="comment"
+                                 constraintName="fk_comment_commenter_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"/>
+
+        <addForeignKeyConstraint baseColumnNames="post_id"
+                                 baseTableName="comment"
+                                 constraintName="fk_comment_post_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="post"/>
+
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/master.xml

     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
 
     <include file="config/liquibase/changelog/00000000000000_initial_schema.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220056_added_entity_AccountDetails.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220057_added_entity_Profile.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220058_added_entity_Friend.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220059_added_entity_Album.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220100_added_entity_Photo.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220101_added_entity_Video.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220102_added_entity_Post.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220103_added_entity_Comment.xml" relativeToChangelogFile="false"/>
     <!-- jhipster-needle-liquibase-add-changelog - JHipster will add liquibase changelogs here -->
+    <include file="config/liquibase/changelog/20190102220056_added_entity_constraints_AccountDetails.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220057_added_entity_constraints_Profile.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220058_added_entity_constraints_Friend.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220059_added_entity_constraints_Album.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220100_added_entity_constraints_Photo.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220101_added_entity_constraints_Video.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220102_added_entity_constraints_Post.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20190102220103_added_entity_constraints_Comment.xml" relativeToChangelogFile="false"/>
     <!-- jhipster-needle-liquibase-add-constraints-changelog - JHipster will add liquibase constraints changelogs here -->
 </databaseChangeLog>

src/main/webapp/app/FaeBoo/Profile-head/profile-head.component.html

+<div class="main-cont">
+
+    <div class = "friend-cont">
+
+        <div class="friend-pic friend4" id = "friend7">
+            <img class ="friend-photo friend4" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend3" id = "friend5">
+            <img class ="friend-photo friend3" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend2" id = "friend3">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend1" id = "friend1">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class = "profile-pic">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend1" id = "friend2">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend2" id = "friend4">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend3" id = "friend6">
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+        <div class="friend-pic friend4" id = friend8>
+            <img class ="friend-photo" src = "../../../content/images/defaultphoto.png">
+        </div>
+
+    </div>
+
+
+    <div class = "settings-container">
+
+        <button>Settings</button>
+        <button>Change Profile</button>
+        <button>Change Bio</button>
+        <button>Friends</button>
+
+    </div>
+
+    <hr>
+
+    <div id = "bio-cont"></div>
+
+    <hr>
+
+    <div id = "feed">
+
+        <div class = "post">
+            <div>
+                <textarea id = "post-area" [(ngModel)]="str"></textarea>
+            </div>
+
+            <div id = "postButton-container">
+                <div class = "button-holder"><button class = "postBtn">Schedule</button></div>
+                <div class = "button-holder"><button class = "postBtn">Memo</button></div>
+                <div class = "button-holder"><button class = "postBtn">Photo</button></div>
+                <div class = "button-holder"><button class = "postBtn" (click)="submitPost();">Submit</button></div>
+            </div>
+
+            <p id = "msg">Create a post...</p>
+        </div>
+
+
+    </div>
+
+</div>

src/main/webapp/app/FaeBoo/Profile-head/profile-head.component.ts

+import { Component } from '@angular/core';
+import { PostService } from 'app/entities/post';
+import { IPost } from 'app/shared/model/post.model';
+import { IUser } from 'app/core';
+import { Observable } from 'rxjs';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+
+@Component({
+    selector: 'jhi-profile-head',
+    templateUrl: './profile-head.component.html',
+    styleUrls: ['profile-head.css']
+})
+export class ProfileHeadComponent {
+    str: string;
+    post: IPost;
+    user: IUser;
+    isSaving: boolean;
+    testPost: IPost;
+
+    constructor(private postService: PostService) {}
+
+    submitPost(): void {
+        this.post = new class implements IPost {
+            content: string;
+            dislikes: number;
+            id: number;
+            likes: number;
+            numberOfComments: number;
+            owner: IUser;
+        }();
+        this.post.content = this.str;
+        this.post.dislikes = 0;
+        this.post.likes = 0;
+        this.post.numberOfComments = 0;
+        if (this.post.content.length > 1) {
+            this.save(this.post);
+        }
+    }
+
+    save(post: IPost) {
+        this.isSaving = true;
+        this.subscribeToSaveResponse(this.postService.create(post));
+        console.log('post created');
+    }
+
+    private subscribeToSaveResponse(result: Observable<HttpResponse<IPost>>) {
+        result.subscribe((res: HttpResponse<IPost>) => this.onSaveSuccess(), (res: HttpErrorResponse) => this.onSaveError());
+    }
+
+    private onSaveSuccess() {
+        this.isSaving = false;
+    }
+
+    private onSaveError() {
+        this.isSaving = false;
+    }
+}

src/main/webapp/app/FaeBoo/Profile-head/profile-head.css

+.main-cont {
+    width: 100%;
+    height: 1fr;
+    box-sizing: border-box;
+    padding: 8px;
+    position: relative;
+}
+
+.friend-cont {
+    display: grid;
+    justify-items: center;
+    grid-template-columns: calc(10%) calc(10%) calc(10%) calc(10%) calc(20%) calc(10%) calc(10%) calc(10%) calc(10%);
+    /*grid-column-gap: 5px;*/
+    grid-template-rows: auto;
+    width: 100%;
+    height: 100%;
+    box-sizing: border-box;
+    position: relative;
+    overflow-y: auto;
+    overflow-x: scroll;
+    margin: auto;
+}
+
+#bio-cont {
+    width: 100%;
+    height: 75px;
+    box-sizing: border-box;
+    padding: 8px;
+    margin-top: 8px;
+}
+
+.friend-pic {
+    width: 100px;
+    height: 100px;
+    position: relative;
+    border-radius: 50%;
+    margin: auto;
+    overflow-x: hidden;
+}
+
+.friend-photo {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.profile-pic {
+    width: 200px;
+    height: 200px;
+    position: relative;
+    overflow: hidden;
+    border-radius: 50%;
+    grid-column-start: 5;
+    grid-row-start: 1;
+    margin: auto;
+    z-index: 5;
+}
+
+.friend1 {
+    z-index: 1;
+}
+
+.friend2 {
+    z-index: 2;
+}
+
+.friend3 {
+    z-index: 3;
+}
+
+.friend4 {
+    z-index: 4;
+}
+
+.settings-container {
+    width: 100%;
+    text-align: center;
+    padding: 10px;
+}
+
+.settings-container button {
+    display: inline-block;
+    width: 20%;
+    text-align: center;
+    border: none;
+    background-color: #e2e6eb;
+    padding: 5px;
+    color: #969a9f;
+    margin-right: 10px;
+    margin-top: 10px;
+}
+
+hr {
+    border: 1px solid #d1d5da;
+}
+
+#feed {
+    width: 65%;
+    min-height: 250px;
+    margin: auto;
+    padding: 10px;
+    box-sizing: border-box;
+}
+
+.post {
+    width: 100%;
+    height: 245px;
+    padding: 15px;
+    box-sizing: border-box;
+    display: grid;
+    grid-template-columns: calc(85% - 5px) 15%;
+    grid-template-rows: 195px 20px;
+    grid-column-gap: 5px;
+    color: #969a9f;
+    border-radius: 5px;
+    background-color: #e2e6eb;
+}
+
+#post-area {
+    resize: none;
+    width: 100%;
+    height: 100%;
+    grid-row-start: 1;
+    grid-column-start: 1;
+    border: none;
+    border-radius: 5px;
+    padding: 10px;
+}
+
+#postButton-container {
+    width: 100%;
+    height: 100%;
+    display: grid;
+    grid-template-rows: 25% 25% 25% 25%;
+    grid-template-columns: 100%;
+    box-sizing: border-box;
+    grid-row-start: 1;
+    grid-column-start: 2;
+}
+
+.postBtn {
+    width: 100%;
+    height: 100%;
+    font-size: 10px;
+    border: none;
+    background-color: white;
+    color: #969a9f;
+}
+
+.button-holder {
+    width: 100%;
+    height: 100%;
+    box-sizing: border-box;
+    padding: 5px;
+}
+
+#msg {
+    grid-column-start: 1;
+    grid-row-start: 2;
+}

src/main/webapp/app/FaeBoo/Profile-temp/profile-temp.component.html

+<jhi-profile-head></jhi-profile-head>

src/main/webapp/app/FaeBoo/Profile-temp/profile-temp.component.ts

+import { Component } from '@angular/core';
+import { ProfileHeadComponent } from 'app/FaeBoo/Profile-head/profile-head.component';
+
+@Component({
+    selector: 'jhi-profile-temp',
+    templateUrl: './profile-temp.component.html',
+    styleUrls: ['profile-temp.scss']
+})
+export class ProfileTempComponent {}

src/main/webapp/app/FaeBoo/Profile-temp/profile-temp.module.ts

+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { RouterModule } from '@angular/router';
+
+import { FaeBooSharedModule } from 'app/shared';
+import { PROFILE_ROUTE } from 'app/FaeBoo/Profile-temp/profile-temp.route';
+import { ProfileTempComponent } from 'app/FaeBoo/Profile-temp/profile-temp.component';
+import { ProfileHeadComponent } from 'app/FaeBoo/Profile-head/profile-head.component';
+
+@NgModule({
+    imports: [FaeBooSharedModule, RouterModule.forChild([PROFILE_ROUTE])],
+    declarations: [ProfileTempComponent, ProfileHeadComponent],
+    schemas: [CUSTOM_ELEMENTS_SCHEMA]
+})
+export class ProfileTempModule {}

src/main/webapp/app/FaeBoo/Profile-temp/profile-temp.route.ts

+import { Route } from '@angular/router';
+
+import { ProfileTempComponent } from 'app/FaeBoo/Profile-temp/profile-temp.component';
+
+export const PROFILE_ROUTE: Route = {
+    path: 'profile-head',
+    component: ProfileTempComponent,
+    data: {
+        authorities: [],
+        pageTitle: 'profile.title'
+    }
+};

src/main/webapp/app/FaeBoo/Services/post.service.ts

+import { Injectable } from '@angular/core';
+import { HttpClient, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { SERVER_API_URL } from 'app/app.constants';
+import { createRequestOption } from 'app/shared/util/request-util';
+import { IPost } from 'app/shared/model/post.model';
+
+@Injectable({ providedIn: 'root' })
+export class PostService {
+    public resourceUrl = SERVER_API_URL + 'api/users';
+
+    constructor(private http: HttpClient) {}
+
+    create(post: IPost): Observable<HttpResponse<IPost>> {
+        return this.http.post<IPost>(this.resourceUrl, post, { observe: 'response' });
+    }
+
+    update(post: IPost): Observable<HttpResponse<IPost>> {
+        return this.http.put<IPost>(this.resourceUrl, post, { observe: 'response' });
+    }
+
+    find(login: string): Observable<HttpResponse<IPost>> {
+        return this.http.get<IPost>(`${this.resourceUrl}/${login}`, { observe: 'response' });
+    }
+
+    query(req?: any): Observable<HttpResponse<IPost[]>> {
+        const options = createRequestOption(req);
+        return this.http.get<IPost[]>(this.resourceUrl, { params: options, observe: 'response' });
+    }
+
+    delete(login: string): Observable<HttpResponse<any>> {
+        return this.http.delete(`${this.resourceUrl}/${login}`, { observe: 'response' });
+    }
+
+    authorities(): Observable<string[]> {
+        return this.http.get<string[]>(SERVER_API_URL + 'api/users/authorities');
+    }
+}

src/main/webapp/app/account/account.route.ts

 import { Routes } from '@angular/router';
 
+import { loginRoute } from 'app/shared/login/login.route';
 import { activateRoute, passwordRoute, passwordResetFinishRoute, passwordResetInitRoute, registerRoute, settingsRoute } from './';
 
-const ACCOUNT_ROUTES = [activateRoute, passwordRoute, passwordResetFinishRoute, passwordResetInitRoute, registerRoute, settingsRoute];
+const ACCOUNT_ROUTES = [
+    activateRoute,
+    passwordRoute,
+    passwordResetFinishRoute,
+    passwordResetInitRoute,
+    registerRoute,
+    settingsRoute,
+    loginRoute
+];
 
 export const accountState: Routes = [
     {

src/main/webapp/app/account/register/register.component.html

             </div>
 
             <div class="alert alert-danger" *ngIf="errorUserExists" jhiTranslate="register.messages.error.userexists">
-                <strong>Login name already registered!</strong> Please choose another one.
+                <strong>Login name already registered!</strong> Please, choose another one.
             </div>
 
             <div class="alert alert-danger" *ngIf="errorEmailExists" jhiTranslate="register.messages.error.emailexists">

src/main/webapp/app/account/register/register.component.ts

     }
 
     register() {
+        console.log('Register');
         if (this.registerAccount.password !== this.confirmPassword) {
             this.doNotMatch = 'ERROR';
         } else {

src/main/webapp/app/app.module.ts

 import { Ng2Webstorage } from 'ngx-webstorage';
 import { NgJhipsterModule } from 'ng-jhipster';
 
+// import { ProfileHeadComponent } from 'app/FaeBoo/Profile-head/profile-head.component';
+import { ProfileTempComponent } from 'app/FaeBoo/Profile-temp/profile-temp.component';
+import { ProfileTempModule } from 'app/FaeBoo/Profile-temp/profile-temp.module';
+
 import { AuthInterceptor } from './blocks/interceptor/auth.interceptor';
 import { AuthExpiredInterceptor } from './blocks/interceptor/auth-expired.interceptor';
 import { ErrorHandlerInterceptor } from './blocks/interceptor/errorhandler.interceptor';
         FaeBooSharedModule.forRoot(),
         FaeBooCoreModule,
         FaeBooHomeModule,
+        ProfileTempModule,
         FaeBooAccountModule,
         // jhipster-needle-angular-add-module JHipster will add new module here
         FaeBooEntityModule
     ],
-    declarations: [JhiMainComponent, NavbarComponent, ErrorComponent, PageRibbonComponent, ActiveMenuDirective, FooterComponent],
+    declarations: [
+        JhiMainComponent,
+        NavbarComponent,
+        ErrorComponent,
+        PageRibbonComponent,
+        ActiveMenuDirective,
+        FooterComponent
+        // ProfileHeadComponent,
+    ],
     providers: [
         {
             provide: HTTP_INTERCEPTORS,

src/main/webapp/app/entities/account-details/account-details-delete-dialog.component.html

+<form name="deleteForm" (ngSubmit)="confirmDelete(accountDetails.id)">
+    <div class="modal-header">
+        <h4 class="modal-title" jhiTranslate="entity.delete.title">Confirm delete operation</h4>
+        <button type="button" class="close" data-dismiss="modal" aria-hidden="true"
+                (click)="clear()">&times;</button>
+    </div>
+    <div class="modal-body">
+        <jhi-alert-error></jhi-alert-error>
+        <p id="jhi-delete-accountDetails-heading" jhiTranslate="faeBooApp.accountDetails.delete.question" translateValues="{id: '{{accountDetails.id}}'}">Are you sure you want to delete this Account Details?</p>
+    </div>
+    <div class="modal-footer">
+        <button type="button" class="btn btn-secondary" data-dismiss="modal" (click)="clear()">
+            <fa-icon [icon]="'ban'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.cancel">Cancel</span>
+        </button>
+        <button id="jhi-confirm-delete-accountDetails" type="submit" class="btn btn-danger">
+            <fa-icon [icon]="'times'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.delete">Delete</span>
+        </button>
+    </div>
+</form>

src/main/webapp/app/entities/account-details/account-details-delete-dialog.component.ts

+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { NgbActiveModal, NgbModal, NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
+import { JhiEventManager } from 'ng-jhipster';
+
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+import { AccountDetailsService } from './account-details.service';
+
+@Component({
+    selector: 'jhi-account-details-delete-dialog',
+    templateUrl: './account-details-delete-dialog.component.html'
+})
+export class AccountDetailsDeleteDialogComponent {
+    accountDetails: IAccountDetails;
+
+    constructor(
+        private accountDetailsService: AccountDetailsService,
+        public activeModal: NgbActiveModal,
+        private eventManager: JhiEventManager
+    ) {}
+
+    clear() {
+        this.activeModal.dismiss('cancel');
+    }
+
+    confirmDelete(id: number) {
+        this.accountDetailsService.delete(id).subscribe(response => {
+            this.eventManager.broadcast({
+                name: 'accountDetailsListModification',
+                content: 'Deleted an accountDetails'
+            });
+            this.activeModal.dismiss(true);
+        });
+    }
+}
+
+@Component({
+    selector: 'jhi-account-details-delete-popup',
+    template: ''
+})
+export class AccountDetailsDeletePopupComponent implements OnInit, OnDestroy {
+    private ngbModalRef: NgbModalRef;
+
+    constructor(private activatedRoute: ActivatedRoute, private router: Router, private modalService: NgbModal) {}
+
+    ngOnInit() {
+        this.activatedRoute.data.subscribe(({ accountDetails }) => {
+            setTimeout(() => {
+                this.ngbModalRef = this.modalService.open(AccountDetailsDeleteDialogComponent as Component, {
+                    size: 'lg',
+                    backdrop: 'static'
+                });
+                this.ngbModalRef.componentInstance.accountDetails = accountDetails;
+                this.ngbModalRef.result.then(
+                    result => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    },
+                    reason => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    }
+                );
+            }, 0);
+        });
+    }
+
+    ngOnDestroy() {
+        this.ngbModalRef = null;
+    }
+}

src/main/webapp/app/entities/account-details/account-details-detail.component.html

+<div class="row justify-content-center">
+    <div class="col-8">
+        <div *ngIf="accountDetails">
+            <h2><span jhiTranslate="faeBooApp.accountDetails.detail.title">Account Details</span> {{accountDetails.id}}</h2>
+            <hr>
+            <jhi-alert-error></jhi-alert-error>
+            <dl class="row-md jh-entity-details">
+                <dt><span jhiTranslate="faeBooApp.accountDetails.securityQuestion">Security Question</span></dt>
+                <dd>
+                    <span>{{accountDetails.securityQuestion}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.accountDetails.securityAnswer">Security Answer</span></dt>
+                <dd>
+                    <span>{{accountDetails.securityAnswer}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.accountDetails.phoneNumber">Phone Number</span></dt>
+                <dd>
+                    <span>{{accountDetails.phoneNumber}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.accountDetails.userAccount">User Account</span></dt>
+                <dd>
+                    {{accountDetails.userAccount?.email}}
+                </dd>
+            </dl>
+
+            <button type="submit"
+                    (click)="previousState()"
+                    class="btn btn-info">
+                <fa-icon [icon]="'arrow-left'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.back"> Back</span>
+            </button>
+
+            <button type="button"
+                    [routerLink]="['/account-details', accountDetails.id, 'edit']"
+                    class="btn btn-primary">
+                <fa-icon [icon]="'pencil-alt'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.edit"> Edit</span>
+            </button>
+        </div>
+    </div>
+</div>

src/main/webapp/app/entities/account-details/account-details-detail.component.ts

+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+
+@Component({
+    selector: 'jhi-account-details-detail',
+    templateUrl: './account-details-detail.component.html'
+})
+export class AccountDetailsDetailComponent implements OnInit {
+    accountDetails: IAccountDetails;
+
+    constructor(private activatedRoute: ActivatedRoute) {}
+
+    ngOnInit() {
+        this.activatedRoute.data.subscribe(({ accountDetails }) => {
+            this.accountDetails = accountDetails;
+        });
+    }
+
+    previousState() {
+        window.history.back();
+    }
+}

src/main/webapp/app/entities/account-details/account-details-update.component.html

+<div class="row justify-content-center">
+    <div class="col-8">
+        <form name="editForm" role="form" novalidate (ngSubmit)="save()" #editForm="ngForm">
+            <h2 id="jhi-account-details-heading" jhiTranslate="faeBooApp.accountDetails.home.createOrEditLabel">Create or edit a Account Details</h2>
+            <div>
+                <jhi-alert-error></jhi-alert-error>
+                <div class="form-group" [hidden]="!accountDetails.id">
+                    <label for="id" jhiTranslate="global.field.id">ID</label>
+                    <input type="text" class="form-control" id="id" name="id"
+                        [(ngModel)]="accountDetails.id" readonly />
+                </div>
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.accountDetails.securityQuestion" for="field_securityQuestion">Security Question</label>
+                    <input type="text" class="form-control" name="securityQuestion" id="field_securityQuestion"
+                        [(ngModel)]="accountDetails.securityQuestion" />
+                </div>
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.accountDetails.securityAnswer" for="field_securityAnswer">Security Answer</label>
+                    <input type="text" class="form-control" name="securityAnswer" id="field_securityAnswer"
+                        [(ngModel)]="accountDetails.securityAnswer" />
+                </div>
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.accountDetails.phoneNumber" for="field_phoneNumber">Phone Number</label>
+                    <input type="text" class="form-control" name="phoneNumber" id="field_phoneNumber"
+                        [(ngModel)]="accountDetails.phoneNumber" />
+                </div>
+
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.accountDetails.userAccount" for="field_userAccount">User Account</label>
+                    <select class="form-control" id="field_userAccount" name="userAccount" [(ngModel)]="accountDetails.userAccount" >
+                        <option [ngValue]="null"></option>
+                        <option [ngValue]="userOption.id === accountDetails.userAccount?.id ? accountDetails.userAccount : userOption" *ngFor="let userOption of users; trackBy: trackUserById">{{userOption.email}}</option>
+                    </select>
+                </div>
+            </div>
+            <div>
+                <button type="button" id="cancel-save" class="btn btn-secondary"  (click)="previousState()">
+                    <fa-icon [icon]="'ban'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.cancel">Cancel</span>
+                </button>
+                <button type="submit" id="save-entity" [disabled]="editForm.form.invalid || isSaving" class="btn btn-primary">
+                    <fa-icon [icon]="'save'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.save">Save</span>
+                </button>
+            </div>
+        </form>
+    </div>
+</div>

src/main/webapp/app/entities/account-details/account-details-update.component.ts

+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { JhiAlertService } from 'ng-jhipster';
+
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+import { AccountDetailsService } from './account-details.service';
+import { IUser, UserService } from 'app/core';
+
+@Component({
+    selector: 'jhi-account-details-update',
+    templateUrl: './account-details-update.component.html'
+})
+export class AccountDetailsUpdateComponent implements OnInit {
+    accountDetails: IAccountDetails;
+    isSaving: boolean;
+
+    users: IUser[];
+
+    constructor(
+        private jhiAlertService: JhiAlertService,
+        private accountDetailsService: AccountDetailsService,
+        private userService: UserService,
+        private activatedRoute: ActivatedRoute
+    ) {}
+
+    ngOnInit() {
+        this.isSaving = false;
+        this.activatedRoute.data.subscribe(({ accountDetails }) => {
+            this.accountDetails = accountDetails;
+        });
+        this.userService.query().subscribe(
+            (res: HttpResponse<IUser[]>) => {
+                this.users = res.body;
+            },
+            (res: HttpErrorResponse) => this.onError(res.message)
+        );
+    }
+
+    previousState() {
+        window.history.back();
+    }
+
+    save() {
+        this.isSaving = true;
+        if (this.accountDetails.id !== undefined) {
+            this.subscribeToSaveResponse(this.accountDetailsService.update(this.accountDetails));
+        } else {
+            this.subscribeToSaveResponse(this.accountDetailsService.create(this.accountDetails));
+        }
+    }
+
+    private subscribeToSaveResponse(result: Observable<HttpResponse<IAccountDetails>>) {
+        result.subscribe((res: HttpResponse<IAccountDetails>) => this.onSaveSuccess(), (res: HttpErrorResponse) => this.onSaveError());
+    }
+
+    private onSaveSuccess() {
+        this.isSaving = false;
+        this.previousState();
+    }
+
+    private onSaveError() {
+        this.isSaving = false;
+    }
+
+    private onError(errorMessage: string) {
+        this.jhiAlertService.error(errorMessage, null, null);
+    }
+
+    trackUserById(index: number, item: IUser) {
+        return item.id;
+    }
+}

src/main/webapp/app/entities/account-details/account-details.component.html

+<div>
+    <h2 id="page-heading">
+        <span jhiTranslate="faeBooApp.accountDetails.home.title">Account Details</span>
+        <button id="jh-create-entity" class="btn btn-primary float-right jh-create-entity create-account-details" [routerLink]="['/account-details/new']">
+            <fa-icon [icon]="'plus'"></fa-icon>
+            <span  jhiTranslate="faeBooApp.accountDetails.home.createLabel">
+            Create new Account Details
+            </span>
+        </button>
+    </h2>
+    <jhi-alert></jhi-alert>
+    <br/>
+    <div class="table-responsive" *ngIf="accountDetails">
+        <table class="table table-striped">
+            <thead>
+            <tr>
+            <th><span jhiTranslate="global.field.id">ID</span></th>
+            <th><span jhiTranslate="faeBooApp.accountDetails.securityQuestion">Security Question</span></th>
+            <th><span jhiTranslate="faeBooApp.accountDetails.securityAnswer">Security Answer</span></th>
+            <th><span jhiTranslate="faeBooApp.accountDetails.phoneNumber">Phone Number</span></th>
+            <th><span jhiTranslate="faeBooApp.accountDetails.userAccount">User Account</span></th>
+            <th></th>
+            </tr>
+            </thead>
+            <tbody>
+            <tr *ngFor="let accountDetails of accountDetails ;trackBy: trackId">
+                <td><a [routerLink]="['/account-details', accountDetails.id, 'view' ]">{{accountDetails.id}}</a></td>
+                <td>{{accountDetails.securityQuestion}}</td>
+                <td>{{accountDetails.securityAnswer}}</td>
+                <td>{{accountDetails.phoneNumber}}</td>
+                <td>
+                    {{accountDetails.userAccount?.email}}
+                </td>
+                <td class="text-right">
+                    <div class="btn-group flex-btn-group-container">
+                        <button type="submit"
+                                [routerLink]="['/account-details', accountDetails.id, 'view' ]"
+                                class="btn btn-info btn-sm">
+                            <fa-icon [icon]="'eye'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.view">View</span>
+                        </button>
+                        <button type="submit"
+                                [routerLink]="['/account-details', accountDetails.id, 'edit']"
+                                class="btn btn-primary btn-sm">
+                            <fa-icon [icon]="'pencil-alt'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.edit">Edit</span>
+                        </button>
+                        <button type="submit"
+                                [routerLink]="['/', { outlets: { popup: 'account-details/'+ accountDetails.id + '/delete'} }]"
+                                replaceUrl="true"
+                                queryParamsHandling="merge"
+                                class="btn btn-danger btn-sm">
+                            <fa-icon [icon]="'times'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.delete">Delete</span>
+                        </button>
+                    </div>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>

src/main/webapp/app/entities/account-details/account-details.component.ts

+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { Subscription } from 'rxjs';
+import { JhiEventManager, JhiAlertService } from 'ng-jhipster';
+
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+import { Principal } from 'app/core';
+import { AccountDetailsService } from './account-details.service';
+
+@Component({
+    selector: 'jhi-account-details',
+    templateUrl: './account-details.component.html'
+})
+export class AccountDetailsComponent implements OnInit, OnDestroy {
+    accountDetails: IAccountDetails[];
+    currentAccount: any;
+    eventSubscriber: Subscription;
+
+    constructor(
+        private accountDetailsService: AccountDetailsService,
+        private jhiAlertService: JhiAlertService,
+        private eventManager: JhiEventManager,
+        private principal: Principal
+    ) {}
+
+    loadAll() {
+        this.accountDetailsService.query().subscribe(
+            (res: HttpResponse<IAccountDetails[]>) => {
+                this.accountDetails = res.body;
+            },
+            (res: HttpErrorResponse) => this.onError(res.message)
+        );
+    }
+
+    ngOnInit() {
+        this.loadAll();
+        this.principal.identity().then(account => {
+            this.currentAccount = account;
+        });
+        this.registerChangeInAccountDetails();
+    }
+
+    ngOnDestroy() {
+        this.eventManager.destroy(this.eventSubscriber);
+    }
+
+    trackId(index: number, item: IAccountDetails) {
+        return item.id;
+    }
+
+    registerChangeInAccountDetails() {
+        this.eventSubscriber = this.eventManager.subscribe('accountDetailsListModification', response => this.loadAll());
+    }
+
+    private onError(errorMessage: string) {
+        this.jhiAlertService.error(errorMessage, null, null);
+    }
+}

src/main/webapp/app/entities/account-details/account-details.module.ts

+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { RouterModule } from '@angular/router';
+
+import { FaeBooSharedModule } from 'app/shared';
+import { FaeBooAdminModule } from 'app/admin/admin.module';
+import {
+    AccountDetailsComponent,
+    AccountDetailsDetailComponent,
+    AccountDetailsUpdateComponent,
+    AccountDetailsDeletePopupComponent,
+    AccountDetailsDeleteDialogComponent,
+    accountDetailsRoute,
+    accountDetailsPopupRoute
+} from './';
+
+const ENTITY_STATES = [...accountDetailsRoute, ...accountDetailsPopupRoute];
+
+@NgModule({
+    imports: [FaeBooSharedModule, FaeBooAdminModule, RouterModule.forChild(ENTITY_STATES)],
+    declarations: [
+        AccountDetailsComponent,
+        AccountDetailsDetailComponent,
+        AccountDetailsUpdateComponent,
+        AccountDetailsDeleteDialogComponent,
+        AccountDetailsDeletePopupComponent
+    ],
+    entryComponents: [
+        AccountDetailsComponent,
+        AccountDetailsUpdateComponent,
+        AccountDetailsDeleteDialogComponent,
+        AccountDetailsDeletePopupComponent
+    ],
+    schemas: [CUSTOM_ELEMENTS_SCHEMA]
+})
+export class FaeBooAccountDetailsModule {}

src/main/webapp/app/entities/account-details/account-details.route.ts

+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot, Routes } from '@angular/router';
+import { UserRouteAccessService } from 'app/core';
+import { Observable, of } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { AccountDetails } from 'app/shared/model/account-details.model';
+import { AccountDetailsService } from './account-details.service';
+import { AccountDetailsComponent } from './account-details.component';
+import { AccountDetailsDetailComponent } from './account-details-detail.component';
+import { AccountDetailsUpdateComponent } from './account-details-update.component';
+import { AccountDetailsDeletePopupComponent } from './account-details-delete-dialog.component';
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+
+@Injectable({ providedIn: 'root' })
+export class AccountDetailsResolve implements Resolve<IAccountDetails> {
+    constructor(private service: AccountDetailsService) {}
+
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<AccountDetails> {
+        const id = route.params['id'] ? route.params['id'] : null;
+        if (id) {
+            return this.service.find(id).pipe(
+                filter((response: HttpResponse<AccountDetails>) => response.ok),
+                map((accountDetails: HttpResponse<AccountDetails>) => accountDetails.body)
+            );
+        }
+        return of(new AccountDetails());
+    }
+}
+
+export const accountDetailsRoute: Routes = [
+    {
+        path: 'account-details',
+        component: AccountDetailsComponent,
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.accountDetails.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'account-details/:id/view',
+        component: AccountDetailsDetailComponent,
+        resolve: {
+            accountDetails: AccountDetailsResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.accountDetails.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'account-details/new',
+        component: AccountDetailsUpdateComponent,
+        resolve: {
+            accountDetails: AccountDetailsResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.accountDetails.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'account-details/:id/edit',
+        component: AccountDetailsUpdateComponent,
+        resolve: {
+            accountDetails: AccountDetailsResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.accountDetails.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    }
+];
+
+export const accountDetailsPopupRoute: Routes = [
+    {
+        path: 'account-details/:id/delete',
+        component: AccountDetailsDeletePopupComponent,
+        resolve: {
+            accountDetails: AccountDetailsResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.accountDetails.home.title'
+        },
+        canActivate: [UserRouteAccessService],
+        outlet: 'popup'
+    }
+];

src/main/webapp/app/entities/account-details/account-details.service.ts

+import { Injectable } from '@angular/core';
+import { HttpClient, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { SERVER_API_URL } from 'app/app.constants';
+import { createRequestOption } from 'app/shared';
+import { IAccountDetails } from 'app/shared/model/account-details.model';
+
+type EntityResponseType = HttpResponse<IAccountDetails>;
+type EntityArrayResponseType = HttpResponse<IAccountDetails[]>;
+
+@Injectable({ providedIn: 'root' })
+export class AccountDetailsService {
+    public resourceUrl = SERVER_API_URL + 'api/account-details';
+
+    constructor(private http: HttpClient) {}
+
+    create(accountDetails: IAccountDetails): Observable<EntityResponseType> {
+        return this.http.post<IAccountDetails>(this.resourceUrl, accountDetails, { observe: 'response' });
+    }
+
+    update(accountDetails: IAccountDetails): Observable<EntityResponseType> {
+        return this.http.put<IAccountDetails>(this.resourceUrl, accountDetails, { observe: 'response' });
+    }
+
+    find(id: number): Observable<EntityResponseType> {
+        return this.http.get<IAccountDetails>(`${this.resourceUrl}/${id}`, { observe: 'response' });
+    }
+
+    query(req?: any): Observable<EntityArrayResponseType> {
+        const options = createRequestOption(req);
+        return this.http.get<IAccountDetails[]>(this.resourceUrl, { params: options, observe: 'response' });
+    }
+
+    delete(id: number): Observable<HttpResponse<any>> {
+        return this.http.delete<any>(`${this.resourceUrl}/${id}`, { observe: 'response' });
+    }
+}

src/main/webapp/app/entities/account-details/index.ts

+export * from './account-details.service';
+export * from './account-details-update.component';
+export * from './account-details-delete-dialog.component';
+export * from './account-details-detail.component';
+export * from './account-details.component';
+export * from './account-details.route';

src/main/webapp/app/entities/album/album-delete-dialog.component.html

+<form name="deleteForm" (ngSubmit)="confirmDelete(album.id)">
+    <div class="modal-header">
+        <h4 class="modal-title" jhiTranslate="entity.delete.title">Confirm delete operation</h4>
+        <button type="button" class="close" data-dismiss="modal" aria-hidden="true"
+                (click)="clear()">&times;</button>
+    </div>
+    <div class="modal-body">
+        <jhi-alert-error></jhi-alert-error>
+        <p id="jhi-delete-album-heading" jhiTranslate="faeBooApp.album.delete.question" translateValues="{id: '{{album.id}}'}">Are you sure you want to delete this Album?</p>
+    </div>
+    <div class="modal-footer">
+        <button type="button" class="btn btn-secondary" data-dismiss="modal" (click)="clear()">
+            <fa-icon [icon]="'ban'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.cancel">Cancel</span>
+        </button>
+        <button id="jhi-confirm-delete-album" type="submit" class="btn btn-danger">
+            <fa-icon [icon]="'times'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.delete">Delete</span>
+        </button>
+    </div>
+</form>

src/main/webapp/app/entities/album/album-delete-dialog.component.ts

+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { NgbActiveModal, NgbModal, NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
+import { JhiEventManager } from 'ng-jhipster';
+
+import { IAlbum } from 'app/shared/model/album.model';
+import { AlbumService } from './album.service';
+
+@Component({
+    selector: 'jhi-album-delete-dialog',
+    templateUrl: './album-delete-dialog.component.html'
+})
+export class AlbumDeleteDialogComponent {
+    album: IAlbum;
+
+    constructor(private albumService: AlbumService, public activeModal: NgbActiveModal, private eventManager: JhiEventManager) {}
+
+    clear() {
+        this.activeModal.dismiss('cancel');
+    }
+
+    confirmDelete(id: number) {
+        this.albumService.delete(id).subscribe(response => {
+            this.eventManager.broadcast({
+                name: 'albumListModification',
+                content: 'Deleted an album'
+            });
+            this.activeModal.dismiss(true);
+        });
+    }
+}
+
+@Component({
+    selector: 'jhi-album-delete-popup',
+    template: ''
+})
+export class AlbumDeletePopupComponent implements OnInit, OnDestroy {
+    private ngbModalRef: NgbModalRef;
+
+    constructor(private activatedRoute: ActivatedRoute, private router: Router, private modalService: NgbModal) {}
+
+    ngOnInit() {
+        this.activatedRoute.data.subscribe(({ album }) => {
+            setTimeout(() => {
+                this.ngbModalRef = this.modalService.open(AlbumDeleteDialogComponent as Component, { size: 'lg', backdrop: 'static' });
+                this.ngbModalRef.componentInstance.album = album;
+                this.ngbModalRef.result.then(
+                    result => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    },
+                    reason => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    }
+                );
+            }, 0);
+        });
+    }
+
+    ngOnDestroy() {
+        this.ngbModalRef = null;
+    }
+}

src/main/webapp/app/entities/album/album-detail.component.html

+<div class="row justify-content-center">
+    <div class="col-8">
+        <div *ngIf="album">
+            <h2><span jhiTranslate="faeBooApp.album.detail.title">Album</span> {{album.id}}</h2>
+            <hr>
+            <jhi-alert-error></jhi-alert-error>
+            <dl class="row-md jh-entity-details">
+                <dt><span jhiTranslate="faeBooApp.album.name">Name</span></dt>
+                <dd>
+                    <span>{{album.name}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.album.description">Description</span></dt>
+                <dd>
+                    <span>{{album.description}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.album.owner">Owner</span></dt>
+                <dd>
+                    {{album.owner?.email}}
+                </dd>
+            </dl>
+
+            <button type="submit"
+                    (click)="previousState()"
+                    class="btn btn-info">
+                <fa-icon [icon]="'arrow-left'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.back"> Back</span>
+            </button>
+
+            <button type="button"
+                    [routerLink]="['/album', album.id, 'edit']"
+                    class="btn btn-primary">
+                <fa-icon [icon]="'pencil-alt'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.edit"> Edit</span>
+            </button>
+        </div>
+    </div>
+</div>

src/main/webapp/app/entities/album/album-detail.component.ts

+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+
+import { IAlbum } from 'app/shared/model/album.model';
+
+@Component({
+    selector: 'jhi-album-detail',
+    templateUrl: './album-detail.component.html'
+})
+export class AlbumDetailComponent implements OnInit {
+    album: IAlbum;
+
+    constructor(private activatedRoute: ActivatedRoute) {}
+
+    ngOnInit() {
+        this.activatedRoute.data.subscribe(({ album }) => {
+            this.album = album;
+        });
+    }
+
+    previousState() {
+        window.history.back();
+    }
+}

src/main/webapp/app/entities/album/album-update.component.html

+<div class="row justify-content-center">
+    <div class="col-8">
+        <form name="editForm" role="form" novalidate (ngSubmit)="save()" #editForm="ngForm">
+            <h2 id="jhi-album-heading" jhiTranslate="faeBooApp.album.home.createOrEditLabel">Create or edit a Album</h2>
+            <div>
+                <jhi-alert-error></jhi-alert-error>
+                <div class="form-group" [hidden]="!album.id">
+                    <label for="id" jhiTranslate="global.field.id">ID</label>
+                    <input type="text" class="form-control" id="id" name="id"
+                        [(ngModel)]="album.id" readonly />
+                </div>
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.album.name" for="field_name">Name</label>
+                    <input type="text" class="form-control" name="name" id="field_name"
+                        [(ngModel)]="album.name" />
+                </div>
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.album.description" for="field_description">Description</label>
+                    <input type="text" class="form-control" name="description" id="field_description"
+                        [(ngModel)]="album.description" />
+                </div>
+
+                <div class="form-group">
+                    <label class="form-control-label" jhiTranslate="faeBooApp.album.owner" for="field_owner">Owner</label>
+                    <select class="form-control" id="field_owner" name="owner" [(ngModel)]="album.owner" >
+                        <option [ngValue]="null"></option>
+                        <option [ngValue]="userOption.id === album.owner?.id ? album.owner : userOption" *ngFor="let userOption of users; trackBy: trackUserById">{{userOption.email}}</option>
+                    </select>
+                </div>
+            </div>
+            <div>
+                <button type="button" id="cancel-save" class="btn btn-secondary"  (click)="previousState()">
+                    <fa-icon [icon]="'ban'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.cancel">Cancel</span>
+                </button>
+                <button type="submit" id="save-entity" [disabled]="editForm.form.invalid || isSaving" class="btn btn-primary">
+                    <fa-icon [icon]="'save'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.save">Save</span>
+                </button>
+            </div>
+        </form>
+    </div>
+</div>

src/main/webapp/app/entities/album/album-update.component.ts

+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { JhiAlertService } from 'ng-jhipster';
+
+import { IAlbum } from 'app/shared/model/album.model';
+import { AlbumService } from './album.service';
+import { IUser, UserService } from 'app/core';
+
+@Component({
+    selector: 'jhi-album-update',
+    templateUrl: './album-update.component.html'
+})
+export class AlbumUpdateComponent implements OnInit {
+    album: IAlbum;
+    isSaving: boolean;
+
+    users: IUser[];
+
+    constructor(
+        private jhiAlertService: JhiAlertService,
+        private albumService: AlbumService,
+        private userService: UserService,
+        private activatedRoute: ActivatedRoute
+    ) {}
+
+    ngOnInit() {
+        this.isSaving = false;
+        this.activatedRoute.data.subscribe(({ album }) => {
+            this.album = album;
+        });
+        this.userService.query().subscribe(
+            (res: HttpResponse<IUser[]>) => {
+                this.users = res.body;
+            },
+            (res: HttpErrorResponse) => this.onError(res.message)
+        );
+    }
+
+    previousState() {
+        window.history.back();
+    }
+
+    save() {
+        this.isSaving = true;
+        if (this.album.id !== undefined) {
+            this.subscribeToSaveResponse(this.albumService.update(this.album));
+        } else {
+            this.subscribeToSaveResponse(this.albumService.create(this.album));
+        }
+    }
+
+    private subscribeToSaveResponse(result: Observable<HttpResponse<IAlbum>>) {
+        result.subscribe((res: HttpResponse<IAlbum>) => this.onSaveSuccess(), (res: HttpErrorResponse) => this.onSaveError());
+    }
+
+    private onSaveSuccess() {
+        this.isSaving = false;
+        this.previousState();
+    }
+
+    private onSaveError() {
+        this.isSaving = false;
+    }
+
+    private onError(errorMessage: string) {
+        this.jhiAlertService.error(errorMessage, null, null);
+    }
+
+    trackUserById(index: number, item: IUser) {
+        return item.id;
+    }
+}

src/main/webapp/app/entities/album/album.component.html

+<div>
+    <h2 id="page-heading">
+        <span jhiTranslate="faeBooApp.album.home.title">Albums</span>
+        <button id="jh-create-entity" class="btn btn-primary float-right jh-create-entity create-album" [routerLink]="['/album/new']">
+            <fa-icon [icon]="'plus'"></fa-icon>
+            <span  jhiTranslate="faeBooApp.album.home.createLabel">
+            Create new Album
+            </span>
+        </button>
+    </h2>
+    <jhi-alert></jhi-alert>
+    <br/>
+    <div class="table-responsive" *ngIf="albums">
+        <table class="table table-striped">
+            <thead>
+            <tr>
+            <th><span jhiTranslate="global.field.id">ID</span></th>
+            <th><span jhiTranslate="faeBooApp.album.name">Name</span></th>
+            <th><span jhiTranslate="faeBooApp.album.description">Description</span></th>
+            <th><span jhiTranslate="faeBooApp.album.owner">Owner</span></th>
+            <th></th>
+            </tr>
+            </thead>
+            <tbody>
+            <tr *ngFor="let album of albums ;trackBy: trackId">
+                <td><a [routerLink]="['/album', album.id, 'view' ]">{{album.id}}</a></td>
+                <td>{{album.name}}</td>
+                <td>{{album.description}}</td>
+                <td>
+                    {{album.owner?.email}}
+                </td>
+                <td class="text-right">
+                    <div class="btn-group flex-btn-group-container">
+                        <button type="submit"
+                                [routerLink]="['/album', album.id, 'view' ]"
+                                class="btn btn-info btn-sm">
+                            <fa-icon [icon]="'eye'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.view">View</span>
+                        </button>
+                        <button type="submit"
+                                [routerLink]="['/album', album.id, 'edit']"
+                                class="btn btn-primary btn-sm">
+                            <fa-icon [icon]="'pencil-alt'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.edit">Edit</span>
+                        </button>
+                        <button type="submit"
+                                [routerLink]="['/', { outlets: { popup: 'album/'+ album.id + '/delete'} }]"
+                                replaceUrl="true"
+                                queryParamsHandling="merge"
+                                class="btn btn-danger btn-sm">
+                            <fa-icon [icon]="'times'"></fa-icon>
+                            <span class="d-none d-md-inline" jhiTranslate="entity.action.delete">Delete</span>
+                        </button>
+                    </div>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>

src/main/webapp/app/entities/album/album.component.ts

+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { Subscription } from 'rxjs';
+import { JhiEventManager, JhiAlertService } from 'ng-jhipster';
+
+import { IAlbum } from 'app/shared/model/album.model';
+import { Principal } from 'app/core';
+import { AlbumService } from './album.service';
+
+@Component({
+    selector: 'jhi-album',
+    templateUrl: './album.component.html'
+})
+export class AlbumComponent implements OnInit, OnDestroy {
+    albums: IAlbum[];
+    currentAccount: any;
+    eventSubscriber: Subscription;
+
+    constructor(
+        private albumService: AlbumService,
+        private jhiAlertService: JhiAlertService,
+        private eventManager: JhiEventManager,
+        private principal: Principal
+    ) {}
+
+    loadAll() {
+        this.albumService.query().subscribe(
+            (res: HttpResponse<IAlbum[]>) => {
+                this.albums = res.body;
+            },
+            (res: HttpErrorResponse) => this.onError(res.message)
+        );
+    }
+
+    ngOnInit() {
+        this.loadAll();
+        this.principal.identity().then(account => {
+            this.currentAccount = account;
+        });
+        this.registerChangeInAlbums();
+    }
+
+    ngOnDestroy() {
+        this.eventManager.destroy(this.eventSubscriber);
+    }
+
+    trackId(index: number, item: IAlbum) {
+        return item.id;
+    }
+
+    registerChangeInAlbums() {
+        this.eventSubscriber = this.eventManager.subscribe('albumListModification', response => this.loadAll());
+    }
+
+    private onError(errorMessage: string) {
+        this.jhiAlertService.error(errorMessage, null, null);
+    }
+}

src/main/webapp/app/entities/album/album.module.ts

+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { RouterModule } from '@angular/router';
+
+import { FaeBooSharedModule } from 'app/shared';
+import { FaeBooAdminModule } from 'app/admin/admin.module';
+import {
+    AlbumComponent,
+    AlbumDetailComponent,
+    AlbumUpdateComponent,
+    AlbumDeletePopupComponent,
+    AlbumDeleteDialogComponent,
+    albumRoute,
+    albumPopupRoute
+} from './';
+
+const ENTITY_STATES = [...albumRoute, ...albumPopupRoute];
+
+@NgModule({
+    imports: [FaeBooSharedModule, FaeBooAdminModule, RouterModule.forChild(ENTITY_STATES)],
+    declarations: [AlbumComponent, AlbumDetailComponent, AlbumUpdateComponent, AlbumDeleteDialogComponent, AlbumDeletePopupComponent],
+    entryComponents: [AlbumComponent, AlbumUpdateComponent, AlbumDeleteDialogComponent, AlbumDeletePopupComponent],
+    schemas: [CUSTOM_ELEMENTS_SCHEMA]
+})
+export class FaeBooAlbumModule {}

src/main/webapp/app/entities/album/album.route.ts

+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot, Routes } from '@angular/router';
+import { UserRouteAccessService } from 'app/core';
+import { Observable, of } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { Album } from 'app/shared/model/album.model';
+import { AlbumService } from './album.service';
+import { AlbumComponent } from './album.component';
+import { AlbumDetailComponent } from './album-detail.component';
+import { AlbumUpdateComponent } from './album-update.component';
+import { AlbumDeletePopupComponent } from './album-delete-dialog.component';
+import { IAlbum } from 'app/shared/model/album.model';
+
+@Injectable({ providedIn: 'root' })
+export class AlbumResolve implements Resolve<IAlbum> {
+    constructor(private service: AlbumService) {}
+
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Album> {
+        const id = route.params['id'] ? route.params['id'] : null;
+        if (id) {
+            return this.service.find(id).pipe(
+                filter((response: HttpResponse<Album>) => response.ok),
+                map((album: HttpResponse<Album>) => album.body)
+            );
+        }
+        return of(new Album());
+    }
+}
+
+export const albumRoute: Routes = [
+    {
+        path: 'album',
+        component: AlbumComponent,
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.album.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'album/:id/view',
+        component: AlbumDetailComponent,
+        resolve: {
+            album: AlbumResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.album.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'album/new',
+        component: AlbumUpdateComponent,
+        resolve: {
+            album: AlbumResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.album.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    },
+    {
+        path: 'album/:id/edit',
+        component: AlbumUpdateComponent,
+        resolve: {
+            album: AlbumResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.album.home.title'
+        },
+        canActivate: [UserRouteAccessService]
+    }
+];
+
+export const albumPopupRoute: Routes = [
+    {
+        path: 'album/:id/delete',
+        component: AlbumDeletePopupComponent,
+        resolve: {
+            album: AlbumResolve
+        },
+        data: {
+            authorities: ['ROLE_USER'],
+            pageTitle: 'faeBooApp.album.home.title'
+        },
+        canActivate: [UserRouteAccessService],
+        outlet: 'popup'
+    }
+];

src/main/webapp/app/entities/album/album.service.ts

+import { Injectable } from '@angular/core';
+import { HttpClient, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { SERVER_API_URL } from 'app/app.constants';
+import { createRequestOption } from 'app/shared';
+import { IAlbum } from 'app/shared/model/album.model';
+
+type EntityResponseType = HttpResponse<IAlbum>;
+type EntityArrayResponseType = HttpResponse<IAlbum[]>;
+
+@Injectable({ providedIn: 'root' })
+export class AlbumService {
+    public resourceUrl = SERVER_API_URL + 'api/albums';
+
+    constructor(private http: HttpClient) {}
+
+    create(album: IAlbum): Observable<EntityResponseType> {
+        return this.http.post<IAlbum>(this.resourceUrl, album, { observe: 'response' });
+    }
+
+    update(album: IAlbum): Observable<EntityResponseType> {
+        return this.http.put<IAlbum>(this.resourceUrl, album, { observe: 'response' });
+    }
+
+    find(id: number): Observable<EntityResponseType> {
+        return this.http.get<IAlbum>(`${this.resourceUrl}/${id}`, { observe: 'response' });
+    }
+
+    query(req?: any): Observable<EntityArrayResponseType> {
+        const options = createRequestOption(req);
+        return this.http.get<IAlbum[]>(this.resourceUrl, { params: options, observe: 'response' });
+    }
+
+    delete(id: number): Observable<HttpResponse<any>> {
+        return this.http.delete<any>(`${this.resourceUrl}/${id}`, { observe: 'response' });
+    }
+}

src/main/webapp/app/entities/album/index.ts

+export * from './album.service';
+export * from './album-update.component';
+export * from './album-delete-dialog.component';
+export * from './album-detail.component';
+export * from './album.component';
+export * from './album.route';

src/main/webapp/app/entities/comment/comment-delete-dialog.component.html

+<form name="deleteForm" (ngSubmit)="confirmDelete(comment.id)">
+    <div class="modal-header">
+        <h4 class="modal-title" jhiTranslate="entity.delete.title">Confirm delete operation</h4>
+        <button type="button" class="close" data-dismiss="modal" aria-hidden="true"
+                (click)="clear()">&times;</button>
+    </div>
+    <div class="modal-body">
+        <jhi-alert-error></jhi-alert-error>
+        <p id="jhi-delete-comment-heading" jhiTranslate="faeBooApp.comment.delete.question" translateValues="{id: '{{comment.id}}'}">Are you sure you want to delete this Comment?</p>
+    </div>
+    <div class="modal-footer">
+        <button type="button" class="btn btn-secondary" data-dismiss="modal" (click)="clear()">
+            <fa-icon [icon]="'ban'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.cancel">Cancel</span>
+        </button>
+        <button id="jhi-confirm-delete-comment" type="submit" class="btn btn-danger">
+            <fa-icon [icon]="'times'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.delete">Delete</span>
+        </button>
+    </div>
+</form>

src/main/webapp/app/entities/comment/comment-delete-dialog.component.ts

+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { NgbActiveModal, NgbModal, NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
+import { JhiEventManager } from 'ng-jhipster';
+
+import { IComment } from 'app/shared/model/comment.model';
+import { CommentService } from './comment.service';
+
+@Component({
+    selector: 'jhi-comment-delete-dialog',
+    templateUrl: './comment-delete-dialog.component.html'
+})
+export class CommentDeleteDialogComponent {
+    comment: IComment;
+
+    constructor(private commentService: CommentService, public activeModal: NgbActiveModal, private eventManager: JhiEventManager) {}
+
+    clear() {
+        this.activeModal.dismiss('cancel');
+    }
+
+    confirmDelete(id: number) {
+        this.commentService.delete(id).subscribe(response => {
+            this.eventManager.broadcast({
+                name: 'commentListModification',
+                content: 'Deleted an comment'
+            });
+            this.activeModal.dismiss(true);
+        });
+    }
+}
+
+@Component({
+    selector: 'jhi-comment-delete-popup',
+    template: ''
+})
+export class CommentDeletePopupComponent implements OnInit, OnDestroy {
+    private ngbModalRef: NgbModalRef;
+
+    constructor(private activatedRoute: ActivatedRoute, private router: Router, private modalService: NgbModal) {}
+
+    ngOnInit() {
+        this.activatedRoute.data.subscribe(({ comment }) => {
+            setTimeout(() => {
+                this.ngbModalRef = this.modalService.open(CommentDeleteDialogComponent as Component, { size: 'lg', backdrop: 'static' });
+                this.ngbModalRef.componentInstance.comment = comment;
+                this.ngbModalRef.result.then(
+                    result => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    },
+                    reason => {
+                        this.router.navigate([{ outlets: { popup: null } }], { replaceUrl: true, queryParamsHandling: 'merge' });
+                        this.ngbModalRef = null;
+                    }
+                );
+            }, 0);
+        });
+    }
+
+    ngOnDestroy() {
+        this.ngbModalRef = null;
+    }
+}

src/main/webapp/app/entities/comment/comment-detail.component.html

+<div class="row justify-content-center">
+    <div class="col-8">
+        <div *ngIf="comment">
+            <h2><span jhiTranslate="faeBooApp.comment.detail.title">Comment</span> {{comment.id}}</h2>
+            <hr>
+            <jhi-alert-error></jhi-alert-error>
+            <dl class="row-md jh-entity-details">
+                <dt><span jhiTranslate="faeBooApp.comment.content">Content</span></dt>
+                <dd>
+                    <span>{{comment.content}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.comment.likes">Likes</span></dt>
+                <dd>
+                    <span>{{comment.likes}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.comment.dislikes">Dislikes</span></dt>
+                <dd>
+                    <span>{{comment.dislikes}}</span>
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.comment.commenter">Commenter</span></dt>
+                <dd>
+                    {{comment.commenter?.email}}
+                </dd>
+                <dt><span jhiTranslate="faeBooApp.comment.post">Post</span></dt>
+                <dd>
+                    <div *ngIf="comment.post">
+                        <a [routerLink]="['/post', comment.post?.id, 'view']">{{comment.post?.id}}</a>
+                    </div>
+                </dd>
+            </dl>
+
+            <button type="submit"
+                    (click)="previousState()"
+                    class="btn btn-info">
+                <fa-icon [icon]="'arrow-left'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.back"> Back</span>
+            </button>
+
+            <button type="button"
+                    [routerLink]="['/comment', comment.id, 'edit']"
+                    class="btn btn-primary">
+                <fa-icon [icon]="'pencil-alt'"></fa-icon>&nbsp;<span jhiTranslate="entity.action.edit"> Edit</span>
+            </button>
+        </div>
+    </div>
+</div>