Design A Social Media Platform - Object-Oriented Design

Requirements

User Profiles: Users can create and manage their profiles.
Follow Feature: Users can follow other users.
Posting Updates: Users can create posts that may include text, images, or videos.
Likes and Comments: Other users can like and comment on posts.
Direct Messaging: Users can send private messages to each other.

Define Core Objects

User: Represents a user in the system.
- Attributes:
  - userId (string)
  - username (string)
  - email (string)
  - password (string)
  - profilePicture (string)
Post: Represents a user's post.
- Attributes:
  - postId (string)
  - content (string)
  - mediaUrl (string)
  - createdAt (datetime)
  - userId (string, foreign key referencing User)
Comment: Represents comments made on posts.
- Attributes:
  - commentId (string)
  - content (string)
  - createdAt (datetime)
  - postId (string, foreign key referencing Post)
  - userId (string, foreign key referencing User)
Like: Represents a like on a post.
- Attributes:
  - likeId (string)
  - postId (string, foreign key referencing Post)
  - userId (string, foreign key referencing User)
Message: Represents a direct message between users.
- Attributes:
  - messageId (string)
  - senderId (string, foreign key referencing User)
  - receiverId (string, foreign key referencing User)
  - content (string)
  - createdAt (datetime)

Analyze Relationships

A User can create multiple Post objects.
Each Post can have multiple Comment objects associated with it.
A User can write comments and can like multiple posts.
Messages can be sent and received by users.

Establish Hierarchy

Design inheritance trees where applicable to promote code reuse and polymorphism. This step involves identifying common attributes and behaviors that can be abstracted into parent classes...

Design Patterns

Singleton Pattern: Implemented in DatabaseConnection to ensure a single instance for database management.
Factory Pattern: Added PostFactory to create different types of posts (TextPost, ImagePost), reducing dependency on specific classes.
Observer Pattern: User now implements the Observer interface to receive notifications, and each user subscribes to the NotificationService.
Command Pattern: Introduced LikePostCommand to encapsulate the action of liking a post, allowing for future enhancements like queuing.

Define Class Members (write code)

Attributes: For each class, define the attributes (data) it will hold...

Methods: Define the methods (functions) that operate on the attributes. Ensure they align with the object's responsibilities and adhere to the principle of encapsulation.

// Observer Pattern for notifications
interface Observer {
    void update(String message);
}
class NotificationService {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
    observers.add(observer);
}

