add another privilege methods, need test

internal/controller/privilege_internal/controller.go

@@ -3,6 +3,7 @@ package privilege_internal
 import (
 	"errors"
 	"github.com/gofiber/fiber/v2"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.uber.org/zap"
 	our_errors "hub_admin_backend_service/internal/errors"
 	"hub_admin_backend_service/internal/models"
@@ -176,7 +177,12 @@ func (p *PrivilegeInternal) PostMany(c *fiber.Ctx) error {
 
 	result, err := p.repo.PostMany(c.Context(), req)
 	if err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+		switch {
+		case errors.Is(err, our_errors.ErrAlreadyExist):
+			return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "One is privilege already exist"})
+		default:
+			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+		}
 	}
 
 	return c.Status(fiber.StatusOK).JSON(result)
@@ -188,10 +194,60 @@ func (p *PrivilegeInternal) UpdateMany(c *fiber.Ctx) error {
 	if err := c.BodyParser(&req); err != nil {
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
 	}
-	return c.SendStatus(http.StatusOK)
+
+	if len(req.Privileges) == 0 {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "len array dont be 0"})
+	}
+
+	for _, priv := range req.Privileges {
+		if !tools.Validate(priv) {
+			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Missing required fields"})
+		}
+	}
+
+	result, err := p.repo.UpdateMany(c.Context(), req)
+	if err != nil {
+		switch {
+		case errors.Is(err, our_errors.ErrNotFound):
+			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "One is privilege not found"})
+		default:
+			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+		}
+	}
+
+	return c.Status(fiber.StatusOK).JSON(result)
 }
 
 // хаб нода restorePrivilege
 func (p *PrivilegeInternal) Restore(c *fiber.Ctx) error {
+	var req struct {
+		ID string `json:"privilegeId"`
+	}
+
+	if err := c.BodyParser(&req); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
+	}
+
+	if req.ID == "" {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "PrivilegeID is required"})
+	}
+
+	_, err := primitive.ObjectIDFromHex(req.ID)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid id"})
+	}
+
+	result, err := p.repo.RestorePrivilege(c.Context(), req.ID)
+	if err != nil {
+		switch {
+		case errors.Is(err, our_errors.ErrNotFound):
+			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privilege not found"})
+		default:
+			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+		}
+	}
+
+	return c.Status(fiber.StatusOK).JSON(result)
+
 	return c.SendStatus(http.StatusOK)
 }

internal/controller/privilege_internal/route.go

