485 lines
15 KiB
Go
485 lines
15 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/fpmb/server/internal/database"
|
|
"github.com/fpmb/server/internal/models"
|
|
"github.com/gofiber/fiber/v2"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
func GetBoard(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
if _, err := getProjectRole(ctx, projectID, userID); err != nil {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Access denied"})
|
|
}
|
|
|
|
colCursor, err := database.GetCollection("board_columns").Find(ctx,
|
|
bson.M{"project_id": projectID},
|
|
options.Find().SetSort(bson.M{"position": 1}))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "Failed to fetch columns"})
|
|
}
|
|
defer colCursor.Close(ctx)
|
|
|
|
var columns []models.BoardColumn
|
|
colCursor.All(ctx, &columns)
|
|
|
|
type ColumnWithCards struct {
|
|
models.BoardColumn
|
|
Cards []models.Card `json:"cards"`
|
|
}
|
|
|
|
result := []ColumnWithCards{}
|
|
for _, col := range columns {
|
|
cardCursor, err := database.GetCollection("cards").Find(ctx,
|
|
bson.M{"column_id": col.ID},
|
|
options.Find().SetSort(bson.M{"position": 1}))
|
|
if err != nil {
|
|
result = append(result, ColumnWithCards{BoardColumn: col, Cards: []models.Card{}})
|
|
continue
|
|
}
|
|
var cards []models.Card
|
|
cardCursor.All(ctx, &cards)
|
|
cardCursor.Close(ctx)
|
|
if cards == nil {
|
|
cards = []models.Card{}
|
|
}
|
|
result = append(result, ColumnWithCards{BoardColumn: col, Cards: cards})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{"project_id": projectID, "columns": result})
|
|
}
|
|
|
|
func CreateColumn(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
var body struct {
|
|
Title string `json:"title"`
|
|
}
|
|
if err := c.BodyParser(&body); err != nil || body.Title == "" {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Title is required"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
roleFlags, err := getProjectRole(ctx, projectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
count, _ := database.GetCollection("board_columns").CountDocuments(ctx, bson.M{"project_id": projectID})
|
|
now := time.Now()
|
|
col := &models.BoardColumn{
|
|
ID: primitive.NewObjectID(),
|
|
ProjectID: projectID,
|
|
Title: body.Title,
|
|
Position: int(count),
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
|
|
database.GetCollection("board_columns").InsertOne(ctx, col)
|
|
return c.Status(fiber.StatusCreated).JSON(col)
|
|
}
|
|
|
|
func UpdateColumn(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
columnID, err := primitive.ObjectIDFromHex(c.Params("columnId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid column ID"})
|
|
}
|
|
|
|
var body struct {
|
|
Title string `json:"title"`
|
|
}
|
|
c.BodyParser(&body)
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
roleFlags, err := getProjectRole(ctx, projectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
update := bson.M{"updated_at": time.Now()}
|
|
if body.Title != "" {
|
|
update["title"] = body.Title
|
|
}
|
|
|
|
col := database.GetCollection("board_columns")
|
|
col.UpdateOne(ctx, bson.M{"_id": columnID, "project_id": projectID}, bson.M{"$set": update})
|
|
|
|
var column models.BoardColumn
|
|
col.FindOne(ctx, bson.M{"_id": columnID}).Decode(&column)
|
|
return c.JSON(column)
|
|
}
|
|
|
|
func ReorderColumn(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
columnID, err := primitive.ObjectIDFromHex(c.Params("columnId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid column ID"})
|
|
}
|
|
|
|
var body struct {
|
|
Position int `json:"position"`
|
|
}
|
|
c.BodyParser(&body)
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
roleFlags, err := getProjectRole(ctx, projectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
database.GetCollection("board_columns").UpdateOne(ctx,
|
|
bson.M{"_id": columnID, "project_id": projectID},
|
|
bson.M{"$set": bson.M{"position": body.Position, "updated_at": time.Now()}},
|
|
)
|
|
return c.JSON(fiber.Map{"id": columnID, "position": body.Position})
|
|
}
|
|
|
|
func DeleteColumn(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
columnID, err := primitive.ObjectIDFromHex(c.Params("columnId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid column ID"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
roleFlags, err := getProjectRole(ctx, projectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleAdmin) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
database.GetCollection("board_columns").DeleteOne(ctx, bson.M{"_id": columnID, "project_id": projectID})
|
|
database.GetCollection("cards").DeleteMany(ctx, bson.M{"column_id": columnID})
|
|
return c.JSON(fiber.Map{"message": "Column deleted"})
|
|
}
|
|
|
|
func CreateCard(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
projectID, err := primitive.ObjectIDFromHex(c.Params("projectId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid project ID"})
|
|
}
|
|
|
|
columnID, err := primitive.ObjectIDFromHex(c.Params("columnId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid column ID"})
|
|
}
|
|
|
|
var body struct {
|
|
Title string `json:"title"`
|
|
Description string `json:"description"`
|
|
Priority string `json:"priority"`
|
|
Color string `json:"color"`
|
|
DueDate string `json:"due_date"`
|
|
Assignees []string `json:"assignees"`
|
|
Subtasks []models.Subtask `json:"subtasks"`
|
|
}
|
|
if err := c.BodyParser(&body); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request body"})
|
|
}
|
|
if body.Title == "" {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Title is required"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
roleFlags, err := getProjectRole(ctx, projectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
count, _ := database.GetCollection("cards").CountDocuments(ctx, bson.M{"column_id": columnID})
|
|
now := time.Now()
|
|
|
|
if body.Assignees == nil {
|
|
body.Assignees = []string{}
|
|
}
|
|
if body.Subtasks == nil {
|
|
body.Subtasks = []models.Subtask{}
|
|
}
|
|
if body.Priority == "" {
|
|
body.Priority = "Medium"
|
|
}
|
|
if body.Color == "" {
|
|
body.Color = "neutral"
|
|
}
|
|
|
|
var dueDate *time.Time
|
|
if body.DueDate != "" {
|
|
if parsed, parseErr := time.Parse("2006-01-02", body.DueDate); parseErr == nil {
|
|
dueDate = &parsed
|
|
}
|
|
}
|
|
|
|
card := &models.Card{
|
|
ID: primitive.NewObjectID(),
|
|
ColumnID: columnID,
|
|
ProjectID: projectID,
|
|
Title: body.Title,
|
|
Description: body.Description,
|
|
Priority: body.Priority,
|
|
Color: body.Color,
|
|
DueDate: dueDate,
|
|
Assignees: body.Assignees,
|
|
Subtasks: body.Subtasks,
|
|
Position: int(count),
|
|
CreatedBy: userID,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
|
|
database.GetCollection("cards").InsertOne(ctx, card)
|
|
|
|
for _, email := range card.Assignees {
|
|
var assignee models.User
|
|
if err := database.GetCollection("users").FindOne(ctx, bson.M{"email": email}).Decode(&assignee); err != nil {
|
|
continue
|
|
}
|
|
if assignee.ID == userID {
|
|
continue
|
|
}
|
|
createNotification(ctx, assignee.ID, "assign",
|
|
"You have been assigned to the task \""+card.Title+"\"",
|
|
card.ProjectID, card.ID)
|
|
}
|
|
|
|
return c.Status(fiber.StatusCreated).JSON(card)
|
|
}
|
|
|
|
func UpdateCard(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
cardID, err := primitive.ObjectIDFromHex(c.Params("cardId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid card ID"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
var existing models.Card
|
|
if err := database.GetCollection("cards").FindOne(ctx, bson.M{"_id": cardID}).Decode(&existing); err != nil {
|
|
return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Card not found"})
|
|
}
|
|
|
|
roleFlags, err := getProjectRole(ctx, existing.ProjectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
var body struct {
|
|
Title *string `json:"title"`
|
|
Description *string `json:"description"`
|
|
Priority *string `json:"priority"`
|
|
Color *string `json:"color"`
|
|
DueDate *string `json:"due_date"`
|
|
Assignees []string `json:"assignees"`
|
|
Subtasks []models.Subtask `json:"subtasks"`
|
|
}
|
|
c.BodyParser(&body)
|
|
|
|
update := bson.M{"updated_at": time.Now()}
|
|
if body.Title != nil {
|
|
update["title"] = *body.Title
|
|
}
|
|
if body.Description != nil {
|
|
update["description"] = *body.Description
|
|
}
|
|
if body.Priority != nil {
|
|
update["priority"] = *body.Priority
|
|
}
|
|
if body.Color != nil {
|
|
update["color"] = *body.Color
|
|
}
|
|
if body.DueDate != nil {
|
|
if *body.DueDate == "" {
|
|
update["due_date"] = nil
|
|
} else if parsed, parseErr := time.Parse("2006-01-02", *body.DueDate); parseErr == nil {
|
|
update["due_date"] = parsed
|
|
}
|
|
}
|
|
if body.Assignees != nil {
|
|
update["assignees"] = body.Assignees
|
|
}
|
|
if body.Subtasks != nil {
|
|
update["subtasks"] = body.Subtasks
|
|
}
|
|
|
|
col := database.GetCollection("cards")
|
|
col.UpdateOne(ctx, bson.M{"_id": cardID}, bson.M{"$set": update})
|
|
|
|
var card models.Card
|
|
col.FindOne(ctx, bson.M{"_id": cardID}).Decode(&card)
|
|
|
|
if body.Assignees != nil {
|
|
existingSet := make(map[string]bool)
|
|
for _, e := range existing.Assignees {
|
|
existingSet[e] = true
|
|
}
|
|
for _, email := range body.Assignees {
|
|
if existingSet[email] {
|
|
continue
|
|
}
|
|
var assignee models.User
|
|
if err := database.GetCollection("users").FindOne(ctx, bson.M{"email": email}).Decode(&assignee); err != nil {
|
|
continue
|
|
}
|
|
if assignee.ID == userID {
|
|
continue
|
|
}
|
|
createNotification(ctx, assignee.ID, "assign",
|
|
"You have been assigned to the task \""+card.Title+"\"",
|
|
card.ProjectID, card.ID)
|
|
}
|
|
}
|
|
|
|
return c.JSON(card)
|
|
}
|
|
|
|
func MoveCard(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
cardID, err := primitive.ObjectIDFromHex(c.Params("cardId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid card ID"})
|
|
}
|
|
|
|
var body struct {
|
|
ColumnID string `json:"column_id"`
|
|
Position int `json:"position"`
|
|
}
|
|
if err := c.BodyParser(&body); err != nil || body.ColumnID == "" {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "column_id is required"})
|
|
}
|
|
|
|
newColumnID, err := primitive.ObjectIDFromHex(body.ColumnID)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid column_id"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
var card models.Card
|
|
if err := database.GetCollection("cards").FindOne(ctx, bson.M{"_id": cardID}).Decode(&card); err != nil {
|
|
return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Card not found"})
|
|
}
|
|
|
|
roleFlags, err := getProjectRole(ctx, card.ProjectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
col := database.GetCollection("cards")
|
|
col.UpdateOne(ctx, bson.M{"_id": cardID}, bson.M{"$set": bson.M{
|
|
"column_id": newColumnID,
|
|
"position": body.Position,
|
|
"updated_at": time.Now(),
|
|
}})
|
|
|
|
var updated models.Card
|
|
col.FindOne(ctx, bson.M{"_id": cardID}).Decode(&updated)
|
|
return c.JSON(updated)
|
|
}
|
|
|
|
func DeleteCard(c *fiber.Ctx) error {
|
|
userID, err := primitive.ObjectIDFromHex(c.Locals("user_id").(string))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid user"})
|
|
}
|
|
|
|
cardID, err := primitive.ObjectIDFromHex(c.Params("cardId"))
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid card ID"})
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
var card models.Card
|
|
if err := database.GetCollection("cards").FindOne(ctx, bson.M{"_id": cardID}).Decode(&card); err != nil {
|
|
return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Card not found"})
|
|
}
|
|
|
|
roleFlags, err := getProjectRole(ctx, card.ProjectID, userID)
|
|
if err != nil || !hasPermission(roleFlags, RoleEditor) {
|
|
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "Insufficient permissions"})
|
|
}
|
|
|
|
database.GetCollection("cards").DeleteOne(ctx, bson.M{"_id": cardID})
|
|
return c.JSON(fiber.Map{"message": "Card deleted"})
|
|
}
|