EASY Process Notifications

Textio now has a system to process different types of notifications: direct messages, group messages, and system alerts. Each notification type has a unique way of calculating its importance score based on user interaction and content.

Assignment

1

Implement importance methods for each message type

• For a directMessage the importance score is based on if the message isUrgent or not. If it is urgent, the importance score is 50 otherwise the importance score is equal to the DM's priorityLevel.

• For a groupMessage the importance score is based on the message's priorityLevel.

• All systemAlert messages should return a 100 importance score.

2

Complete processNotification function

• For a directMessage, return the sender's username and importance score.

• For a groupMessage, return the group's name and the importance score.

• For a systemAlert, return the alert code and the importance score.

• If the notification does not match any known type, return an empty string and a score of 0.

Solution

main.go

package main

type notification interface {
	importance() int
}

type directMessage struct {
	senderUsername string
	messageContent string
	priorityLevel  int
	isUrgent       bool
}

func (m directMessage) importance() int{
	priortyScore := m.priorityLevel
	urgent:= m.isUrgent

	if urgent{
		return 50
	}else{
		return priortyScore
	}
}

type groupMessage struct {
	groupName      string
	messageContent string
	priorityLevel  int
}

func (g groupMessage) importance() int{
	return g.priorityLevel
}

type systemAlert struct {
	alertCode      string
	messageContent string
}

func (s systemAlert) importance() int{
	return 100
}

func processNotification(n notification) (string, int) {
	switch v := n.(type){
	case directMessage:
		return v.senderUsername, v.importance()
	case groupMessage:
		return v.groupName, v.importance()
	case systemAlert:
		return v.alertCode, v.importance()
	default:
		return "",0
	}
}

🔍 Concept Breakdown

1. The notification Interface

type notification interface {
	importance() int
}

• This defines a contract: Any type (struct) that wants to be considered a “notification” must have an importance() method that returns an int.

• This allows polymorphism — meaning, you can treat different types (directMessage, groupMessage, systemAlert) the same way as long as they satisfy this interface.

---

2. The directMessage Struct

type directMessage struct {
	senderUsername string
	messageContent string
	priorityLevel  int
	isUrgent       bool
}

• Represents a direct message between users.

• The fields store who sent it, the message text, its priority, and whether it’s urgent.

Its method:

func (m directMessage) importance() int {
	if m.isUrgent {
		return 50
	}
	return m.priorityLevel
}

• Implements the importance() method required by the notification interface.

• If urgent → returns a fixed score of 50.

• Otherwise → returns its priority level.

Because it defines importance(), this struct satisfies the notification interface.

---

3. The groupMessage Struct

type groupMessage struct {
	groupName      string
	messageContent string
	priorityLevel  int
}

• Represents messages sent to a group.

• Its importance() method simply returns priorityLevel.

---

4. The systemAlert Struct

type systemAlert struct {
	alertCode      string
	messageContent string
}

• Represents system-generated alerts (like errors or warnings).

• Always has the maximum importance:

func (s systemAlert) importance() int {
	return 100
}

---

5. The processNotification Function

func processNotification(n notification) (string, int) {
	switch v := n.(type) {
	case directMessage:
		return v.senderUsername, v.importance()
	case groupMessage:
		return v.groupName, v.importance()
	case systemAlert:
		return v.alertCode, v.importance()
	default:
		return "", 0
	}
}

• This function accepts any value that implements notification.

• It uses a type switch (switch v := n.(type)) to detect what specific struct the notification is.

• Depending on the type:

  • directMessage → return username + importance score

  • groupMessage → return group name + importance score

  • systemAlert → return alert code + importance score

  • Unknown → return empty string and 0

---

⚙️ Example Usage

example.go

package main

import "fmt"

func main() {
	// Create a few sample notifications
	dm := directMessage{
		senderUsername: "Mario",
		messageContent: "Need your help ASAP",
		priorityLevel:  10,
		isUrgent:       true,
	}

	gm := groupMessage{
		groupName:      "Security Team",
		messageContent: "Meeting at 3PM",
		priorityLevel:  7,
	}

	sa := systemAlert{
		alertCode:      "ALERT_001",
		messageContent: "System overheating detected",
	}

	// Process each notification
	fmt.Println(processNotification(dm))
	fmt.Println(processNotification(gm))
	fmt.Println(processNotification(sa))
}

🧩 Output

Mario 50
Security Team 7
ALERT_001 100

---

🧠 Summary of How the Types Work Together

Type	Implements	importance() Logic	processNotification Output
directMessage	notification	50 if urgent, else priorityLevel	Username + importance
groupMessage	notification	Returns priorityLevel	Group name + importance
systemAlert	notification	Always 100	Alert code + importance

All three structs satisfy the same interface, which allows you to pass them to a single function (processNotification) that can handle them differently based on their concrete type — that’s Go polymorphism in action.