public void notifyObservers(String message) {
    for (Observer observer : observers) {
        observer.update(message);
    }
}

}
class User implements Observer {
private String userId;
private String username;
private List<Post> posts;
private List<User> following;
private NotificationService notificationService;
public User(String userId, String username, NotificationService notificationService) {
    this.userId = userId;
    this.username = username;
    this.posts = new ArrayList&lt;&gt;();
    this.following = new ArrayList&lt;&gt;();
    this.notificationService = notificationService;
    this.notificationService.addObserver(this); // Registering for notifications
}

public void createPost(String content, String mediaUrl, String postType) {
    Post post = PostFactory.createPost(postType, content, mediaUrl, this.userId);
    posts.add(post);
    System.out.println(username + &quot; created a new post.&quot;);
}

public void followUser(User user) {
    following.add(user);
    notificationService.notifyObservers(username + &quot; followed &quot; + user.username);
}

public void update(String message) {
    System.out.println(&quot;Notification to &quot; + username + &quot;: &quot; + message);
}

public void sendMessage(User receiver, String content) {
    Message message = new Message(generateMessageId(), this.userId, receiver.userId, content, new Date());
    receiver.receiveMessage(message);
}

private void receiveMessage(Message message) {
    System.out.println(username + &quot; received a message: &quot; + message.content);
}

private String generateMessageId() {
    return &quot;message_&quot; + (new Date()).getTime(); // Simple ID generation for example
}

}
abstract class Post {
protected String postId;
protected String content;
protected String mediaUrl;
protected Date createdAt;
protected String userId;
protected List<Comment> comments;  // Comments on this post
protected List<Like> likes;        // Likes on this post
public Post(String postId, String content, String mediaUrl, Date createdAt, String userId) {
    this.postId = postId;
    this.content = content;
    this.mediaUrl = mediaUrl;
    this.createdAt = createdAt;
    this.userId = userId;
    this.comments = new ArrayList&lt;&gt;();
    this.likes = new ArrayList&lt;&gt;();
}

public void addComment(String content, User user) {
    Comment comment = new Comment(generateCommentId(), content, new Date(), this.postId, user.userId);
    comments.add(comment);
    System.out.println(user.username + &quot; commented: &quot; + content);
}

private String generateCommentId() {
    return &quot;comment_&quot; + (comments.size() + 1); // Simple ID generation for example
}

public void addLike(User user) {
    Like like = new Like(generateLikeId(), this.postId, user.userId);
    likes.add(like);
    System.out.println(user.username + &quot; liked this post.&quot;);
}

private String generateLikeId() {
    return &quot;like_&quot; + (likes.size() + 1); // Simple ID generation for example
}

// Method to get the list of comments
public List&lt;Comment&gt; getComments() {
    return comments;
}

// Method to get the list of likes
public List&lt;Like&gt; getLikes() {
    return likes;
}

public abstract void displayPost();

}
class TextPost extends Post {
public TextPost(String postId, String content, Date createdAt, String userId) {
super(postId, content, null, createdAt, userId);
}
@Override
public void displayPost() {
    System.out.println(&quot;Text Post: &quot; + content);
}

}
class ImagePost extends Post {
public ImagePost(String postId, String content, String mediaUrl, Date createdAt, String userId) {
super(postId, content, mediaUrl, createdAt, userId);
}
@Override
public void displayPost() {
    System.out.println(&quot;Image Post: &quot; + content + &quot; [Media: &quot; + mediaUrl + &quot;]&quot;);
}

}
class PostFactory {
public static Post createPost(String type, String content, String mediaUrl, String userId) {
String postId = "post_" + (new Date()).getTime(); // Simple ID generation for example
if ("text".equalsIgnoreCase(type)) {
return new TextPost(postId, content, new Date(), userId);
} else if ("image".equalsIgnoreCase(type)) {
return new ImagePost(postId, content, mediaUrl, new Date(), userId);
}
throw new IllegalArgumentException("Unknown post type");
}
}
class Comment {
private String commentId;
private String content;
private Date createdAt;
private String postId;
private String userId;
public Comment(String commentId, String content, Date createdAt, String postId, String userId) {
    this.commentId = commentId;
    this.content = content;
    this.createdAt = createdAt;
    this.postId = postId;
    this.userId = userId;
}

}
class Like {
private String likeId;
private String postId;
private String userId;
public Like(String likeId, String postId, String userId) {
    this.likeId = likeId;
    this.postId = postId;
    this.userId = userId;
}

}
interface Command {
void execute();
}
class LikePostCommand implements Command {
private Post post;
private User user;
public LikePostCommand(Post post, User user) {
    this.post = post;
    this.user = user;
}

public void execute() {
    post.addLike(user); // Call the addLike method on the Post
    System.out.println(user.username + &quot; liked the post: &quot; + post.content);
}

}
// Command Queue to manage command execution
class CommandQueue {
private Queue<Command> commandQueue;
public CommandQueue() {
    this.commandQueue = new LinkedList&lt;&gt;();
}

public void addCommand(Command command) {
    commandQueue.add(command);
    System.out.println(&quot;Command added to queue.&quot;);
}

public void executeCommands() {
    while (!commandQueue.isEmpty()) {
        Command command = commandQueue.poll();
        if (command != null) {
            command.execute();
        }
    }
}

}
class Message {
private String messageId;
private String senderId;
private String receiverId;
private String content;
private Date createdAt;
public Message(String messageId, String senderId, String receiverId, String content, Date createdAt) {
    this.messageId = messageId;
    this.senderId = senderId;
    this.receiverId = receiverId;
    this.content = content;
    this.createdAt = createdAt;
}

}
/ Test interaction
public class SocialMediaApp {
public static void main(String[] args) {
NotificationService notificationService = new NotificationService();
CommandQueue commandQueue = new CommandQueue();
    User alice = new User(&quot;1&quot;, &quot;Alice&quot;, notificationService);
    User bob = new User(&quot;2&quot;, &quot;Bob&quot;, notificationService);

    // Alice follows Bob
    alice.followUser(bob);

    // Alice creates a text post
    alice.createPost(&quot;Hello World!&quot;, null, &quot;text&quot;);

    // Bob likes Alice&#39;s post
    Post alicePost = alice.posts.get(0); // Get Alice&#39;s first post
    LikePostCommand likeCommand = new LikePostCommand(alicePost, bob);

    // Adding command to the queue
    commandQueue.addCommand(likeCommand);

    // Bob sends a message to Alice
    bob.sendMessage(alice, &quot;How are you?&quot;);

    // Execute all queued commands
    commandQueue.executeCommands();
}

}

Adhere to SOLID Guidelines

Check and explain whether your design adheres to solid principles (Ask interviewer what SOLID principle is if you can not recall it.)...

Consider Scalability and Flexibility

Explain how your design can handle changes in scale and whether it would be easily to extend with new functionalities...

Create/Explain your diagram(s)

Try creating a class, flow, state and/or sequence diagram using the diagramming tool. Mermaid flow diagrams can be used to represent system use cases. You can ask the interviewer bot to create a starter diagram if unfamiliar with the tool. Briefly explain your diagrams if necessary...

Future improvements

Critically examine your design for any flaws or areas for future improvement...