Added meeting scheduler low level design (#4)

* Added meeting scheduler low level design

* Added mutex and Getroom

* Add feedback and readme for meeting scheduler design

* Update IsFree method for room

Author: codeimmortal

README.md

@@ -11,6 +11,7 @@ Welcome to the **Low-Level System Design in Go** repository! This repository con
 - [Library Management System](#library-management-system)
 - [Vending Machine System](#vending-machine-system)
 - [Social Media Platform](#social-media-platform)
+- [Meeting Scheduler](#meeting-scheduler)
 - [Contributing Guidelines](#contributing-guidelines)
 
 ## Overview
@@ -99,6 +100,24 @@ The fifth project in this repository is a **Social Media Platform**. This system
 - **Error Handling**: Provides informative error messages for actions such as attempting to interact with nonexistent users or posts.
 - **Encapsulation of Features**: Each feature (users, posts, friendships) is encapsulated in a separate manager class, promoting modularity and ease of maintenance.
 
+
+## Meeting Scheduler
+
+The sixth project in this repository is a Meeting Scheduler, a system that simulates meeting scheduling for users. It demonstrates the following concepts:
+
+- Observer pattern for notifying users about scheduled meetings.
+- Book meeting for muliple users in particular time slot, so that room slot does not collide with each other.
+- Room calendar management, tracking when a room is booked or available.
+- Concurrency control, preventing scheduling conflicts in real time.
+
+### Features
+
+- Book and cancel meetings seamlessly.
+- Prevent double booking, allowing reservations only if the time slot is available.
+- Capacity-based booking, ensuring a room can only be booked if it has enough seats for all attendees.
+- Automated notifications to inform users about meeting bookings or cancellations.
+- Fetching all free rooms for a specific time slot.
+
 ## Contributing Guidelines
 Contributions to expand this repository with more low-level system design problems and solutions are welcomed. Here’s how you can contribute:
 

meeting_scheduler/MeetingScheduler.go

@@ -0,0 +1,70 @@
+package main
+
+import "errors"
+
+type MeetingScheduler struct {
+	rooms   []*MeetingRoom
+	meeting []*Meeting
+}
+
+func NewMeetingScheduler() *MeetingScheduler {
+	return &MeetingScheduler{
+		rooms:   []*MeetingRoom{},
+		meeting: []*Meeting{},
+	}
+}
+
+func (ms *MeetingScheduler) GetRoom(roomId int) *MeetingRoom {
+	for _, room := range ms.rooms {
+		if room.id == roomId {
+			return room
+		}
+	}
+	return nil
+}
+
+// book meeting for a given room
+func (ms *MeetingScheduler) BookMeeting(roomId int, meetingName string, participant []*User, host User, dur *interval, capacity int) (int, error) {
+
+	room := ms.GetRoom(roomId)
+	if room == nil {
+		return 0, errors.New("Room not found")
+	}
+
+	err := room.BookRoom(capacity, dur)
+	if err != nil {
+		return 0, err
+	}
+
+	meeting := NewMeeting(len(ms.meeting), meetingName, dur.id, room, &host)
+	ms.meeting = append(ms.meeting, meeting)
+
+	meeting.AddParticipant(participant...)
+
+	return len(ms.meeting) - 1, nil
+}
+
+func (ms *MeetingScheduler) CancelMeeting(meetingId int) error {
+	if meetingId >= len(ms.meeting) || meetingId < 0 || ms.meeting[meetingId] == nil {
+		return errors.New("There is no such meeting")
+	}
+
+	// cancel meeting
+	ms.meeting[meetingId].CancelMeeting()
+	ms.meeting[meetingId] = nil
+
+	return nil
+}
+
+// GetFreeRoom returns all rooms which are free in particular time interval
+func (ms *MeetingScheduler) GetFreeRoom(dur *interval) []*MeetingRoom {
+	freeRooms := []*MeetingRoom{}
+	for _, room := range ms.rooms {
+		if room.IsFree(dur) {
+			freeRooms = append(freeRooms, room)
+		}
+
+	}
+
+	return freeRooms
+}

meeting_scheduler/calender.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"errors"
+	"time"
+)
+
+type interval struct {
+	id     int
+	date   time.Time
+	start  time.Time
+	end    time.Time
+	status BookingStatus
+}
+
+type Calendar struct {
+	interval map[int]*interval
+}
+
+func (c *Calendar) isFree(dur *interval) bool {
+	// Check if the calendar is free for the given interval, you can add logic to better check if the interval is free
+	for _, ci := range c.interval {
+		// check if time is colliding
+		if ci.status == BOOKED && ci.start.Before(dur.end) && ci.end.After(dur.start) {
+			return false
+		}
+	}
+	return true
+}
+
+func (c *Calendar) setIntervalStatus(durId int, status BookingStatus) {
+	c.interval[durId].status = status
+}
+
+func (c *Calendar) bookInterval(dur *interval) error {
+	if c.isFree(dur) {
+		c.interval[dur.id] = dur
+		c.setIntervalStatus(dur.id, BOOKED)
+		return nil
+	}
+
+	return errors.New("Interval is not free")
+}
+
+func (c *Calendar) cancelInterval(durId int) error {
+	if val, ok := c.interval[durId]; ok {
+		c.setIntervalStatus(val.id, CANCEL)
+		return nil
+	}
+
+	return errors.New("Interval is not free")
+}

meeting_scheduler/go.mod

@@ -0,0 +1,5 @@
+module lld_meeting_scheduler
+
+go 1.22.6
+
+require github.com/pkg/errors v0.9.1

meeting_scheduler/go.sum

@@ -0,0 +1,2 @@
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

meeting_scheduler/main.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+// user code flow
+func main() {
+
+	// prerequisites before scheduling the meeting
+
+	// create rooms1
+	room1 := &MeetingRoom{id: 1, capacity: 10, name: "Room 1", location: location{}, calendar: &Calendar{
+		interval: make(map[int]*interval),
+	}}
+
+	// create rooms2
+	room2 := &MeetingRoom{id: 2, capacity: 10, name: "Room 2", location: location{}, calendar: &Calendar{
+		interval: make(map[int]*interval),
+	}}
+
+	// create user
+	users := []*User{
+		&User{id: 1, name: "sam", email: "[email protected]"},
+		&User{id: 2, name: "ron", email: "[email protected]"},
+		&User{id: 3, name: "don", email: "[email protected]"},
+		&User{id: 4, name: "him", email: "[email protected]"},
+	}
+
+	// first we will have already present rooms
+	scheduler := NewMeetingScheduler()
+
+	scheduler.rooms = append(scheduler.rooms, []*MeetingRoom{room1, room2}...)
+
+	interval1 := &interval{
+		id:    1,
+		date:  time.Date(2009, 11, 17, 0, 0, 0, 0, time.UTC),
+		start: time.Date(2009, 11, 17, 1, 0, 0, 0, time.UTC),
+		end:   time.Date(2009, 11, 17, 1, 30, 0, 0, time.UTC)}
+
+	// prerequisites complete,Now we start the scheduling meeting, taking sam as host and ron as participant
+	_, err := scheduler.BookMeeting(1, "Daily status", []*User{users[1], users[2]}, *users[0], interval1, 10)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+
+	// lets try to book the same room again
+	_, err = scheduler.BookMeeting(2, "Party", []*User{users[1], users[2]}, *users[0], interval1, 10)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+
+	// lets try to book room with more capacity
+	_, err = scheduler.BookMeeting(3, "Discussion", []*User{users[1], users[2]}, *users[0], interval1, 15)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+
+	// book for other interval
+	interval2 := &interval{
+		id:    2,
+		date:  time.Date(2009, 11, 17, 0, 0, 0, 0, time.UTC),
+		start: time.Date(2009, 11, 17, 2, 0, 0, 0, time.UTC),
+		end:   time.Date(2009, 11, 17, 2, 30, 0, 0, time.UTC)}
+
+	// lets try to book room with more capacity
+	meetinIDx, err := scheduler.BookMeeting(1, "Discussion", []*User{users[1], users[3]}, *users[0], interval2, 3)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+
+	// lets try to book room with more capacity
+	_, err = scheduler.BookMeeting(1, "Discussion", []*User{users[1], users[3]}, *users[0], interval2, 3)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+
+	// cancel the meeting and book again
+	scheduler.CancelMeeting(meetinIDx)
+
+	// lets try to book room with more capacity
+	_, err = scheduler.BookMeeting(1, "Discussion again", []*User{users[1], users[3]}, *users[0], interval2, 3)
+	if err != nil {
+		fmt.Printf("\nError while scheduling meeting:%#v", err)
+	}
+}

meeting_scheduler/meeting.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+type BookingStatus string
+
+const (
+	BOOKED BookingStatus = "booked"
+	CANCEL BookingStatus = "cancel"
+)
+
+type Meeting struct {
+	id                int
+	name              string
+	room              *MeetingRoom
+	participant       []*User
+	host              *User
+	meetingDurationId int
+	status            BookingStatus
+	mu                sync.Mutex
+}
+
+func NewMeeting(id int, name string, meetingDurationId int, room *MeetingRoom, host *User) *Meeting {
+	return &Meeting{
+		id:                id,
+		name:              name,
+		room:              room,
+		meetingDurationId: meetingDurationId,
+		participant:       []*User{},
+		host:              host,
+		status:            BOOKED,
+	}
+}
+
+func (m *Meeting) AddParticipant(u ...*User) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.participant = append(m.participant, u...)
+}
+
+func (m *Meeting) RemoveParticipant(userId int) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// remove user from the participant list
+	for i, user := range m.participant {
+		if user.id == userId {
+			m.participant = append(m.participant[:i], m.participant[i+1:]...)
+		}
+	}
+}
+
+func (m *Meeting) setStatus(status BookingStatus) {
+	m.status = status
+}
+
+func (m *Meeting) CancelMeeting() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.setStatus(CANCEL)
+	m.room.CancelRoom(m.meetingDurationId)
+	m.notifyParticipants(CANCEL)
+}
+
+// notify use oberver pattern to notify all the participants
+func (m *Meeting) notifyParticipants(status BookingStatus) {
+	fmt.Printf("\nMeeting %s has been %s\n", m.name, status)
+	for _, user := range m.participant {
+		user.notification()
+	}
+}