On branch main

modified:   main_dc/yalarba/api_yal/internal/domain/feetback/dto.go
	modified:   main_dc/yalarba/api_yal/internal/domain/feetback/handler.go
	modified:   main_dc/yalarba/api_yal/internal/domain/feetback/router.go
	modified:   main_dc/yalarba/api_yal/internal/domain/feetback/service.go
feedback domain is almost ready

main_dc/yalarba/api_yal/internal/domain/feetback/dto.go

@@ -3,4 +3,3 @@ package feetback
 import (
 
 )
-

main_dc/yalarba/api_yal/internal/domain/feetback/handler.go

@@ -0,0 +1,318 @@
+package feetback
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"api_yal/internal/logger"
+	"api_yal/internal/models"
+
+	"github.com/go-chi/chi/v5"
+	"go.uber.org/zap"
+)
+
+type FeedbackHandler struct {
+	service FeedbackService
+}
+
+func NewFeedbackHandler(service FeedbackService) *FeedbackHandler {
+	return &FeedbackHandler{
+		service: service,
+	}
+}
+
+// CreateFeedback создает новый отзыв
+func (h *FeedbackHandler) CreateFeedback(w http.ResponseWriter, r *http.Request) {
+	var feedback models.Feedback
+	if err := json.NewDecoder(r.Body).Decode(&feedback); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.service.Create(r.Context(), &feedback); err != nil {
+		logger.Get().Error("Failed to create feedback", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(feedback)
+}
+
+// GetFeedbackByID возвращает отзыв по ID
+func (h *FeedbackHandler) GetFeedbackByID(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid ID", http.StatusBadRequest)
+		return
+	}
+
+	feedback, err := h.service.GetByID(r.Context(), uint(id))
+	if err != nil {
+		logger.Get().Error("Failed to get feedback", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedback)
+}
+
+// UpdateFeedback обновляет существующий отзыв
+func (h *FeedbackHandler) UpdateFeedback(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid ID", http.StatusBadRequest)
+		return
+	}
+
+	var feedback models.Feedback
+	if err := json.NewDecoder(r.Body).Decode(&feedback); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+	feedback.ID = uint(id)
+
+	if err := h.service.Update(r.Context(), &feedback); err != nil {
+		logger.Get().Error("Failed to update feedback", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedback)
+}
+
+// DeleteFeedback удаляет отзыв
+func (h *FeedbackHandler) DeleteFeedback(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid ID", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.service.Delete(r.Context(), uint(id)); err != nil {
+		logger.Get().Error("Failed to delete feedback", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// ListFeedbacks возвращает список отзывов с пагинацией
+func (h *FeedbackHandler) ListFeedbacks(w http.ResponseWriter, r *http.Request) {
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+	
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 {
+		pageSize = 10
+	}
+	if pageSize > 100 {
+		pageSize = 100
+	}
+
+	feedbacks, total, err := h.service.List(r.Context(), page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to list feedbacks", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("X-Total-Count", strconv.FormatInt(total, 10))
+	json.NewEncoder(w).Encode(feedbacks)
+}
+
+// GetMyFeedbacks возвращает отзывы текущего пользователя
+func (h *FeedbackHandler) GetMyFeedbacks(w http.ResponseWriter, r *http.Request) {
+	// Здесь нужно получить ownerID из JWT токена
+	// Для примера используем заглушку
+	ownerID := uint(1) // TODO: Get from context
+	
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+	
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 {
+		pageSize = 10
+	}
+
+	feedbacks, err := h.service.ListByOwner(r.Context(), ownerID, page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to get user feedbacks", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedbacks)
+}
+
+// GetFeedbacksByObject возвращает отзывы по объекту
+func (h *FeedbackHandler) GetFeedbacksByObject(w http.ResponseWriter, r *http.Request) {
+	objectIDStr := chi.URLParam(r, "objectID")
+	objectID, err := strconv.ParseUint(objectIDStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid object ID", http.StatusBadRequest)
+		return
+	}
+
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+
+	feedbacks, err := h.service.ListByObject(r.Context(), uint(objectID), page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to get object feedbacks", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedbacks)
+}
+
+// GetFeedbacksByPlatform возвращает отзывы по платформе
+func (h *FeedbackHandler) GetFeedbacksByPlatform(w http.ResponseWriter, r *http.Request) {
+	platformStr := chi.URLParam(r, "platform")
+	platform := models.PlatformType(platformStr)
+
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+
+	feedbacks, err := h.service.ListByPlatform(r.Context(), platform, page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to get platform feedbacks", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedbacks)
+}
+
+// SearchFeedbacks ищет отзывы по тексту
+func (h *FeedbackHandler) SearchFeedbacks(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("q")
+	if query == "" {
+		http.Error(w, "Search query is required", http.StatusBadRequest)
+		return
+	}
+
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+
+	feedbacks, err := h.service.Search(r.Context(), query, page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to search feedbacks", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(feedbacks)
+}
+
+// GetFeedbackComments возвращает комментарии к отзыву
+func (h *FeedbackHandler) GetFeedbackComments(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid ID", http.StatusBadRequest)
+		return
+	}
+
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+
+	comments, err := h.service.GetComments(r.Context(), uint(id), page, pageSize)
+	if err != nil {
+		logger.Get().Error("Failed to get comments", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(comments)
+}
+
+// AddComment добавляет комментарий к отзыву
+func (h *FeedbackHandler) AddComment(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid ID", http.StatusBadRequest)
+		return
+	}
+
+	var comment models.Comment
+	if err := json.NewDecoder(r.Body).Decode(&comment); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.service.AddComment(r.Context(), uint(id), &comment); err != nil {
+		logger.Get().Error("Failed to add comment", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(comment)
+}
+
+// UpdateComment обновляет комментарий
+func (h *FeedbackHandler) UpdateComment(w http.ResponseWriter, r *http.Request) {
+	commentIDStr := chi.URLParam(r, "commentID")
+	commentID, err := strconv.ParseUint(commentIDStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid comment ID", http.StatusBadRequest)
+		return
+	}
+
+	var req struct {
+		Text string `json:"text"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.service.UpdateComment(r.Context(), uint(commentID), req.Text); err != nil {
+		logger.Get().Error("Failed to update comment", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]string{"message": "Comment updated successfully"})
+}
+
+// DeleteComment удаляет комментарий
+func (h *FeedbackHandler) DeleteComment(w http.ResponseWriter, r *http.Request) {
+	commentIDStr := chi.URLParam(r, "commentID")
+	commentID, err := strconv.ParseUint(commentIDStr, 10, 32)
+	if err != nil {
+		http.Error(w, "Invalid comment ID", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.service.DeleteComment(r.Context(), uint(commentID)); err != nil {
+		logger.Get().Error("Failed to delete comment", zap.Error(err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}

main_dc/yalarba/api_yal/internal/domain/feetback/router.go

@@ -2,15 +2,51 @@ package feetback
 
 import (
 	"api_yal/internal/logger"
+	"api_yal/internal/middleware"
+	"api_yal/internal/repository"
 
 	"github.com/go-chi/chi/v5"
 	"gorm.io/gorm"
 )
 
-func RegisterRoutes(r chi.Router, db *gorm, jwtSecret string) {
+func RegisterRoutes(r chi.Router, db *gorm.DB, jwtSecret string) {
 	l := logger.Get()
 	l.Info("Registering routes for feetback")
 
+	feedbackRepo := repository.NewFeedbackRepository(db)
+	feedbackService := NewFeedbackServiceImpl(feedbackRepo)
+	feedbackHandler := NewFeedbackHandler(feedbackService)
 
+	// Группируем маршруты для отзывов
+	r.Route("/feedbacks", func(r chi.Router) {
+		// Публичные маршруты (не требуют аутентификации)
+		r.Get("/", feedbackHandler.ListFeedbacks)           // GET /api/v1/feedbacks
+		r.Get("/search", feedbackHandler.SearchFeedbacks)   // GET /api/v1/feedbacks/search?q=query
+		r.Get("/{id}", feedbackHandler.GetFeedbackByID)     // GET /api/v1/feedbacks/{id}
 		
+		// Маршруты для фильтрации
+		r.Get("/object/{objectID}", feedbackHandler.GetFeedbacksByObject)     // GET /api/v1/feedbacks/object/{objectID}
+		r.Get("/platform/{platform}", feedbackHandler.GetFeedbacksByPlatform) // GET /api/v1/feedbacks/platform/{platform}
+		
+		// Маршруты для комментариев (публичные)
+		r.Get("/{id}/comments", feedbackHandler.GetFeedbackComments) // GET /api/v1/feedbacks/{id}/comments
+		
+		// Защищенные маршруты (требуют аутентификации)
+		r.Group(func(r chi.Router) {
+			// Здесь можно добавить middleware для проверки JWT токена
+			r.Use(middleware.AuthMiddleware(jwtSecret))
+			
+			r.Post("/", feedbackHandler.CreateFeedback)          // POST /api/v1/feedbacks
+			r.Put("/{id}", feedbackHandler.UpdateFeedback)       // PUT /api/v1/feedbacks/{id}
+			r.Delete("/{id}", feedbackHandler.DeleteFeedback)    // DELETE /api/v1/feedbacks/{id}
+			
+			// Маршруты для комментариев (требуют аутентификации)
+			r.Post("/{id}/comments", feedbackHandler.AddComment)           // POST /api/v1/feedbacks/{id}/comments
+			r.Put("/{id}/comments/{commentID}", feedbackHandler.UpdateComment)   // PUT /api/v1/feedbacks/{id}/comments/{commentID}
+			r.Delete("/{id}/comments/{commentID}", feedbackHandler.DeleteComment) // DELETE /api/v1/feedbacks/{id}/comments/{commentID}
+			
+			// Маршруты для владельца (получение своих отзывов)
+			r.Get("/my", feedbackHandler.GetMyFeedbacks) // GET /api/v1/feedbacks/my
+		})
+	})
 }

main_dc/yalarba/api_yal/internal/domain/feetback/service.go

@@ -0,0 +1,376 @@
+package feetback
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"api_yal/internal/models"
+	"api_yal/internal/repository"
+
+	"gorm.io/gorm"
+)
+
+type FeedbackService interface {
+	Create(ctx context.Context, feedback *models.Feedback) error
+	GetByID(ctx context.Context, id uint) (*models.Feedback, error)
+	Update(ctx context.Context, feedback *models.Feedback) error
+	Delete(ctx context.Context, id uint) error
+	List(ctx context.Context, page, pageSize int) ([]models.Feedback, int64, error)
+	ListByOwner(ctx context.Context, ownerID uint, page, pageSize int) ([]models.Feedback, error)
+	ListByObject(ctx context.Context, objectID uint, page, pageSize int) ([]models.Feedback, error)
+	ListByPlatform(ctx context.Context, platform models.PlatformType, page, pageSize int) ([]models.Feedback, error)
+	Search(ctx context.Context, query string, page, pageSize int) ([]models.Feedback, error)
+	
+	// Comment methods
+	AddComment(ctx context.Context, feedbackID uint, comment *models.Comment) error
+	GetComments(ctx context.Context, feedbackID uint, page, pageSize int) ([]models.Comment, error)
+	UpdateComment(ctx context.Context, commentID uint, text string) error
+	DeleteComment(ctx context.Context, commentID uint) error
+}
+
+type feedbackServiceImpl struct {
+	feedbackRepository repository.FeedbackRepository
+}
+
+func NewFeedbackServiceImpl(feedbackRepository repository.FeedbackRepository) FeedbackService {
+	return &feedbackServiceImpl{
+		feedbackRepository: feedbackRepository,
+	}
+}
+
+// Create создает новый отзыв
+func (s *feedbackServiceImpl) Create(ctx context.Context, feedback *models.Feedback) error {
+	// Валидация входных данных
+	if err := s.validateFeedback(feedback); err != nil {
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	// Устанавливаем начальное значение счетчика комментариев
+	feedback.CommentCount = 0
+
+	// Создаем отзыв
+	if err := s.feedbackRepository.Create(feedback); err != nil {
+		return fmt.Errorf("failed to create feedback: %w", err)
+	}
+
+	return nil
+}
+
+// GetByID возвращает отзыв по ID
+func (s *feedbackServiceImpl) GetByID(ctx context.Context, id uint) (*models.Feedback, error) {
+	if id == 0 {
+		return nil, errors.New("invalid feedback ID")
+	}
+
+	feedback, err := s.feedbackRepository.GetByID(id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fmt.Errorf("feedback with ID %d not found", id)
+		}
+		return nil, fmt.Errorf("failed to get feedback: %w", err)
+	}
+
+	return feedback, nil
+}
+
+// Update обновляет существующий отзыв
+func (s *feedbackServiceImpl) Update(ctx context.Context, feedback *models.Feedback) error {
+	// Проверяем существование отзыва
+	existing, err := s.feedbackRepository.GetByID(feedback.ID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fmt.Errorf("feedback with ID %d not found", feedback.ID)
+		}
+		return fmt.Errorf("failed to get feedback: %w", err)
+	}
+
+	// Валидация обновленных данных
+	if err := s.validateFeedback(feedback); err != nil {
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	// Сохраняем оригинальный счетчик комментариев
+	feedback.CommentCount = existing.CommentCount
+
+	// Обновляем отзыв
+	if err := s.feedbackRepository.Update(feedback); err != nil {
+		return fmt.Errorf("failed to update feedback: %w", err)
+	}
+
+	return nil
+}
+
+// Delete удаляет отзыв
+func (s *feedbackServiceImpl) Delete(ctx context.Context, id uint) error {
+	if id == 0 {
+		return errors.New("invalid feedback ID")
+	}
+
+	// Проверяем существование отзыва
+	_, err := s.feedbackRepository.GetByID(id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fmt.Errorf("feedback with ID %d not found", id)
+		}
+		return fmt.Errorf("failed to get feedback: %w", err)
+	}
+
+	// Удаляем отзыв
+	if err := s.feedbackRepository.Delete(id); err != nil {
+		return fmt.Errorf("failed to delete feedback: %w", err)
+	}
+
+	return nil
+}
+
+// List возвращает список отзывов с пагинацией
+func (s *feedbackServiceImpl) List(ctx context.Context, page, pageSize int) ([]models.Feedback, int64, error) {
+	// Нормализация параметров пагинации
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	// Получаем список отзывов
+	feedbacks, err := s.feedbackRepository.List(offset, limit)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to list feedbacks: %w", err)
+	}
+
+	// Получаем общее количество
+	total, err := s.feedbackRepository.Count()
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to count feedbacks: %w", err)
+	}
+
+	return feedbacks, total, nil
+}
+
+// ListByOwner возвращает отзывы по владельцу
+func (s *feedbackServiceImpl) ListByOwner(ctx context.Context, ownerID uint, page, pageSize int) ([]models.Feedback, error) {
+	if ownerID == 0 {
+		return nil, errors.New("invalid owner ID")
+	}
+
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	feedbacks, err := s.feedbackRepository.ListByOwner(ownerID, offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list feedbacks by owner: %w", err)
+	}
+
+	return feedbacks, nil
+}
+
+// ListByObject возвращает отзывы по объекту
+func (s *feedbackServiceImpl) ListByObject(ctx context.Context, objectID uint, page, pageSize int) ([]models.Feedback, error) {
+	if objectID == 0 {
+		return nil, errors.New("invalid object ID")
+	}
+
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	feedbacks, err := s.feedbackRepository.ListByObject(objectID, offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list feedbacks by object: %w", err)
+	}
+
+	return feedbacks, nil
+}
+
+// ListByPlatform возвращает отзывы по платформе
+func (s *feedbackServiceImpl) ListByPlatform(ctx context.Context, platform models.PlatformType, page, pageSize int) ([]models.Feedback, error) {
+	// Валидация платформы
+	if !s.isValidPlatform(platform) {
+		return nil, fmt.Errorf("invalid platform: %s", platform)
+	}
+
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	feedbacks, err := s.feedbackRepository.ListByPlatform(platform, offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list feedbacks by platform: %w", err)
+	}
+
+	return feedbacks, nil
+}
+
+// Search ищет отзывы по тексту
+func (s *feedbackServiceImpl) Search(ctx context.Context, query string, page, pageSize int) ([]models.Feedback, error) {
+	if strings.TrimSpace(query) == "" {
+		return nil, errors.New("search query cannot be empty")
+	}
+
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	feedbacks, err := s.feedbackRepository.Search(query, offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to search feedbacks: %w", err)
+	}
+
+	return feedbacks, nil
+}
+
+// AddComment добавляет комментарий к отзыву
+func (s *feedbackServiceImpl) AddComment(ctx context.Context, feedbackID uint, comment *models.Comment) error {
+	if feedbackID == 0 {
+		return errors.New("invalid feedback ID")
+	}
+
+	// Проверяем существование отзыва
+	feedback, err := s.feedbackRepository.GetByID(feedbackID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fmt.Errorf("feedback with ID %d not found", feedbackID)
+		}
+		return fmt.Errorf("failed to get feedback: %w", err)
+	}
+
+	// Валидация комментария
+	if err := s.validateComment(comment); err != nil {
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	// Устанавливаем связь с отзывом
+	comment.FeedbackID = feedbackID
+
+	// Сохраняем комментарий (предполагается, что в репозитории есть метод CreateComment)
+	// Временно используем прямое создание через репозиторий
+	// Для полной реализации нужно добавить метод CreateComment в FeedbackRepository
+	
+	// Обновляем счетчик комментариев
+	newCount := feedback.CommentCount + 1
+	if err := s.feedbackRepository.UpdateCommentCount(feedbackID, newCount); err != nil {
+		return fmt.Errorf("failed to update comment count: %w", err)
+	}
+
+	return nil
+}
+
+// GetComments возвращает комментарии к отзыву
+func (s *feedbackServiceImpl) GetComments(ctx context.Context, feedbackID uint, page, pageSize int) ([]models.Comment, error) {
+	if feedbackID == 0 {
+		return nil, errors.New("invalid feedback ID")
+	}
+
+	// Проверяем существование отзыва
+	_, err := s.feedbackRepository.GetByID(feedbackID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fmt.Errorf("feedback with ID %d not found", feedbackID)
+		}
+		return nil, fmt.Errorf("failed to get feedback: %w", err)
+	}
+
+	offset, limit := s.normalizePagination(page, pageSize)
+
+	comments, err := s.feedbackRepository.GetComments(feedbackID, offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get comments: %w", err)
+	}
+
+	return comments, nil
+}
+
+// UpdateComment обновляет комментарий
+func (s *feedbackServiceImpl) UpdateComment(ctx context.Context, commentID uint, text string) error {
+	if commentID == 0 {
+		return errors.New("invalid comment ID")
+	}
+
+	if strings.TrimSpace(text) == "" {
+		return errors.New("comment text cannot be empty")
+	}
+
+	// Здесь нужно добавить метод UpdateComment в репозиторий
+	// Для текущей реализации используем прямой доступ к БД через репозиторий
+	// Временно возвращаем ошибку о необходимости реализации
+	return fmt.Errorf("UpdateComment method not implemented in repository")
+}
+
+// DeleteComment удаляет комментарий
+func (s *feedbackServiceImpl) DeleteComment(ctx context.Context, commentID uint) error {
+	if commentID == 0 {
+		return errors.New("invalid comment ID")
+	}
+
+	// Здесь нужно добавить метод DeleteComment в репозиторий
+	// Для текущей реализации используем прямой доступ к БД через репозиторий
+	// Временно возвращаем ошибку о необходимости реализации
+	return fmt.Errorf("DeleteComment method not implemented in repository")
+}
+
+// Вспомогательные методы
+
+// validateFeedback валидирует данные отзыва
+func (s *feedbackServiceImpl) validateFeedback(feedback *models.Feedback) error {
+	if feedback.OwnerID == 0 {
+		return errors.New("owner ID is required")
+	}
+
+	if feedback.ObjectID == 0 {
+		return errors.New("object ID is required")
+	}
+
+	if feedback.Score < 1 || feedback.Score > 5 {
+		return errors.New("score must be between 1 and 5")
+	}
+
+	if strings.TrimSpace(feedback.Text) == "" {
+		return errors.New("feedback text cannot be empty")
+	}
+
+	if len(feedback.Text) > 5000 {
+		return errors.New("feedback text cannot exceed 5000 characters")
+	}
+
+	if !s.isValidPlatform(feedback.Platform) {
+		return fmt.Errorf("invalid platform: %s", feedback.Platform)
+	}
+
+	return nil
+}
+
+// validateComment валидирует комментарий
+func (s *feedbackServiceImpl) validateComment(comment *models.Comment) error {
+	if strings.TrimSpace(comment.Text) == "" {
+		return errors.New("comment text cannot be empty")
+	}
+
+	if len(comment.Text) > 1000 {
+		return errors.New("comment text cannot exceed 1000 characters")
+	}
+
+	if comment.OwnerID == 0 {
+		return errors.New("owner ID is required")
+	}
+
+	return nil
+}
+
+// normalizePagination нормализует параметры пагинации
+func (s *feedbackServiceImpl) normalizePagination(page, pageSize int) (offset, limit int) {
+	if page < 1 {
+		page = 1
+	}
+	if pageSize < 1 {
+		pageSize = 10
+	}
+	if pageSize > 100 {
+		pageSize = 100
+	}
+
+	offset = (page - 1) * pageSize
+	limit = pageSize
+	return offset, limit
+}
+
+// isValidPlatform проверяет корректность платформы
+func (s *feedbackServiceImpl) isValidPlatform(platform models.PlatformType) bool {
+	validPlatforms := []models.PlatformType{"entrepreneur", "tourist", "platform1", "platform2"} // Добавьте реальные платформы из вашего models.PlatformType
+	for _, p := range validPlatforms {
+		if p == platform {
+			return true
+		}
+	}
+	return false
+}