add bb_api rest api for begushiybashkir

serv_nginx/api_bb/internal/config/config.go

@@ -0,0 +1,26 @@
+package config
+
+import "os"
+
+type Config struct {
+    Port       string
+    DatabaseURL string
+}
+
+func Load() *Config {
+    port := getEnv("PORT", "8080")
+    databaseURL := getEnv("DATABASE_URL", "sqlite:test.db")
+    
+    return &Config{
+        Port:       port,
+        DatabaseURL: databaseURL,
+    }
+}
+
+func getEnv(key, defaultValue string) string {
+    value := os.Getenv(key)
+    if value == "" {
+        return defaultValue
+    }
+    return value
+}

serv_nginx/api_bb/internal/handlers/auth.go

@@ -0,0 +1,97 @@
+package handlers
+
+import (
+    "encoding/json"
+    "net/http"
+    
+    "github.com/go-chi/chi/v5"
+    "go-rest-api/internal/models"
+    "go-rest-api/internal/service"
+)
+
+type AuthHandler struct {
+    authService service.AuthService
+}
+
+func NewAuthHandler(authService service.AuthService) *AuthHandler {
+    return &AuthHandler{authService: authService}
+}
+
+func (h *AuthHandler) Routes() chi.Router {
+    r := chi.NewRouter()
+    
+    r.Post("/register", h.Register)
+    r.Post("/login", h.Login)
+    r.Get("/check", h.AuthCheck)
+    
+    return r
+}
+
+type RegisterRequest struct {
+    Email     string `json:"email"`
+    Password  string `json:"password"`
+    FirstName string `json:"first_name"`
+    LastName  string `json:"last_name"`
+}
+
+type LoginRequest struct {
+    Email    string `json:"email"`
+    Password string `json:"password"`
+}
+
+func (h *AuthHandler) Register(w http.ResponseWriter, r *http.Request) {
+    var req RegisterRequest
+    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+        respondWithError(w, http.StatusBadRequest, "Invalid request payload")
+        return
+    }
+    
+    user := &models.User{
+        Email:     req.Email,
+        Password:  req.Password,
+        FirstName: req.FirstName,
+        LastName:  req.LastName,
+        Role:      "user",
+    }
+    
+    if err := h.authService.Register(user); err != nil {
+        respondWithError(w, http.StatusBadRequest, err.Error())
+        return
+    }
+    
+    respondWithJSON(w, http.StatusCreated, map[string]string{
+        "message": "User registered successfully",
+    })
+}
+
+func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
+    var req LoginRequest
+    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+        respondWithError(w, http.StatusBadRequest, "Invalid request payload")
+        return
+    }
+    
+    user, err := h.authService.Login(req.Email, req.Password)
+    if err != nil {
+        respondWithError(w, http.StatusUnauthorized, err.Error())
+        return
+    }
+    
+    respondWithJSON(w, http.StatusOK, map[string]interface{}{
+        "message": "Login successful",
+        "user": map[string]interface{}{
+            "id":         user.ID,
+            "email":      user.Email,
+            "first_name": user.FirstName,
+            "last_name":  user.LastName,
+            "role":       user.Role,
+        },
+    })
+}
+
+func (h *AuthHandler) AuthCheck(w http.ResponseWriter, r *http.Request) {
+    respondWithJSON(w, http.StatusOK, map[string]string{
+        "status":  "ok",
+        "message": "Auth endpoint is working",
+    })
+}

serv_nginx/api_bb/internal/handlers/common.go

@@ -0,0 +1,16 @@
+package handlers
+
+import (
+    "encoding/json"
+    "net/http"
+)
+
+func respondWithJSON(w http.ResponseWriter, status int, payload interface{}) {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(status)
+    json.NewEncoder(w).Encode(payload)
+}
+
+func respondWithError(w http.ResponseWriter, status int, message string) {
+    respondWithJSON(w, status, map[string]string{"error": message})
+}

serv_nginx/api_bb/internal/handlers/handlers.go

@@ -0,0 +1,22 @@
+package handlers
+
+import (
+    "go-rest-api/internal/repository"
+    "go-rest-api/internal/service"
+    "gorm.io/gorm"
+)
+
+type Handler struct {
+    healthHandler *HealthHandler
+    authHandler   *AuthHandler
+}
+
+func NewHandler(db *gorm.DB) *Handler {
+    userRepo := repository.NewUserRepository(db)
+    authService := service.NewAuthService(userRepo)
+    
+    return &Handler{
+        healthHandler: NewHealthHandler(),
+        authHandler:   NewAuthHandler(authService),
+    }
+}

serv_nginx/api_bb/internal/handlers/health.go

@@ -0,0 +1,40 @@
+package handlers
+
+import (
+    "net/http"
+    
+    "github.com/go-chi/chi/v5"
+)
+
+type HealthHandler struct{}
+
+func NewHealthHandler() *HealthHandler {
+    return &HealthHandler{}
+}
+
+func (h *HealthHandler) Routes() chi.Router {
+    r := chi.NewRouter()
+    
+    r.Get("/health", h.HealthCheck)
+    r.Get("/check", h.Check)
+    
+    return r
+}
+
+func (h *HealthHandler) HealthCheck(w http.ResponseWriter, r *http.Request) {
+    response := map[string]string{
+        "status": "ok",
+        "message": "Service is healthy",
+    }
+    
+    respondWithJSON(w, http.StatusOK, response)
+}
+
+func (h *HealthHandler) Check(w http.ResponseWriter, r *http.Request) {
+    response := map[string]string{
+        "status": "ok",
+        "message": "API is working",
+    }
+    
+    respondWithJSON(w, http.StatusOK, response)
+}

