create db update message function

api/api.go

@@ -42,6 +42,7 @@ func Start() {
 			r.Use(MessageCtx) // Load message
 			r.Get("/", GetMessage)
 			r.Delete("/", DeleteMessage)
+			r.Post("/edit", EditMessage)
 		})
 		r.Post("/new", NewMessage)
 	})

api/db.go

@@ -41,11 +41,21 @@ func dbGetMessage(id string) (*Message, error) {
 			if err != nil {
 				return nil, fmt.Errorf("failed to parse timestamp: %v", err)
 			}
+			editedStr, ok := message["Edited"].(string)
+			var edited time.Time
+			if ok && editedStr != "" {
+				var err error
+				edited, err = time.Parse(time.RFC3339, editedStr)
+				if err != nil {
+					return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
+				}
+			}
 			return &Message{
 				ID:        message["ID"].(string),
 				UserID:    int64(message["UserID"].(float64)),
 				Body:      message["Body"].(string),
 				Timestamp: timestamp,
+				Edited:    edited,
 			}, nil
 		}
 	}
@@ -67,11 +77,21 @@ func dbGetAllMessages() ([]*Message, error) {
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse timestamp: %v", err)
 		}
+		editedStr, ok := message["Edited"].(string)
+		var edited time.Time
+		if ok && editedStr != "" {
+			var err error
+			edited, err = time.Parse(time.RFC3339, editedStr)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
+			}
+		}
 		result = append(result, &Message{
 			ID:        message["ID"].(string),
 			UserID:    int64(message["UserID"].(float64)),
 			Body:      message["Body"].(string),
 			Timestamp: timestamp,
+			Edited:    edited,
 		})
 	}
 	if len(result) == 0 {
@@ -81,23 +101,134 @@ func dbGetAllMessages() ([]*Message, error) {
 }
 
 func dbAddUser(id int64, name string) error {
+	currentData := db.ExecDB("users")
+	if currentData == nil {
+		return fmt.Errorf("error reading users database")
+	}
+
+	users, ok := currentData["users"].([]interface{})
+	if !ok {
+		return fmt.Errorf("users data is in an unexpected format")
+	}
+
 	user := map[string]interface{}{
 		"ID":   float64(id), // JSON numbers are float64 by default
 		"Name": name,
 	}
-	return db.AddUser(user)
+
+	users = append(users, user)
+	return db.WriteDB("users", users)
 }
 
 func dbAddMessage(message *Message) error {
+	currentData := db.ExecDB("messages")
+	if currentData == nil {
+		return fmt.Errorf("error reading messages database")
+	}
+
+	messages, ok := currentData["messages"].([]interface{})
+	if !ok {
+		return fmt.Errorf("messages data is in an unexpected format")
+	}
+
+	var edited interface{}
+	if message.Edited.IsZero() {
+		edited = nil // Set to nil if Edited is the zero value
+	} else {
+		edited = message.Edited.Format(time.RFC3339)
+	}
+
 	dbMessage := map[string]interface{}{
 		"ID":        message.ID,
 		"UserID":    message.UserID, // JSON numbers are float64
 		"Body":      message.Body,
-		"Timestamp": message.Timestamp,
+		"Timestamp": message.Timestamp.Format(time.RFC3339),
+		"Edited":    edited,
 	}
-	return db.AddMessage(dbMessage)
+
+	messages = append(messages, dbMessage)
+	return db.WriteDB("messages", messages)
+}
+
+func dbUpdateMessage(updatedMessage *Message) error {
+	currentData := db.ExecDB("messages")
+	if currentData == nil {
+		return fmt.Errorf("error reading messages database")
+	}
+
+	messages, ok := currentData["messages"].([]interface{})
+	if !ok {
+		return fmt.Errorf("messages data is in an unexpected format")
+	}
+
+	var updatedMessages []interface{}
+	found := false
+
+	for _, m := range messages {
+		message, ok := m.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		if messageID, ok := message["ID"].(string); ok && messageID == updatedMessage.ID {
+			found = true
+
+			var edited interface{}
+			if updatedMessage.Edited.IsZero() {
+				edited = nil // Set to nil if Edited is the zero value
+			} else {
+				edited = updatedMessage.Edited.Format(time.RFC3339)
+			}
+
+			message = map[string]interface{}{
+				"ID":        updatedMessage.ID,
+				"UserID":    updatedMessage.UserID,
+				"Body":      updatedMessage.Body,
+				"Timestamp": updatedMessage.Timestamp.Format(time.RFC3339),
+				"Edited":    edited,
+			}
+		}
+		updatedMessages = append(updatedMessages, message)
+	}
+
+	if !found {
+		return fmt.Errorf("message with ID %s not found", updatedMessage.ID)
+	}
+
+	return db.WriteDB("messages", updatedMessages)
 }
 
 func dbDeleteMessage(id string) error {
-	return db.DeleteMessage(id)
+	currentData := db.ExecDB("messages")
+	if currentData == nil {
+		return fmt.Errorf("error reading messages database")
+	}
+
+	messages, ok := currentData["messages"].([]interface{})
+	if !ok {
+		return fmt.Errorf("messages data is in an unexpected format")
+	}
+
+	var updatedMessages []interface{}
+	found := false
+
+	for _, m := range messages {
+		message, ok := m.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		if messageID, ok := message["ID"].(string); ok && messageID == id {
+			found = true
+			continue
+		}
+
+		updatedMessages = append(updatedMessages, message)
+	}
+
+	if !found {
+		return fmt.Errorf("message with ID %s not found", id)
+	}
+
+	return db.WriteDB("messages", updatedMessages)
 }

api/message.go

@@ -48,6 +48,38 @@ func GetMessage(w http.ResponseWriter, r *http.Request) {
 
 }
 
+func EditMessage(w http.ResponseWriter, r *http.Request) {
+	message, ok := r.Context().Value(messageKey{}).(*Message)
+	if !ok || message == nil {
+		render.Render(w, r, ErrNotFound)
+		return
+	}
+	err := r.ParseMultipartForm(64 << 10)
+	if err != nil {
+		http.Error(w, "Unable to parse form", http.StatusBadRequest)
+		return
+	}
+	body := r.FormValue("body")
+	if body == "" {
+		http.Error(w, "Message body cannot be empty", http.StatusBadRequest)
+		return
+	}
+
+	message.Body = body
+	message.Edited = time.Now()
+
+	err = dbUpdateMessage(message)
+	if err != nil {
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+
+	if err := render.Render(w, r, NewMessageResponse(message)); err != nil {
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+}
+
 func DeleteMessage(w http.ResponseWriter, r *http.Request) {
 	message, ok := r.Context().Value(messageKey{}).(*Message)
 	if !ok || message == nil {
@@ -102,6 +134,7 @@ func NewMessage(w http.ResponseWriter, r *http.Request) {
 		UserID:    userID,
 		Body:      body,
 		Timestamp: time.Now(),
+		Edited:    time.Time{},
 	}
 
 	err = dbAddMessage(&msg)
@@ -120,6 +153,7 @@ type Message struct {
 	UserID    int64     `json:"user_id"`
 	Body      string    `json:"body"`
 	Timestamp time.Time `json:"timestamp"`
+	Edited    time.Time `json:"edited"`
 }
 
 type MessageRequest struct {
@@ -144,15 +178,23 @@ func (m MessageResponse) MarshalJSON() ([]byte, error) {
 		UserID    int64        `json:"user_id"`
 		Body      string       `json:"body"`
 		Timestamp string       `json:"timestamp"`
+		Edited    *string      `json:"edited,omitempty"` // Use a pointer to allow null values
 		User      *UserPayload `json:"user,omitempty"`
 		Elapsed   int64        `json:"elapsed"`
 	}
 
+	var edited *string
+	if !m.Message.Edited.IsZero() { // Check if Edited is not the zero value
+		editedStr := m.Message.Edited.Format(time.RFC3339)
+		edited = &editedStr
+	}
+
 	ordered := OrderedMessageResponse{
 		ID:        m.Message.ID,
 		UserID:    m.Message.UserID,
 		Body:      m.Message.Body,
 		Timestamp: m.Message.Timestamp.Format(time.RFC3339),
+		Edited:    edited, // Null if Edited is zero
 		User:      m.User,
 		Elapsed:   m.Elapsed,
 	}

db/fake_db.go

@@ -71,58 +71,3 @@ func WriteDB(db_name string, data interface{}) error {
 	fmt.Printf("Successfully wrote to %s DB\n", db_name)
 	return nil
 }
-
-func AddUser(user map[string]interface{}) error {
-	currentData := ExecDB("users")
-	if currentData == nil {
-		return fmt.Errorf("error reading users database")
-	}
-
-	users := currentData["users"].([]interface{})
-	users = append(users, user)
-	return WriteDB("users", users)
-}
-
-func AddMessage(message map[string]interface{}) error {
-	currentData := ExecDB("messages")
-	if currentData == nil {
-		return fmt.Errorf("error reading messages database")
-	}
-
-	messages := currentData["messages"].([]interface{})
-	messages = append(messages, message)
-	return WriteDB("messages", messages)
-}
-
-func DeleteMessage(messageID string) error {
-	currentData := ExecDB("messages")
-	if currentData == nil {
-		return fmt.Errorf("error reading messages database")
-	}
-
-	messages, ok := currentData["messages"].([]interface{})
-	if !ok {
-		return fmt.Errorf("messages data is in an unexpected format")
-	}
-
-	var updatedMessages []interface{}
-	found := false
-
-	for _, value := range messages {
-		if item, ok := value.(map[string]interface{}); ok {
-			if id, exists := item["ID"]; exists {
-				if idStr, ok := id.(string); ok && idStr == messageID {
-					found = true
-					continue
-				}
-			}
-		}
-		updatedMessages = append(updatedMessages, value)
-	}
-
-	if !found {
-		return fmt.Errorf("message with ID %s not found", messageID)
-	}
-
-	return WriteDB("messages", updatedMessages)
-}

test_data/messages.json

@@ -1,62 +1,79 @@
 [
   {
     "Body": "hello",
+    "Edited": null,
     "ID": "1",
     "Timestamp": "2024-12-25T05:00:40Z",
     "UserID": 1
   },
   {
     "Body": "world",
+    "Edited": null,
     "ID": "2",
     "Timestamp": "2024-12-25T05:00:43Z",
     "UserID": 2
   },
   {
     "Body": "abababa",
+    "Edited": null,
     "ID": "3",
     "Timestamp": "2024-12-25T05:01:20Z",
     "UserID": 1
   },
   {
     "Body": "bitch",
+    "Edited": null,
     "ID": "4",
     "Timestamp": "2024-12-25T05:05:55Z",
     "UserID": 2
   },
   {
     "Body": "NIBBA",
+    "Edited": null,
     "ID": "5",
     "Timestamp": "2025-03-24T14:48:28.249221047-04:00",
     "UserID": 1
   },
   {
     "Body": "nibby",
+    "Edited": null,
     "ID": "6",
     "Timestamp": "2025-03-24T14:49:03.246929039-04:00",
     "UserID": 1
   },
   {
     "Body": "aaaaababananana",
+    "Edited": null,
     "ID": "msg_60f70a47-3be2-4315-869a-d6f151ec262a",
     "Timestamp": "2025-03-24T15:01:07.14371835-04:00",
     "UserID": 1
   },
   {
     "Body": "ababa abbott",
+    "Edited": null,
     "ID": "msg_94cbc26d-9098-4fa9-bd21-794516c2263d",
     "Timestamp": "2025-03-24T20:34:57.198849367-04:00",
     "UserID": 1
   },
   {
     "Body": "AAAAAA",
+    "Edited": null,
     "ID": "msg_ca8483db-e823-45c4-882c-fe0930610ba9",
     "Timestamp": "2025-03-24T21:17:04.350827576-04:00",
     "UserID": 1
   },
   {
     "Body": "i am a femboiiiii",
+    "Edited": null,
     "ID": "msg_fcdbb48a-4ea5-4fb3-b925-3a15eb7c291c",
     "Timestamp": "2025-03-24T21:27:48.565290147-04:00",
     "UserID": 2
+  },
+  {
+    "Body": "i love soap",
+    "Edited": "2025-03-27T14:49:14-04:00",
+    "ID": "msg_59851eb1-2e63-46c1-b496-55566c414e33",
+    "Timestamp": "2025-03-27T14:40:26-04:00",
+    "UserID": 1
   }
 ]