valitovgaziz/tp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add rest api for api_bb vue a lot of files

Browse Source
This commit is contained in:
Газиз Валитов
2025-10-09 05:59:40 +05:00
parent 654c682b05
commit 700e404a06
17 changed files with 512 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serv_nginx/api_bb/internal/config/config.go
+30 -26
View File
@@ -1,43 +1,47 @@
// config/config.go
package config
import (
"fmt"
"os"
"fmt"
"os"
)
type Config struct {
Port string
DatabaseURL string
Port string
DatabaseURL string
JWTSecret string
}
func Load() *Config {
port := getEnv("PORT", "8080")
// Формируем DSN для PostgreSQL из переменных окружения
databaseURL := getPostgresDSN()
return &Config{
Port: port,
DatabaseURL: databaseURL,
}
port := getEnv("PORT", "8080")
jwtSecret := getEnv("JWT_SECRET", "your-secret-key")
// Формируем DSN для PostgreSQL из переменных окружения
databaseURL := getPostgresDSN()
return &Config{
Port: port,
DatabaseURL: databaseURL,
JWTSecret: jwtSecret,
}
}
func getPostgresDSN() string {
host := getEnv("DB_HOST", "localhost")
port := getEnv("DB_PORT", "5432")
user := getEnv("DB_USER", "postgres")
password := getEnv("DB_PASSWORD", "postgres")
dbname := getEnv("DB_NAME", "bb_db")
sslmode := getEnv("DB_SSLMODE", "disable")
host := getEnv("DB_HOST", "localhost")
port := getEnv("DB_PORT", "5432")
user := getEnv("DB_USER", "postgres")
password := getEnv("DB_PASSWORD", "postgres")
dbname := getEnv("DB_NAME", "bb_db")
sslmode := getEnv("DB_SSLMODE", "disable")
return fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s",
host, port, user, password, dbname, sslmode)
return fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s",
host, port, user, password, dbname, sslmode)
}
func getEnv(key, defaultValue string) string {
value := os.Getenv(key)
if value == "" {
return defaultValue
}
return value
value := os.Getenv(key)
if value == "" {
return defaultValue
}
return value
}
serv_nginx/api_bb/internal/handlers/auth.go
+142 -71
View File
@@ -1,97 +1,168 @@
// handlers/auth.go
package handlers
import (
"encoding/json"
"net/http"
"github.com/go-chi/chi/v5"
"go-rest-api/internal/models"
"go-rest-api/internal/service"
"encoding/json"
"net/http"
"time"
"go-rest-api/internal/models"
"go-rest-api/internal/service"
"go-rest-api/pkg/middleware"
"go-rest-api/pkg/utils"
"github.com/go-chi/chi/v5"
)
type AuthHandler struct {
authService service.AuthService
authService service.AuthService
jwtService service.JWTService
}
func NewAuthHandler(authService service.AuthService) *AuthHandler {
return &AuthHandler{authService: authService}
func NewAuthHandler(authService service.AuthService, jwtService service.JWTService) *AuthHandler {
return &AuthHandler{
authService: authService,
jwtService: jwtService,
}
}
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
r := chi.NewRouter()
r.Post("/register", h.Register)
r.Post("/login", h.Login)
r.Post("/logout", h.Logout)
r.Get("/profile", h.GetProfile)
return r
}
type RegisterRequest struct {
Email string `json:"email"`
Password string `json:"password"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Email string `json:"email"`
Password string `json:"password"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Phone string `json:"phone"`
Experience string `json:"experience"`
Goals string `json:"goals"`
Newsletter bool `json:"newsletter"`
}
type LoginRequest struct {
Email string `json:"email"`
Password string `json:"password"`
Email string `json:"email"`
Password string `json:"password"`
}
type UserResponse struct {
ID uint `json:"id"`
Email string `json:"email"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Phone string `json:"phone"`
Experience string `json:"experience"`
Goals string `json:"goals"`
Newsletter bool `json:"newsletter"`
Role string `json:"role"`
}
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",
})
var req RegisterRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
utils.RespondWithError(w, http.StatusBadRequest, "Invalid request payload")
return
}
user := &models.User{
Email: req.Email,
Password: req.Password,
FirstName: req.FirstName,
LastName: req.LastName,
Phone: req.Phone,
Experience: req.Experience,
Goals: req.Goals,
Newsletter: req.Newsletter,
Role: "user",
}
if err := h.authService.Register(user); err != nil {
utils.RespondWithError(w, http.StatusBadRequest, err.Error())
return
}
utils.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,
},
})
var req LoginRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
utils.RespondWithError(w, http.StatusBadRequest, "Invalid request payload")
return
}
user, token, err := h.authService.Login(req.Email, req.Password)
if err != nil {
utils.RespondWithError(w, http.StatusUnauthorized, err.Error())
return
}
// Устанавливаем токен в куки
http.SetCookie(w, &http.Cookie{
Name: "auth_token",
Value: token,
Path: "/",
HttpOnly: true,
Secure: false, // В production установить true
SameSite: http.SameSiteLaxMode,
Expires: time.Now().Add(24 * time.Hour),
})
utils.RespondWithJSON(w, http.StatusOK, map[string]interface{}{
"message": "Login successful",
"token": token,
"user": toUserResponse(user),
})
}
func (h *AuthHandler) AuthCheck(w http.ResponseWriter, r *http.Request) {
respondWithJSON(w, http.StatusOK, map[string]string{
"status": "ok",
"message": "Auth endpoint is working",
})
func (h *AuthHandler) Logout(w http.ResponseWriter, r *http.Request) {
// Удаляем куку
http.SetCookie(w, &http.Cookie{
Name: "auth_token",
Value: "",
Path: "/",
HttpOnly: true,
Secure: false,
SameSite: http.SameSiteLaxMode,
Expires: time.Now().Add(-1 * time.Hour),
MaxAge: -1,
})
utils.RespondWithJSON(w, http.StatusOK, map[string]string{
"message": "Logout successful",
})
}
func (h *AuthHandler) GetProfile(w http.ResponseWriter, r *http.Request) {
user, ok := middleware.GetUserFromContext(r.Context())
if !ok {
utils.RespondWithError(w, http.StatusUnauthorized, "Authentication required")
return
}
utils.RespondWithJSON(w, http.StatusOK, toUserResponse(user))
}
func toUserResponse(user *models.User) UserResponse {
return UserResponse{
ID: user.ID,
Email: user.Email,
FirstName: user.FirstName,
LastName: user.LastName,
Phone: user.Phone,
Experience: user.Experience,
Goals: user.Goals,
Newsletter: user.Newsletter,
Role: user.Role,
}
}
serv_nginx/api_bb/internal/handlers/common.go
-16
View File
@@ -1,16 +0,0 @@
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
+27 -4
View File
@@ -1,22 +1,45 @@
// handlers/handlers.go
package handlers
import (
"go-rest-api/internal/repository"
"go-rest-api/internal/service"
"go-rest-api/internal/config"
"gorm.io/gorm"
)
type Handler struct {
healthHandler *HealthHandler
authHandler *AuthHandler
// Здесь будут добавлены другие обработчики
// userHandler *UserHandler
// eventHandler *EventHandler
// reviewHandler *ReviewHandler
}
func NewHandler(db *gorm.DB) *Handler {
func NewHandler(db *gorm.DB, cfg *config.Config) *Handler {
// Инициализация репозиториев
userRepo := repository.NewUserRepository(db)
authService := service.NewAuthService(userRepo)
// Инициализация сервисов
jwtService := service.NewJWTService(cfg.JWTSecret)
authService := service.NewAuthService(userRepo, jwtService)
// Инициализация обработчиков
healthHandler := NewHealthHandler()
authHandler := NewAuthHandler(authService, jwtService)
return &Handler{
healthHandler: NewHealthHandler(),
authHandler: NewAuthHandler(authService),
healthHandler: healthHandler,
authHandler: authHandler,
}
}
// Геттеры для обработчиков (опционально, для удобства)
func (h *Handler) HealthHandler() *HealthHandler {
return h.healthHandler
}
func (h *Handler) AuthHandler() *AuthHandler {
return h.authHandler
}
serv_nginx/api_bb/internal/handlers/health.go
+4 -3
View File
@@ -2,6 +2,8 @@ package handlers
import (
"net/http"
"go-rest-api/pkg/utils"
"github.com/go-chi/chi/v5"
)
@@ -26,8 +28,7 @@ func (h *HealthHandler) HealthCheck(w http.ResponseWriter, r *http.Request) {
"status": "ok",
"message": "Service is healthy",
}
respondWithJSON(w, http.StatusOK, response)
utils.RespondWithJSON(w, http.StatusOK, response)
}
func (h *HealthHandler) Check(w http.ResponseWriter, r *http.Request) {
@@ -36,5 +37,5 @@ func (h *HealthHandler) Check(w http.ResponseWriter, r *http.Request) {
"message": "API is working",
}
respondWithJSON(w, http.StatusOK, response)
utils.RespondWithJSON(w, http.StatusOK, response)
}
serv_nginx/api_bb/internal/models/user.go
+32 -15
View File
@@ -1,23 +1,40 @@
// models/user.go
package models
import (
"time"
"gorm.io/gorm"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
"time"
)
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"`
ID uint `json:"id" gorm:"primaryKey"`
Email string `json:"email" gorm:"uniqueIndex;not null"`
Password string `json:"-" gorm:"not null"`
FirstName string `json:"first_name" gorm:"not null"`
LastName string `json:"last_name" gorm:"not null"`
Phone string `json:"phone"`
Experience string `json:"experience"`
Goals string `json:"goals"`
Newsletter bool `json:"newsletter"`
Role string `json:"role" gorm:"default:user"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `json:"-" gorm:"index"`
}
// Другие модели будут добавлены позже
// type Profile {}, type Event {}, type Review {}, etc.
// HashPassword хеширует пароль перед сохранением
func (u *User) HashPassword() error {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
u.Password = string(hashedPassword)
return nil
}
// CheckPassword проверяет пароль
func (u *User) CheckPassword(password string) bool {
err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
return err == nil
}
serv_nginx/api_bb/internal/routes/routes.go
+20 -10
View File
@@ -1,3 +1,4 @@
// routes/routes.go
package routes
import (
@@ -6,13 +7,14 @@ import (
"github.com/go-chi/chi/v5"
"gorm.io/gorm"
"go-rest-api/internal/config"
"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 {
func SetupRouter(db *gorm.DB, config *config.Config) http.Handler {
r := chi.NewRouter()
// Apply common middleware
@@ -24,28 +26,36 @@ func SetupRouter(db *gorm.DB) http.Handler {
userRepo := repository.NewUserRepository(db)
// Initialize services
authService := service.NewAuthService(userRepo)
jwtService := service.NewJWTService(config.JWTSecret)
authService := service.NewAuthService(userRepo, jwtService)
// Initialize handlers
healthHandler := handlers.NewHealthHandler()
authHandler := handlers.NewAuthHandler(authService)
h := handlers.NewHealthHandler()
authHandler := handlers.NewAuthHandler(authService, jwtService)
// Health routes
r.Mount("/", healthHandler.Routes())
// API v1 routes
r.Route("/v1", func(r chi.Router) {
// Add the new /check route
r.Get("/check", h.Check)
r.Get("/check", healthHandler.Check)
// Public auth routes
r.Mount("/auth", authHandler.Routes())
// Protected routes
r.Route("/user", func(r chi.Router) {
r.Use(middleware.AuthMiddleware(jwtService, userRepo))
r.Use(middleware.RequireAuth)
r.Get("/profile", authHandler.GetProfile)
// Здесь будут другие защищенные маршруты пользователя
})
// Здесь будут добавлены другие маршруты:
// 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
+47 -35
View File
@@ -1,52 +1,64 @@
// service/auth_service.go
package service
import (
"errors"
"go-rest-api/internal/models"
"go-rest-api/internal/repository"
"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)
Register(user *models.User) error
Login(email, password string) (*models.User, string, error)
GetUserProfile(userID uint) (*models.User, error)
}
type authService struct {
userRepo repository.UserRepository
userRepo repository.UserRepository
jwtService JWTService
}
func NewAuthService(userRepo repository.UserRepository) AuthService {
return &authService{userRepo: userRepo}
func NewAuthService(userRepo repository.UserRepository, jwtService JWTService) AuthService {
return &authService{
userRepo: userRepo,
jwtService: jwtService,
}
}
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)
// Проверяем, существует ли пользователь
existingUser, err := s.userRepo.FindByEmail(user.Email)
if err == nil && existingUser != nil {
return errors.New("user with this email already exists")
}
// Хешируем пароль
if err := user.HashPassword(); err != nil {
return err
}
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
func (s *authService) Login(email, password string) (*models.User, string, error) {
user, err := s.userRepo.FindByEmail(email)
if err != nil {
return nil, "", errors.New("invalid email or password")
}
if !user.CheckPassword(password) {
return nil, "", errors.New("invalid email or password")
}
token, err := s.jwtService.GenerateToken(user.ID, user.Email)
if err != nil {
return nil, "", err
}
return user, token, nil
}
func (s *authService) GetUserProfile(userID uint) (*models.User, error) {
return s.userRepo.FindByID(userID)
}
serv_nginx/api_bb/internal/service/jwt_service.go
+61
View File
@@ -0,0 +1,61 @@
// service/jwt_service.go
package service
import (
"errors"
"fmt"
"time"
"github.com/golang-jwt/jwt/v5"
)
type JWTService interface {
GenerateToken(userID uint, email string) (string, error)
ValidateToken(tokenString string) (*jwt.Token, error)
ExtractUserID(token *jwt.Token) (uint, error)
}
type jwtService struct {
secretKey string
}
func NewJWTService(secretKey string) JWTService {
return &jwtService{secretKey: secretKey}
}
type Claims struct {
UserID uint `json:"user_id"`
Email string `json:"email"`
jwt.RegisteredClaims
}
func (j *jwtService) GenerateToken(userID uint, email string) (string, error) {
claims := &Claims{
UserID: userID,
Email: email,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
IssuedAt: jwt.NewNumericDate(time.Now()),
},
}
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
return token.SignedString([]byte(j.secretKey))
}
func (j *jwtService) ValidateToken(tokenString string) (*jwt.Token, error) {
return jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
}
return []byte(j.secretKey), nil
})
}
func (j *jwtService) ExtractUserID(token *jwt.Token) (uint, error) {
claims, ok := token.Claims.(*Claims)
if !ok {
return 0, errors.New("invalid token claims")
}
return claims.UserID, nil
}