serv_nginx/api_bb/internal/models/user.go

@@ -0,0 +1,23 @@
+package models
+
+import (
+    "time"
+    "gorm.io/gorm"
+)
+
+type User struct {
+    gorm.Model
+    ID        uint      `gorm:"primaryKey" json:"id"`
+    Email     string    `gorm:"uniqueIndex;not null" json:"email"`
+    Password  string    `gorm:"not null" json:"-"`
+    FirstName string    `json:"first_name"`
+    LastName  string    `json:"last_name"`
+    Role      string    `gorm:"default:user" json:"role"` // user, admin
+    IsActive  bool      `gorm:"default:true" json:"is_active"`
+    LastLogin time.Time `json:"last_login"`
+    CreatedAt time.Time `json:"created_at"`
+    UpdatedAt time.Time `json:"updated_at"`
+}
+
+// Другие модели будут добавлены позже
+// type Profile {}, type Event {}, type Review {}, etc.

serv_nginx/api_bb/internal/repository/user_repository.go

@@ -0,0 +1,46 @@
+package repository
+
+import (
+    "go-rest-api/internal/models"
+    "gorm.io/gorm"
+)
+
+type UserRepository interface {
+    Create(user *models.User) error
+    FindByID(id uint) (*models.User, error)
+    FindByEmail(email string) (*models.User, error)
+    Update(user *models.User) error
+    Delete(id uint) error
+}
+
+type userRepository struct {
+    db *gorm.DB
+}
+
+func NewUserRepository(db *gorm.DB) UserRepository {
+    return &userRepository{db: db}
+}
+
+func (r *userRepository) Create(user *models.User) error {
+    return r.db.Create(user).Error
+}
+
+func (r *userRepository) FindByID(id uint) (*models.User, error) {
+    var user models.User
+    err := r.db.First(&user, id).Error
+    return &user, err
+}
+
+func (r *userRepository) FindByEmail(email string) (*models.User, error) {
+    var user models.User
+    err := r.db.Where("email = ?", email).First(&user).Error
+    return &user, err
+}
+
+func (r *userRepository) Update(user *models.User) error {
+    return r.db.Save(user).Error
+}
+
+func (r *userRepository) Delete(id uint) error {
+    return r.db.Delete(&models.User{}, id).Error
+}

serv_nginx/api_bb/internal/routes/routes.go

@@ -0,0 +1,47 @@
+package routes
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"gorm.io/gorm"
+
+	"go-rest-api/internal/handlers"
+	"go-rest-api/internal/repository"
+	"go-rest-api/internal/service"
+	"go-rest-api/pkg/middleware"
+)
+
+func SetupRouter(db *gorm.DB) http.Handler {
+	r := chi.NewRouter()
+	
+	// Apply common middleware
+	for _, m := range middleware.CommonMiddleware() {
+		r.Use(m)
+	}
+
+	// Initialize repositories
+	userRepo := repository.NewUserRepository(db)
+	
+	// Initialize services
+	authService := service.NewAuthService(userRepo)
+	
+	// Initialize handlers
+	healthHandler := handlers.NewHealthHandler()
+	authHandler := handlers.NewAuthHandler(authService)
+	
+	// Health routes
+	r.Mount("/api", healthHandler.Routes())
+	
+	// API v1 routes
+	r.Route("/api/v1", func(r chi.Router) {
+		r.Mount("/auth", authHandler.Routes())
+		
+		// Здесь будут добавлены другие маршруты:
+		// r.Mount("/users", userHandler.Routes())
+		// r.Mount("/events", eventHandler.Routes())
+		// r.Mount("/reviews", reviewHandler.Routes())
+	})
+	
+	return r
+}

serv_nginx/api_bb/internal/service/auth_service.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+    "errors"
+    "go-rest-api/internal/models"
+    "go-rest-api/internal/repository"
+)
+
+type AuthService interface {
+    Register(user *models.User) error
+    Login(email, password string) (*models.User, error)
+}
+
+type authService struct {
+    userRepo repository.UserRepository
+}
+
+func NewAuthService(userRepo repository.UserRepository) AuthService {
+    return &authService{userRepo: userRepo}
+}
+
+func (s *authService) Register(user *models.User) error {
+    // Проверка существования пользователя
+    existingUser, _ := s.userRepo.FindByEmail(user.Email)
+    if existingUser != nil {
+        return errors.New("user already exists")
+    }
+    
+    // Здесь должна быть хеширование пароля
+    // user.Password = hashPassword(user.Password)
+    
+    return s.userRepo.Create(user)
+}
+
+func (s *authService) Login(email, password string) (*models.User, error) {
+    user, err := s.userRepo.FindByEmail(email)
+    if err != nil {
+        return nil, errors.New("invalid credentials")
+    }
+    
+    // Здесь должна быть проверка хеша пароля
+    // if !checkPasswordHash(password, user.Password) {
+    //     return nil, errors.New("invalid credentials")
+    // }
+    
+    // Временно просто проверяем напрямую (для демо)
+    if user.Password != password {
+        return nil, errors.New("invalid credentials")
+    }
+    
+    return user, nil
+}