Refactor Notification Management and Enhance Customer Features

- Updated the notification handling logic to utilize a new SDK for sending notifications, improving the flexibility and scalability of the notification system.
- Introduced new methods in the notification service for sending notifications to users and customers based on various target audience types, enhancing the notification delivery capabilities.
- Added a new endpoint to assign companies to a customer, improving customer management functionalities.
- Refactored the customer entity and forms to replace 'CompanyIDs' with 'Companies', ensuring consistency across the data model.
- Enhanced API documentation with Swagger comments for the new endpoint and updated notification structures, ensuring clarity for API consumers.

internal/customer/form.go

@@ -60,6 +60,7 @@ type CustomerResponse struct {
 	CreatedAt   int64             `json:"created_at"`
 	LastLoginAt *int64            `json:"last_login_at"`
 	Companies   []*CompanySummary `json:"companies"`
+	DeviceToken []string          `json:"-"`
 }
 
 // ToResponse converts Customer to CustomerResponse

internal/customer/repository.go

@@ -20,6 +20,9 @@ type Repository interface {
 	GetByID(ctx context.Context, id string) (*Customer, error)
 	GetByEmail(ctx context.Context, email string) (*Customer, error)
 	GetByUsername(ctx context.Context, username string) (*Customer, error)
+	GetByIDs(ctx context.Context, ids []string) ([]Customer, error)
+	GetByRole(ctx context.Context, role CustomerRole) ([]Customer, error)
+	GetByCompanies(ctx context.Context, companies []string) ([]Customer, error)
 	GetByCompanyID(ctx context.Context, companyID string, pagination *response.Pagination) ([]*Customer, int64, error)
 	Search(ctx context.Context, form *SearchCustomersForm, pagination *response.Pagination) ([]Customer, int64, error)
 	Delete(ctx context.Context, id string) error
@@ -168,6 +171,48 @@ func (r *customerRepository) GetByUsername(ctx context.Context, username string)
 	return customer, nil
 }
 