@@ -12,7 +12,6 @@ func (p *PrivilegeInternal) Register(router fiber.Router) {
 	router.Post("/many", p.PostMany)
 	router.Put("/many", p.UpdateMany)
 	router.Post("/restore", p.Restore)
-
 }
 
 func (p *PrivilegeInternal) Name() string {

internal/repository/privilege/privilege.go

@@ -93,7 +93,7 @@ func (p *Privilege) Update(ctx context.Context, req models.CreateUpdateReq) (mod
 		p.logger.Error("Failed to find privilege", zap.Error(err))
 		return models.Privilege{}, err
 	}
-
+	currTime := time.Now()
 	update := bson.M{
 		"$set": bson.M{
 			"name":        req.Name,
@@ -102,7 +102,7 @@ func (p *Privilege) Update(ctx context.Context, req models.CreateUpdateReq) (mod
 			"type":        req.Type,
 			"value":       req.Value,
 			"price":       req.Price,
-			"updatedAt":   time.Now(),
+			"updatedAt":   currTime,
 		},
 	}
 
@@ -118,7 +118,7 @@ func (p *Privilege) Update(ctx context.Context, req models.CreateUpdateReq) (mod
 	exist.Type = req.Type
 	exist.Value = req.Value
 	exist.Price = req.Price
-	exist.UpdatedAt = time.Now()
+	exist.UpdatedAt = currTime
 
 	return exist, nil
 }
@@ -193,8 +193,18 @@ func (p *Privilege) GetByServiceKey(ctx context.Context, serviceKey string) ([]m
 }
 
 func (p *Privilege) PostMany(ctx context.Context, req models.ManyCreateUpdate) ([]models.Privilege, error) {
-	var privileges []interface{}
+	var privileges []models.Privilege
 	for _, r := range req.Privileges {
+		exist := models.Privilege{}
+		err := p.mdb.FindOne(ctx, bson.M{"privilegeId": r.PrivilegeId}).Decode(exist)
+		if err == nil {
+			p.logger.Error("privilege already exists", zap.String("privilegeId", r.PrivilegeId))
+			return nil, errors.ErrAlreadyExist
+		} else if err != mongo.ErrNoDocuments {
+			p.logger.Error("failed to check existing privilege", zap.Error(err))
+			return nil, err
+		}
+
 		privileges = append(privileges, models.Privilege{
 			ID:          primitive.NewObjectID(),
 			Name:        r.Name,
@@ -209,17 +219,77 @@ func (p *Privilege) PostMany(ctx context.Context, req models.ManyCreateUpdate) (
 		})
 	}
 
-	result, err := p.mdb.InsertMany(ctx, privileges)
+	noneType := make([]interface{}, len(privileges))
+	for i, v := range privileges {
+		noneType[i] = v
+	}
+
+	_, err := p.mdb.InsertMany(ctx, noneType)
 	if err != nil {
 		p.logger.Error("failed to insert privileges", zap.Error(err))
 		return nil, err
 	}
 
-	inserted := make([]models.Privilege, len(result.InsertedIDs))
+	return privileges, nil
-	for i, id := range result.InsertedIDs {
+}
-		inserted[i] = privileges[i].(models.Privilege)
+
-		inserted[i].ID = id.(primitive.ObjectID)
+func (p *Privilege) UpdateMany(ctx context.Context, req models.ManyCreateUpdate) ([]models.Privilege, error) {
+	var updated []models.Privilege
+	for _, r := range req.Privileges {
+		filter := bson.M{"privilegeId": r.PrivilegeId}
+		update := bson.M{
+			"$set": bson.M{
+				"name":        r.Name,
+				"serviceKey":  r.ServiceKey,
+				"description": r.Description,
+				"type":        r.Type,
+				"value":       r.Value,
+				"price":       r.Price,
+				"updatedAt":   time.Now(),
+			},
+		}
+
+		var updatedPrivilege models.Privilege
+		opts := options.FindOneAndUpdate().SetReturnDocument(options.After)
+		err := p.mdb.FindOneAndUpdate(ctx, filter, update, opts).Decode(&updatedPrivilege)
+		if err != nil {
+			if err == mongo.ErrNoDocuments {
+				return nil, errors.ErrNotFound
+			}
+			p.logger.Error("failed to update privilege", zap.Error(err))
+			return nil, err
+		}
+
+		updated = append(updated, updatedPrivilege)
+	}
+	return updated, nil
+}
+
+func (p *Privilege) RestorePrivilege(ctx context.Context, id string) (models.Privilege, error) {
+	exist := models.Privilege{}
+	err := p.mdb.FindOne(ctx, bson.M{"privilegeId": id}).Decode(exist)
+	if err == mongo.ErrNoDocuments {
+		return models.Privilege{}, errors.ErrNotFound
+	} else if err != nil {
+		p.logger.Error("Failed to find privilege", zap.Error(err))
+		return models.Privilege{}, err
+	}
+	currTime := time.Now()
+	update := bson.M{
+		"$set": bson.M{
+			"isDeleted": false,
+			"updatedAt": currTime,
+		},
 	}
 
-	return inserted, nil
+	_, err = p.mdb.UpdateOne(ctx, bson.M{"privilegeId": id}, update)
+	if err != nil {
+		p.logger.Error("Failed to restore privilege", zap.Error(err))
+		return models.Privilege{}, err
+	}
+
+	exist.IsDeleted = false
+	exist.UpdatedAt = currTime
+
+	return exist, nil
 }