+// GetByIDs retrieves customers by IDs
+func (r *customerRepository) GetByIDs(ctx context.Context, ids []string) ([]Customer, error) {
+	customers, err := r.ormRepo.FindAll(ctx, bson.M{"_id": bson.M{"$in": ids}}, orm.NewPaginationBuilder().Limit(len(ids)).Build())
+	if err != nil {
+		if errors.Is(err, orm.ErrDocumentNotFound) {
+			return nil, errors.New("customers not found")
+		}
+		r.logger.Error("Failed to get customers by IDs", map[string]interface{}{
+			"error": err.Error(),
+			"ids":   ids,
+		})
+		return nil, err
+	}
+	return customers.Items, nil
+}
+
+// GetByRole retrieves customers by role
+func (r *customerRepository) GetByRole(ctx context.Context, role CustomerRole) ([]Customer, error) {
+	customers, err := r.ormRepo.FindAll(ctx, bson.M{"role": role}, orm.NewPaginationBuilder().Build())
+	if err != nil {
+		if errors.Is(err, orm.ErrDocumentNotFound) {
+			return nil, errors.New("customers not found")
+		}
+		r.logger.Error("Failed to get customers by role", map[string]interface{}{
+			"error": err.Error(),
+			"role":  role,
+		})
+		return nil, err
+	}
+	return customers.Items, nil
+}
+
+// GetByCompanies retrieves customers by companies
+
+func (r *customerRepository) GetByCompanies(ctx context.Context, companies []string) ([]Customer, error) {
+	customers, err := r.ormRepo.FindAll(ctx, bson.M{"companies": bson.M{"$in": companies}}, orm.NewPaginationBuilder().Build())
+	if err != nil {
+		return nil, err
+	}
+	return customers.Items, nil
+}
+
 // GetByCompanyID retrieves customers by company ID with pagination
 func (r *customerRepository) GetByCompanyID(ctx context.Context, companyID string, pagination *response.Pagination) ([]*Customer, int64, error) {
 	// Build pagination

internal/customer/service.go

@@ -29,6 +29,9 @@ type Service interface {
 	Register(ctx context.Context, form *CreateCustomerForm) (*CustomerResponse, error)
 	GetByID(ctx context.Context, id string) (*CustomerResponse, error)
 	Search(ctx context.Context, form *SearchCustomersForm, pagination *response.Pagination) (*CustomerListResponse, error)
+	GetCustomersByIDs(ctx context.Context, ids []string) (*CustomerListResponse, error)
+	GetCustomersByRole(ctx context.Context, role string) (*CustomerListResponse, error)
+	GetCustomersByCompanies(ctx context.Context, companies []string) (*CustomerListResponse, error)
 	Update(ctx context.Context, id string, form *UpdateCustomerForm) (*CustomerResponse, error)
 	Delete(ctx context.Context, id string) error
 	UpdateStatus(ctx context.Context, id string, form *UpdateStatusForm) error
@@ -206,6 +209,65 @@ func (s *customerService) Search(ctx context.Context, form *SearchCustomersForm,
 	}, nil
 }
 
+// GetCustomersByIDs retrieves customers by IDs
+func (s *customerService) GetCustomersByIDs(ctx context.Context, ids []string) (*CustomerListResponse, error) {
+	customers, err := s.repository.GetByIDs(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+
+	var customerResponses []*CustomerResponse
+	for _, customer := range customers {
+		customerResponses = append(customerResponses, customer.ToResponse(nil))
+	}
+
+	return &CustomerListResponse{
+		Customers: customerResponses,
+	}, nil
+}
+
+// GetCustomersByRole retrieves customers by role
+func (s *customerService) GetCustomersByRole(ctx context.Context, role string) (*CustomerListResponse, error) {
+	customers, err := s.repository.GetByRole(ctx, CustomerRole(role))
+	if err != nil {
+		s.logger.Error("Failed to get customers by role", map[string]interface{}{
+			"error": err.Error(),
+			"role":  role,
+		})
+		return nil, err
+	}
+
+	var customerResponses []*CustomerResponse
+	for _, customer := range customers {
+		customerResponses = append(customerResponses, customer.ToResponse(nil))
+	}
+
+	return &CustomerListResponse{
+		Customers: customerResponses,
+	}, nil
+}
+
+// GetCustomersByCompanies retrieves customers by companies
+func (s *customerService) GetCustomersByCompanies(ctx context.Context, companies []string) (*CustomerListResponse, error) {
+	customers, err := s.repository.GetByCompanies(ctx, companies)
+	if err != nil {
+		s.logger.Error("Failed to get customers by companies", map[string]interface{}{
+			"error":     err.Error(),
+			"companies": companies,
+		})
+		return nil, err
+	}
+
+	var customerResponses []*CustomerResponse
+	for _, customer := range customers {
+		customerResponses = append(customerResponses, customer.ToResponse(nil))
+	}
+
+	return &CustomerListResponse{
+		Customers: customerResponses,
+	}, nil
+}
+
 // Update updates a customer
 func (s *customerService) Update(ctx context.Context, id string, form *UpdateCustomerForm) (*CustomerResponse, error) {
 	// Get existing customer

internal/notification/entity.go

@@ -1,11 +1,5 @@
 package notification
 
-import (
-	"tm/pkg/mongo"
-
-	"go.mongodb.org/mongo-driver/v2/bson"
-)
-
 // NotificationType represents the type of notification
 type NotificationType string
 
@@ -65,46 +59,8 @@ const (
 	TargetAudienceSpecificCustomer TargetAudienceType = "specific_customer"
 )
 
-// Notification represents a notification entity
-type Notification struct {
-	mongo.Model `bson:",inline"`
-	Recipient   []string             `bson:"recipients"`
-	Tender      bson.ObjectID        `bson:"tender"`
-	Channels    []DeliveryChannel    `bson:"channels"`
-	Type        NotificationType     `bson:"type"`
-	Priority    NotificationPriority `bson:"priority"`
-	Status      NotificationStatus   `bson:"status"`
-	Target      TargetAudienceType   `bson:"target"`
-	Title       string               `bson:"title"`
-	Description string               `bson:"description"`
-	Link        *string              `bson:"link"`
-	Schedule    Schedule             `bson:"schedule"`
-}
-
-type Schedule struct {
-	Time int64 `bson:"time"`
-}
-
-func (n *Notification) SetID(id string) {
-	n.ID, _ = bson.ObjectIDFromHex(id)
-}
-
-func (n *Notification) GetID() string {
-	return n.ID.Hex()
-}
-
-func (n *Notification) SetCreatedAt(timestamp int64) {
-	n.CreatedAt = timestamp
-}
-
-func (n *Notification) SetUpdatedAt(timestamp int64) {
-	n.UpdatedAt = timestamp
-}
-
-func (n *Notification) GetCreatedAt() int64 {
-	return n.CreatedAt
-}
-
-func (n *Notification) GetUpdatedAt() int64 {
-	return n.UpdatedAt
+type notificationRecipient struct {
+	UserID       string
+	Email        string
+	DeviceTokens []string
 }

internal/notification/form.go

@@ -1,70 +1,26 @@
 package notification
 
-import (
-	"tm/pkg/response"
-
-	"go.mongodb.org/mongo-driver/v2/bson"
-)
-
 // CreateRequest represents the request to create a notification
 type NotificationRequest struct {
-	Recipient   []string             `json:"recipient" valid:"required,stringlength(1|100)"`
-	Tender      bson.ObjectID        `json:"tender" valid:"optional,stringlength(1|100)"`
-	Channels    []DeliveryChannel    `json:"channels" valid:"required,minlength(1)"`
-	Type        NotificationType     `json:"type" valid:"required,notification_type"`
-	Priority    NotificationPriority `json:"priority" valid:"required,notification_priority"`
-	Target      TargetAudienceType   `json:"target" valid:"required,target_audience"`
-	Title       string               `json:"title" valid:"required,stringlength(1|200)"`
-	Description string               `json:"description" valid:"required,stringlength(1|1000)"`
+	Recipient   []string             `json:"recipient"`
+	Tender      string               `json:"tender" valid:"optional,stringlength(1|100)"`
+	Channels    []DeliveryChannel    `json:"channels" valid:"required"`
+	Type        NotificationType     `json:"type" valid:"required"`
+	Priority    NotificationPriority `json:"priority" valid:"required"`
+	Target      TargetAudienceType   `json:"target" valid:"required"`
+	Title       string               `json:"title" valid:"required"`
+	Description string               `json:"description" valid:"required"`
 	Link        *string              `json:"link" valid:"optional,url"`
-	Schedule    ScheduleRequest      `json:"schedule" valid:"optional"`
-}
-
-type ScheduleRequest struct {
-	Time int64 `json:"time" valid:"required,int64"`
-}
-
-// NotificationResponse represents the response after creating a notification
-type NotificationResponse struct {
-	ID          string               `json:"id"`
-	Tender      string               `json:"tender"`
-	Channels    []DeliveryChannel    `json:"channels"`
-	Type        NotificationType     `json:"type"`
-	Priority    NotificationPriority `json:"priority"`
-	Target      TargetAudienceType   `json:"target"`
-	Title       string               `json:"title"`
-	Description string               `json:"description"`
-	Link        string               `json:"link"`
-	Schedule    ScheduleResponse     `json:"schedule"`
-}
-
-type ScheduleResponse struct {
-	Time int64 `json:"time"`
-}
-
-type NotificationsResponse struct {
-	Notifications []*NotificationResponse `json:"notifications"`
-	Meta          *response.Meta          `json:"-"`
-}
-
-func (n *Notification) ToResponse() *NotificationResponse {
-	return &NotificationResponse{
-		ID:          n.ID.Hex(),
-		Tender:      n.Tender.Hex(),
-		Channels:    n.Channels,
-		Type:        n.Type,
-		Priority:    n.Priority,
-		Target:      n.Target,
-		Title:       n.Title,
-		Description: n.Description,
-		Link:        *n.Link,
-		Schedule: ScheduleResponse{
-			Time: n.Schedule.Time,
-		},
-	}
+	ScheduleAt  int64                `json:"schedule_at" valid:"optional"`
 }
 
 // SearchForm represents the form for searching notifications
 type SearchForm struct {
-	Search *string `query:"q" valid:"optional"`
+	Search *string            `query:"q" valid:"optional"`
+	Status NotificationStatus `query:"status" valid:"optional"`
+
+	SortBy    *string `query:"sort_by" valid:"optional"`
+	SortOrder *string `query:"sort_order" valid:"optional"`
+	Limit     *int    `query:"limit" valid:"optional"`
+	Offset    *int    `query:"offset" valid:"optional"`
 }

internal/notification/handler.go

@@ -10,12 +10,12 @@ import (
 
 // NotificationHandler handles HTTP requests for notification operations
 type NotificationHandler struct {
-	service NotificationService
+	service Service
 	logger  logger.Logger
 }
 
 // NewNotificationHandler creates a new notification handler
-func NewHandler(service NotificationService, logger logger.Logger) *NotificationHandler {
+func NewHandler(service Service, logger logger.Logger) *NotificationHandler {
 	return &NotificationHandler{
 		service: service,
 		logger:  logger,
@@ -33,7 +33,7 @@ func NewHandler(service NotificationService, logger logger.Logger) *Notification
 // @Failure 400 {object} response.APIResponse
 // @Failure 500 {object} response.APIResponse
 // @Router /admin/v1/notifications [post]
-func (h *NotificationHandler) Create(c echo.Context) error {
+func (h *NotificationHandler) Send(c echo.Context) error {
 	var req NotificationRequest
 	if err := c.Bind(&req); err != nil {
 		return response.BadRequest(c, "Invalid request format", err.Error())
@@ -44,145 +44,10 @@ func (h *NotificationHandler) Create(c echo.Context) error {
 		return response.ValidationError(c, "Validation failed", err.Error())
 	}
 
-	// Create notification
-	resp, err := h.service.Create(c.Request().Context(), &req)
-	if err != nil {
-		return response.InternalServerError(c, "Failed to create notification")
+	// Send notification
+	if err := h.service.Send(c.Request().Context(), &req); err != nil {
+		return response.InternalServerError(c, "Failed to send notification")
 	}
 
-	return response.Created(c, resp, "Notification created successfully")
-}
-
-// UpdateNotification updates a notification
-// @Summary Update notification
-// @Description Update an existing notification
-// @Tags Admin-Notification
-// @Accept json
-// @Produce json
-// @Param id path string true "Notification ID"
-// @Param notification body NotificationRequest true "Updated notification information"
-// @Success 200 {object} response.APIResponse "Notification updated successfully"
-// @Failure 400 {object} response.APIResponse
-// @Failure 404 {object} response.APIResponse
-// @Failure 500 {object} response.APIResponse
-// @Router /admin/v1/notifications/{id} [put]
-func (h *NotificationHandler) UpdateNotification(c echo.Context) error {
-	id := c.Param("id")
-	if id == "" {
-		return response.BadRequest(c, "Notification ID is required", "")
-	}
-
-	var req NotificationRequest
-	if err := c.Bind(&req); err != nil {
-		return response.BadRequest(c, "Invalid request format", err.Error())
-	}
-
-	// Update notification
-	_, err := h.service.Update(c.Request().Context(), id, &req)
-	if err != nil {
-		if err.Error() == "notification not found" {
-			return response.NotFound(c, "Notification not found")
-		}
-		return response.BadRequest(c, "Failed to update notification", err.Error())
-	}
-
-	return response.Success(c, nil, "Notification updated successfully")
-}
-
-// GetNotifications retrieves notifications for a user
-// @Summary Get user notifications
-// @Description Retrieve notifications for a specific user with filtering and pagination
-// @Tags Admin-Notification
-// @Accept json
-// @Produce json
-// @Param recipient query string true "Recipient"
-// @Param type query string false "Notification type (info, warning, alert, reject)"
-// @Param priority query string false "Notification priority (low, medium, important)"
-// @Param status query string false "Delivery status (pending, sent, failed)"
-// @Param is_read query bool false "Read status"
-// @Param page query int false "Page number" default(1)
-// @Param limit query int false "Items per page" default(20)
-// @Param sort_by query string false "Sort field" default(created_at)
-// @Param sort_order query string false "Sort order (asc, desc)" default(desc)
-// @Success 200 {object} response.APIResponse{data=NotificationsResponse}
-// @Failure 400 {object} response.APIResponse
-// @Failure 500 {object} response.APIResponse
-// @Router /admin/v1/notifications [get]
-func (h *NotificationHandler) Search(c echo.Context) error {
-	req, err := response.Parse[SearchForm](c)
-	if err != nil {
-		return response.ValidationError(c, "Invalid request data", err.Error())
-	}
-
-	pagination := response.NewPagination(c)
-
-	// Validate request
-	if valid, err := govalidator.ValidateStruct(req); !valid {
-		return response.ValidationError(c, "Validation failed", err.Error())
-	}
-
-	// Get notifications
-	resp, err := h.service.Search(c.Request().Context(), req, pagination)
-	if err != nil {
-		return response.InternalServerError(c, "Failed to get notifications")
-	}
-
-	return response.Success(c, resp, "Notifications retrieved successfully")
-}
-
-// Get retrieves a notification by ID
-// @Summary Get notification by ID
-// @Description Retrieve a specific notification by its ID
-// @Tags Admin-Notification
-// @Accept json
-// @Produce json
-// @Param id path string true "Notification ID"
-// @Success 200 {object} response.APIResponse{data=NotificationResponse}
-// @Failure 400 {object} response.APIResponse
-// @Failure 404 {object} response.APIResponse
-// @Failure 500 {object} response.APIResponse
-// @Router /admin/v1/notifications/{id} [get]
-func (h *NotificationHandler) Get(c echo.Context) error {
-	id := c.Param("id")
-	if id == "" {
-		return response.BadRequest(c, "Notification ID is required", "")
-	}
-
-	// Get notification
-	resp, err := h.service.Get(c.Request().Context(), id)
-	if err != nil {
-		if err.Error() == "notification not found" {
-			return response.NotFound(c, "Notification not found")
-		}
-		return response.InternalServerError(c, "Failed to get notification")
-	}
-
-	return response.Success(c, resp, "Notification retrieved successfully")
-}
-
-// DeleteNotification deletes a notification
-// @Summary Delete notification
-// @Description Delete a specific notification
-// @Tags Admin-Notification
-// @Accept json
-// @Produce json
-// @Param id path string true "Notification ID"
-// @Success 200 {object} response.APIResponse "Notification deleted successfully"
-// @Failure 400 {object} response.APIResponse
-// @Failure 404 {object} response.APIResponse
-// @Failure 500 {object} response.APIResponse
-// @Router /admin/v1/notifications/{id} [delete]
-func (h *NotificationHandler) DeleteNotification(c echo.Context) error {
-	id := c.Param("id")
-	if id == "" {
-		return response.BadRequest(c, "Notification ID is required", "")
-	}
-
-	// Delete notification
-	err := h.service.Delete(c.Request().Context(), id)
-	if err != nil {
-		return response.InternalServerError(c, "Failed to delete notification")
-	}
-
-	return response.Success(c, nil, "Notification deleted successfully")
+	return response.Created(c, nil, "Notification sent successfully")
 }

internal/notification/repository.go

@@ -1,103 +0,0 @@
-package notification
-
-import (
-	"context"
-	"time"
-
-	"tm/pkg/logger"
-	orm "tm/pkg/mongo"
-	"tm/pkg/response"
-
-	"go.mongodb.org/mongo-driver/v2/bson"
-)
-
-// NotificationRepository defines the interface for notification data operations
-type NotificationRepository interface {
-	Create(ctx context.Context, notification *Notification) error
-	Update(ctx context.Context, notification *Notification) error
-	Get(ctx context.Context, id string) (*Notification, error)
-	Search(ctx context.Context, form *SearchForm, pagination *response.Pagination) ([]Notification, int64, error)
-	Delete(ctx context.Context, id string) error
-}
-
-// notificationRepository implements NotificationRepository interface
-type notificationRepository struct {
-	ormRepo orm.Repository[Notification]
-	logger  logger.Logger
-}
-
-func collection() string {
-	return "notifications"
-}
-
-// NewNotificationRepository creates a new notification repository
-func NewNotificationRepository(mongoManager *orm.ConnectionManager, logger logger.Logger) NotificationRepository {
-	// Create indexes using the ORM's index management
-	indexes := []orm.Index{
-		*orm.CreateTextIndex("search_idx", "title", "description"),
-	}
-
-	// Create indexes
-	err := mongoManager.CreateIndexes(collection(), indexes)
-	if err != nil {
-		logger.Warn("Failed to create customer indexes", map[string]interface{}{
-			"error": err.Error(),
-		})
-	}
-
-	ormRepo := orm.NewRepository[Notification](mongoManager.GetCollection(collection()), logger)
-
-	return &notificationRepository{
-		ormRepo: ormRepo,
-		logger:  logger,
-	}
-}
-
-// Create creates a new notification
-func (r *notificationRepository) Create(ctx context.Context, notification *Notification) error {
-	notification.SetCreatedAt(time.Now().Unix())
-	return r.ormRepo.Create(ctx, notification)
-}
-
-// Create creates a new notification
-func (r *notificationRepository) Update(ctx context.Context, notification *Notification) error {
-	notification.SetUpdatedAt(time.Now().Unix())
-	return r.ormRepo.Update(ctx, notification)
-}
-
-// Get gets a notification by id
-func (r *notificationRepository) Get(ctx context.Context, id string) (*Notification, error) {
-	return r.ormRepo.FindByID(ctx, id)
-}
-
-// Search searches for notifications
-func (r *notificationRepository) Search(ctx context.Context, form *SearchForm, pagination *response.Pagination) ([]Notification, int64, error) {
-	// Build pagination
-	paginationBuilder := orm.NewPaginationBuilder().
-		Limit(pagination.Limit).
-		Skip(pagination.Offset).
-		SortBy(pagination.SortBy, pagination.SortOrder)
-
-	filter := bson.M{}
-
-	if form.Search != nil {
-		filter["$text"] = bson.M{"$search": *form.Search}
-	}
-
-	// Use ORM to find customers
-	result, err := r.ormRepo.FindAll(ctx, filter, paginationBuilder.Build())
-	if err != nil {
-		r.logger.Error("Failed to search customers", map[string]interface{}{
-			"error":  err.Error(),
-			"search": form.Search,
-		})
-		return nil, 0, err
-	}
-
-	return result.Items, result.TotalCount, nil
-}
-
-// Delete deletes a notification
-func (r *notificationRepository) Delete(ctx context.Context, id string) error {
-	return r.ormRepo.Delete(ctx, id)
-}

internal/notification/service.go

@@ -3,197 +3,242 @@ package notification
 import (
 	"context"
 	"errors"
-	"fmt"
 
+	"tm/internal/customer"
+	"tm/internal/user"
 	"tm/pkg/logger"
+	"tm/pkg/notification"
 	"tm/pkg/response"
 )
 
 // NotificationService defines the interface for notification business logic
-type NotificationService interface {
-	Create(ctx context.Context, req *NotificationRequest) (*NotificationResponse, error)
-	Update(ctx context.Context, id string, req *NotificationRequest) (*NotificationResponse, error)
-	Get(ctx context.Context, id string) (*NotificationResponse, error)
-	Search(ctx context.Context, req *SearchForm, pagination *response.Pagination) (*NotificationsResponse, error)
-	Delete(ctx context.Context, id string) error
+type Service interface {
+	Send(ctx context.Context, req *NotificationRequest) error
+	getUsers(ctx context.Context, userIDs []string) ([]notificationRecipient, error)
+	getCustomers(ctx context.Context, values []string, target string) ([]notificationRecipient, error)
 }
 
 // notificationService implements NotificationService interface
 type notificationService struct {
-	repository NotificationRepository
-	logger     logger.Logger
+	sdk             notification.SDK
+	userService     user.Service
+	customerService customer.Service
+	logger          logger.Logger
 }
 
 // NewNotificationService creates a new notification service
 func NewNotificationService(
-	repository NotificationRepository,
+	sdk notification.SDK,
+	userService user.Service,
+	customerService customer.Service,
 	logger logger.Logger,
-) NotificationService {
+) Service {
 	return &notificationService{
-		repository: repository,
-		logger:     logger,
+		sdk:             sdk,
+		userService:     userService,
+		customerService: customerService,
+		logger:          logger,
 	}
 }
 
-// Create creates a single notification
-func (s *notificationService) Create(ctx context.Context, req *NotificationRequest) (*NotificationResponse, error) {
-	s.logger.Info("Creating notification", map[string]interface{}{
+// Send sends a multiple notification
+func (s *notificationService) Send(ctx context.Context, req *NotificationRequest) error {
+	s.logger.Info("Sending notification", map[string]interface{}{
 		"recipient": req.Recipient,
 		"type":      req.Type,
 		"priority":  req.Priority,
 	})
 
-	// Create notification entity
-	notification := &Notification{
-		Recipient:   req.Recipient,
-		Tender:      req.Tender,
-		Channels:    req.Channels,
-		Type:        req.Type,
-		Priority:    req.Priority,
-		Title:       req.Title,
-		Description: req.Description,
-		Link:        req.Link,
-		Status:      DeliveryStatusPending,
-		Schedule: Schedule{
-			Time: req.Schedule.Time,
-		},
-	}
+	if req.Target == TargetAudienceAllUsers || req.Target == TargetAudienceSpecificUsers {
+		recipients, err := s.getUsers(ctx, req.Recipient)
+		if err != nil {
+			return err
+		}
+		for _, recipient := range recipients {
+			for _, v := range recipient.DeviceTokens {
+				s.sdk.SendNotification(ctx, &notification.NotificationRequest{
+					UserID:    recipient.UserID,
+					Title:     req.Title,
+					Message:   req.Description,
+					Type:      string(req.Type),
+					Priority:  string(req.Priority),
+					EventType: notification.EventTypePush,
+					Metadata: map[string]any{
+						"tender": req.Tender,
+					},
+					Methods: notification.NotificationMethods{
+						Push: v,
+					},
 
-	// Create notification in repository
-	if err := s.repository.Create(ctx, notification); err != nil {
-		s.logger.Error("Failed to create notification", map[string]interface{}{
+					ScheduledAt: req.ScheduleAt,
+				})
+			}
+
+			if recipient.Email != "" {
+				s.sdk.SendNotification(ctx, &notification.NotificationRequest{
+					UserID:    recipient.UserID,
+					Title:     req.Title,
+					Message:   req.Description,
+					Type:      string(req.Type),
+					Priority:  string(req.Priority),
+					EventType: notification.EventTypeEmail,
+					Metadata: map[string]any{
+						"tender": req.Tender,
+					},
+					Methods: notification.NotificationMethods{
+						Email: recipient.Email,
+					},
+					ScheduledAt: req.ScheduleAt,
+				})
+			}
+		}
+	} else {
+		recipients, err := s.getCustomers(ctx, req.Recipient, string(req.Target))
+		if err != nil {
+			return err
+		}
+		for _, recipient := range recipients {
+			for _, v := range recipient.DeviceTokens {
+				s.sdk.SendNotification(ctx, &notification.NotificationRequest{
+					UserID:    recipient.UserID,
+					Title:     req.Title,
+					Message:   req.Description,
+					Type:      string(req.Type),
+					Priority:  string(req.Priority),
+					EventType: notification.EventTypePush,
+					Methods: notification.NotificationMethods{
+						Push: v,
+					},
+					ScheduledAt: req.ScheduleAt,
+				})
+			}
+
+			if recipient.Email != "" {
+				s.sdk.SendNotification(ctx, &notification.NotificationRequest{
+					UserID:    recipient.UserID,
+					Title:     req.Title,
+					Message:   req.Description,
+					Type:      string(req.Type),
+					Priority:  string(req.Priority),
+					EventType: notification.EventTypeEmail,
+					Methods: notification.NotificationMethods{
+						Email: recipient.Email,
+					},
+					ScheduledAt: req.ScheduleAt,
+				})
+			}
+		}
+		s.logger.Info("Notification sent", map[string]interface{}{
 			"recipient": req.Recipient,
-			"error":     err.Error(),
+			"channels":  req.Channels,
 		})
-		return nil, fmt.Errorf("failed to create notification")
+
+		return nil
 	}
-
-	s.logger.Info("Notification created", map[string]interface{}{
-		"notification_id": notification.ID,
-		"recipient":       req.Recipient,
-		"channels":        req.Channels,
-	})
-
-	return notification.ToResponse(), nil
-}
-
-// Update updates a notification
-func (s *notificationService) Update(ctx context.Context, id string, req *NotificationRequest) (*NotificationResponse, error) {
-	s.logger.Info("Updating notification", map[string]interface{}{
-		"notification_id": id,
-	})
-
-	notification, err := s.repository.Get(ctx, id)
-	if err != nil {
-		s.logger.Error("Failed to get notification", map[string]interface{}{
-			"notification_id": id,
-			"error":           err.Error(),
-		})
-		return nil, fmt.Errorf("failed to get notification")
-	}
-
-	if notification.Status == DeliveryStatusSent {
-		return nil, fmt.Errorf("notification already sent")
-	}
-
-	// update notification fields
-	notification.Recipient = req.Recipient
-	notification.Tender = req.Tender
-	notification.Channels = req.Channels
-	notification.Type = req.Type
-	notification.Priority = req.Priority
-	notification.Title = req.Title
-	notification.Description = req.Description
-	notification.Link = req.Link
-	notification.Schedule = Schedule{
-		Time: req.Schedule.Time,
-	}
-	notification.Status = DeliveryStatusPending
-
-	// update notification in repository
-	if err := s.repository.Update(ctx, notification); err != nil {
-		s.logger.Error("Failed to update notification", map[string]interface{}{
-			"notification_id": id,
-			"error":           err.Error(),
-		})
-		return nil, fmt.Errorf("failed to update notification")
-	}
-
-	s.logger.Info("Notification updated", map[string]interface{}{
-		"notification_id": id,
-		"recipient":       req.Recipient,
-		"channels":        req.Channels,
-	})
-
-	return notification.ToResponse(), nil
-}
-
-// Get gets a notification
-func (s *notificationService) Get(ctx context.Context, id string) (*NotificationResponse, error) {
-	s.logger.Info("Getting notification", map[string]interface{}{
-		"notification_id": id,
-	})
-
-	notification, err := s.repository.Get(ctx, id)
-	if err != nil {
-		s.logger.Error("Failed to get notification", map[string]interface{}{
-			"notification_id": id,
-			"error":           err.Error(),
-		})
-		return nil, fmt.Errorf("failed to get notification")
-	}
-
-	return notification.ToResponse(), nil
-}
-
-// Search searches for notifications
-func (s *notificationService) Search(ctx context.Context, req *SearchForm, pagination *response.Pagination) (*NotificationsResponse, error) {
-	notifications, total, err := s.repository.Search(ctx, req, pagination)
-	if err != nil {
-		s.logger.Error("Failed to search notifications", map[string]interface{}{
-			"error": err.Error(),
-		})
-		return nil, errors.New("failed to search notifications")
-	}
-
-	var notificationResponses []*NotificationResponse
-	for _, notification := range notifications {
-		notificationResponses = append(notificationResponses, notification.ToResponse())
-	}
-
-	return &NotificationsResponse{
-		Notifications: notificationResponses,
-		Meta:          pagination.Response(total),
-	}, nil
-}
-
-// Delete deletes a notification
-func (s *notificationService) Delete(ctx context.Context, id string) error {
-	s.logger.Info("Deleting notification", map[string]interface{}{
-		"notification_id": id,
-	})
-
-	notification, err := s.repository.Get(ctx, id)
-	if err != nil {
-		s.logger.Error("Failed to get notification", map[string]interface{}{
-			"notification_id": id,
-			"error":           err.Error(),
-		})
-		return fmt.Errorf("failed to get notification")
-	}
-
-	if notification.Status == DeliveryStatusSent {
-		return fmt.Errorf("notification already sent")
-	}
-
-	err = s.repository.Delete(ctx, id)
-	if err != nil {
-		s.logger.Error("Failed to delete notification", map[string]interface{}{
-			"notification_id": id,
-			"error":           err.Error(),
-		})
-		return err
-	}
-
 	return nil
 }
+
+func (s *notificationService) getUsers(ctx context.Context, userIDs []string) ([]notificationRecipient, error) {
+	recipients := make([]notificationRecipient, 0)
+	offset := 0
+	for {
+		var users *user.UserListResponse
+		var err error
+		if len(userIDs) > 0 {
+			users, err = s.userService.GetUsersByIDs(ctx, userIDs)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			users, err = s.userService.Search(ctx, &user.SearchUsersForm{}, &response.Pagination{Limit: 100, Offset: offset})
+			if err != nil {
+				return nil, err
+			}
+			offset += 100
+			if len(users.Users) == 0 {
+				break
+			}
+		}
+
+		for _, user := range users.Users {
+			recipients = append(recipients, notificationRecipient{
+				UserID:       user.ID,
+				Email:        user.Email,
+				DeviceTokens: user.DeviceToken,
+			})
+		}
+
+		if len(recipients) == 0 {
+			return nil, errors.New("no users found")
+		}
+	}
+
+	return recipients, nil
+}
+
+func (s *notificationService) getCustomers(ctx context.Context, values []string, target string) ([]notificationRecipient, error) {
+	recipients := make([]notificationRecipient, 0)
+
+	if target == string(TargetAudienceSpecificRole) {
+		customers, err := s.customerService.GetCustomersByRole(ctx, values[0])
+		if err != nil {
+			return nil, err
+		}
+		for _, customer := range customers.Customers {
+			recipients = append(recipients, notificationRecipient{
+				UserID:       customer.ID,
+				Email:        customer.Email,
+				DeviceTokens: customer.DeviceToken,
+			})
+		}
+	} else if target == string(TargetAudienceSpecificCompany) {
+		customers, err := s.customerService.GetCustomersByCompanies(ctx, values)
+		if err != nil {
+			return nil, err
+		}
+		for _, customer := range customers.Customers {
+			recipients = append(recipients, notificationRecipient{
+				UserID:       customer.ID,
+				Email:        customer.Email,
+				DeviceTokens: customer.DeviceToken,
+			})
+		}
+	} else if target == string(TargetAudienceSpecificCustomer) {
+		customers, err := s.customerService.GetCustomersByIDs(ctx, values)
+		if err != nil {
+			return nil, err
+		}
+		for _, customer := range customers.Customers {
+			recipients = append(recipients, notificationRecipient{
+				UserID:       customer.ID,
+				Email:        customer.Email,
+				DeviceTokens: customer.DeviceToken,
+			})
+		}
+	} else {
+		offset := 0
+		for {
+			customers, err := s.customerService.Search(ctx, &customer.SearchCustomersForm{}, &response.Pagination{Limit: 100, Offset: offset})
+			if err != nil {
+				return nil, err
+			}
+			for _, customer := range customers.Customers {
+				recipients = append(recipients, notificationRecipient{
+					UserID:       customer.ID,
+					Email:        customer.Email,
+					DeviceTokens: customer.DeviceToken,
+				})
+			}
+			offset += 100
+			if len(customers.Customers) == 0 {
+				break
+			}
+		}
+	}
+
+	if len(recipients) == 0 {
+		return nil, errors.New("no customers found")
+	}
+
+	return recipients, nil
+}

internal/user/form.go

@@ -85,20 +85,21 @@ type UpdateUserRoleForm struct {
 
 // Response DTOs
 type UserResponse struct {
-	ID           string  `json:"id"`
-	FullName     string  `json:"full_name"`
-	Username     string  `json:"username"`
-	Email        string  `json:"email"`
-	Role         string  `json:"role"`
-	Status       string  `json:"status"`
-	Department   *string `json:"department"`
-	Position     *string `json:"position"`
-	Phone        *string `json:"phone"`
-	ProfileImage *string `json:"profile_image"`
-	IsVerified   bool    `json:"is_verified"`
-	LastLoginAt  *int64  `json:"last_login_at"`
-	UpdatedAt    int64   `json:"updated_at"`
-	CreatedAt    int64   `json:"created_at"`
+	ID           string   `json:"id"`
+	FullName     string   `json:"full_name"`
+	Username     string   `json:"username"`
+	Email        string   `json:"email"`
+	Role         string   `json:"role"`
+	Status       string   `json:"status"`
+	Department   *string  `json:"department"`
+	Position     *string  `json:"position"`
+	Phone        *string  `json:"phone"`
+	ProfileImage *string  `json:"profile_image"`
+	IsVerified   bool     `json:"is_verified"`
+	LastLoginAt  *int64   `json:"last_login_at"`
+	UpdatedAt    int64    `json:"updated_at"`
+	CreatedAt    int64    `json:"created_at"`
+	DeviceToken  []string `json:"-"`
 }
 
 type AuthResponse struct {

internal/user/repository.go

@@ -20,6 +20,7 @@ type Repository interface {
 	GetByID(ctx context.Context, id string) (*User, error)
 	GetByEmail(ctx context.Context, email string) (*User, error)
 	GetByUsername(ctx context.Context, username string) (*User, error)
+	GetByIDs(ctx context.Context, userIDs []string) ([]User, error)
 	Search(ctx context.Context, form *SearchUsersForm, pagination *response.Pagination) ([]User, int64, error)
 }
 
@@ -215,6 +216,16 @@ func (r *userRepository) Delete(ctx context.Context, id string) error {
 	return nil
 }
 
+// GetByIDs retrieves users by IDs
+func (r *userRepository) GetByIDs(ctx context.Context, userIDs []string) ([]User, error) {
+	users, err := r.ormRepo.FindAll(ctx, bson.M{"_id": bson.M{"$in": userIDs}}, orm.NewPaginationBuilder().Limit(len(userIDs)).Build())
+	if err != nil {
+		return nil, err
+	}
+
+	return users.Items, nil
+}
+
 // List retrieves users with pagination
 func (r *userRepository) Search(ctx context.Context, form *SearchUsersForm, pagination *response.Pagination) ([]User, int64, error) {
 	filter := bson.M{}

internal/user/service.go

@@ -23,6 +23,7 @@ type Service interface {
 	Update(ctx context.Context, id string, form *UpdateUserForm) (*UserResponse, error)
 	UpdateStatus(ctx context.Context, id string, form *UpdateUserStatusForm) error
 	GetUserByID(ctx context.Context, userID string) (*UserResponse, error)
+	GetUsersByIDs(ctx context.Context, userIDs []string) (*UserListResponse, error)
 	Search(ctx context.Context, form *SearchUsersForm, pagination *response.Pagination) (*UserListResponse, error)
 	Delete(ctx context.Context, id string) error
 
@@ -250,6 +251,23 @@ func (s *userService) GetUserByID(ctx context.Context, id string) (*UserResponse
 	return user.ToResponse(), nil
 }
 
+// GetUsersByIDs retrieves users by IDs
+func (s *userService) GetUsersByIDs(ctx context.Context, userIDs []string) (*UserListResponse, error) {
+	users, err := s.repository.GetByIDs(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	var userResponses []*UserResponse
+	for _, user := range users {
+		userResponses = append(userResponses, user.ToResponse())
+	}
+
+	return &UserListResponse{
+		Users: userResponses,
+	}, nil
+}
+
 // Search searches users with search and filters
 func (s *userService) Search(ctx context.Context, form *SearchUsersForm, pagination *response.Pagination) (*UserListResponse, error) {
 	// Get users