Users and pay in one file

frontend/style/app/main.go

@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"os"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -16,50 +17,45 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
-// Структура для тела запроса на localhost:5000
+type User struct {
-type PaymentRequest struct {
+	ID       int    `json:"id"`
-	ID  string  `json:"id"`
+	Email    string `json:"email"`
-	Sum float64 `json:"sum"`
+	Password string `json:"password"`
-}
-
-// Структура для ответа от localhost:5000
-type PaymentResponse struct {
-	Message string `json:"message"`
-	URL     string `json:"redir_url"`
 }
 
 var db *sql.DB
 
+func create_table(command string) {
+	_, err := db.Exec(command)
+	if err != nil {
+		log.Fatal("Ошибка при создании таблицы:", err)
+	}
+	fmt.Println("База данных готова к работе.")
+}
+
 func initDB() {
 	var err error
-	dbFile := "pay_orders.db"
+	dbFile := "UNITED.db"
 	db, err = sql.Open("sqlite3", dbFile)
 	if err != nil {
 		log.Fatal("Ошибка подключения к базе данных:", err)
 	}
 
-	// Создаем таблицу pay_urls, если она не существует
+	// Create tables if they don't exist
-	createTableSQL := `
+	create_table(`
 	CREATE TABLE IF NOT EXISTS pay_urls (
 		id TEXT PRIMARY KEY,
 		url TEXT NOT NULL
-	);`
+	);`)
-	_, err = db.Exec(createTableSQL)
+
-	if err != nil {
+	create_table(`
-		log.Fatal("Ошибка при создании таблицы pay_urls:", err)
-	}
-	createTableSQL = `
 	CREATE TABLE IF NOT EXISTS order_list (
 		order_id TEXT PRIMARY KEY,
 		total_price REAL NOT NULL,
 		datetime TEXT NOT NULL
-	);`
+	);`)
-	_, err = db.Exec(createTableSQL)
-	if err != nil {
-		log.Fatal("Ошибка при создании таблицы order_list:", err)
-	}
 
-	createTableSQL = `CREATE TABLE IF NOT EXISTS order_lines (
+	create_table(`CREATE TABLE IF NOT EXISTS order_lines (
     	line_id INTEGER PRIMARY KEY AUTOINCREMENT,
     	order_id TEXT NOT NULL,
 		item_id INTEGER NOT NULL,
@@ -67,17 +63,32 @@ func initDB() {
 		item_price REAL NOT NULL,
 		item_quantity INTEGER NOT NULL,
 		FOREIGN KEY (order_id) REFERENCES order_list(order_id)
-	);`
+	);`)
-	_, err = db.Exec(createTableSQL)
+
-	if err != nil {
+	create_table(`CREATE TABLE IF NOT EXISTS users (
-		log.Fatal("Ошибка при создании таблицы order_lines:", err)
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
-	}
+        email TEXT NOT NULL UNIQUE,
+        password TEXT NOT NULL
+    );`)
 
 	fmt.Println("База данных готова к работе.")
 }
 
+/*----------------------------PAYMENT--------------------------------------*/
 func payHandler(w http.ResponseWriter, r *http.Request) {
 
+	// Структура для тела запроса на localhost:5000
+	type PaymentRequest struct {
+		ID  string  `json:"id"`
+		Sum float64 `json:"sum"`
+	}
+
+	// Структура для ответа от localhost:5000
+	type PaymentResponse struct {
+		Message string `json:"message"`
+		URL     string `json:"redir_url"`
+	}
+
 	cookie, err := r.Cookie("totalPrice")
 	if err != nil {
 		http.Error(w, "Не удалось получить amount из cookies", http.StatusBadRequest)
@@ -216,33 +227,39 @@ func checkPayHandler(w http.ResponseWriter, r *http.Request) {
 	w.Write([]byte(response))
 }
 
-type CartItem struct {
-	ID       int     `json:"id"`
-	Title    string  `json:"title"`
-	Price    float64 `json:"price"`
-	Quantity int     `json:"quantity"`
-}
-
-type Cart struct {
-	CartItems []CartItem `json:"cart_items"`
-}
-
 func add_to_cart(w http.ResponseWriter, r *http.Request) {
+
+	type CartItem struct {
+		ID       int     `json:"id"`
+		Title    string  `json:"title"`
+		Price    float64 `json:"price"`
+		Quantity int     `json:"quantity"`
+	}
+
+	type Cart struct {
+		CartItems []CartItem `json:"cart_items"`
+	}
+
 	cartCookie, err := r.Cookie("cart")
 	if err != nil {
 		http.Error(w, "Cart cookie not found", http.StatusBadRequest)
 		return
 	}
 	fmt.Print("cartCookie.Value: ", cartCookie.Value)
+	cartValue := strings.ReplaceAll(cartCookie.Value, "'", "\"") // Replace single quotes with double quotes
 	var cart Cart
 
-	// Разбираем JSON
+	err = json.Unmarshal([]byte(cartValue), &cart)
-	err = json.Unmarshal([]byte(cartCookie.Value), &cart)
 	if err != nil {
-		fmt.Println("Ошибка при разборе JSON:", err)
+		http.Error(w, "Invalid cart data format", http.StatusBadRequest)
 		return
 	}
-
+	for _, item := range cart.CartItems {
+		fmt.Println("Item ID:", item.ID)
+		fmt.Println("Item Title:", item.Title)
+		fmt.Println("Item Price:", item.Price)
+		fmt.Println("Item Quantity:", item.Quantity)
+	}
 	del_cookie, err := r.Cookie("uuid")
 	if err != nil {
 		http.Error(w, "Не найден cookie с uuid", http.StatusBadRequest)
@@ -256,20 +273,24 @@ func add_to_cart(w http.ResponseWriter, r *http.Request) {
 
 	total_price := total_cookie.Value
 	order_id := del_cookie.Value
+	fmt.Println("order_id: ", order_id)
+	fmt.Println("total_price: ", total_price)
 
 	insertSql := `INSERT INTO order_list VALUES (?, ?, ?)`
 	_, err = db.Exec(insertSql, order_id, total_price, time.Now().Format("2006-01-02 15:04:05"))
 	if err != nil {
-		http.Error(w, "Ошибка при сохранении данных в базу данных", http.StatusInternalServerError)
+		http.Error(w, "Ошибка при сохранении данных в базу данных 1", http.StatusInternalServerError)
+		fmt.Print("Ошибка при сохранении данных в базу данных 1", err)
 		return
 	}
 
 	for _, item := range cart.CartItems {
 
-		insertSQL := `INSERT INTO order_lines VALUES (?, ?, ?, ?, ?)`
+		insertSQL := `INSERT INTO order_lines (order_id, item_id, item_title, item_price, item_quantity) VALUES (?, ?, ?, ?, ?)`
 		_, err = db.Exec(insertSQL, order_id, item.ID, item.Title, item.Price, item.Quantity)
 		if err != nil {
-			http.Error(w, "Ошибка при сохранении данных в базу данных", http.StatusInternalServerError)
+			http.Error(w, "Ошибка при сохранении данных в базу данных 2", http.StatusInternalServerError)
+			fmt.Println("Ошибка при сохранении данных в базу данных 2", err)
 			return
 		}
 	}
@@ -292,6 +313,101 @@ func add_to_cart(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 	w.Write([]byte("OK"))
 }
+
+/*----------------------------USER-----------------------------------------*/
+func registerHandler(w http.ResponseWriter, r *http.Request) {
+	log.Printf("Received request with method: %s", r.Method)
+	if r.Method != http.MethodPost {
+		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var user User
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		http.Error(w, "Ошибка обработки JSON", http.StatusBadRequest)
+		return
+	}
+
+	if user.Email == "" || user.Password == "" {
+		http.Error(w, "Email и пароль обязательны", http.StatusBadRequest)
+		return
+	}
+
+	insertQuery := `INSERT INTO users (email, password) VALUES (?, ?)`
+	_, err := db.Exec(insertQuery, user.Email, user.Password)
+	if err != nil {
+		http.Error(w, "Ошибка записи в базу данных", http.StatusInternalServerError)
+		fmt.Println("Ошибка:", err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(map[string]string{"message": "Пользователь успешно зарегистрирован", "email": user.Email})
+}
+
+func loginHandler(w http.ResponseWriter, r *http.Request) {
+	log.Printf("Received request with method: %s", r.Method)
+	if r.Method != http.MethodPost {
+		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var user User
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		http.Error(w, "Ошибка обработки JSON", http.StatusBadRequest)
+		return
+	}
+
+	if user.Email == "" || user.Password == "" {
+		http.Error(w, "Email и пароль обязательны", http.StatusBadRequest)
+		return
+	}
+
+	query := `SELECT id, email, password FROM users WHERE email = ? AND password = ?`
+	var dbUser User
+	err := db.QueryRow(query, user.Email, user.Password).Scan(&dbUser.ID, &dbUser.Email, &dbUser.Password)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			http.Error(w, "Неверные учетные данные", http.StatusUnauthorized)
+		} else {
+			http.Error(w, "Ошибка при проверке учетных данных", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]string{"message": "Вход успешен", "email": dbUser.Email})
+}
+
+func getUsersHandler(w http.ResponseWriter, r *http.Request) {
+
+	log.Printf("Received request with method: %s", r.Method)
+	if r.Method != http.MethodGet {
+		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
+		return
+	}
+
+	rows, err := db.Query(`SELECT id, email, password FROM users`)
+	if err != nil {
+		http.Error(w, "Ошибка чтения из базы данных", http.StatusInternalServerError)
+		return
+	}
+	defer rows.Close()
+
+	var users []User
+	for rows.Next() {
+		var user User
+		if err := rows.Scan(&user.ID, &user.Email, &user.Password); err != nil {
+			http.Error(w, "Ошибка обработки данных", http.StatusInternalServerError)
+			return
+		}
+		users = append(users, user)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(users)
+}
+
 func main() {
 
 	initDB()
@@ -307,6 +423,9 @@ func main() {
 	http.HandleFunc("/api/pay", payHandler)
 	http.HandleFunc("/api/check_pay", checkPayHandler)
 	http.HandleFunc("/api/add_to_cart", add_to_cart)
+	http.HandleFunc("/api/register", registerHandler)
+	http.HandleFunc("/api/login", loginHandler)
+	http.HandleFunc("/api/users", getUsersHandler)
 
 	// Start server with CORS middleware
 	port := os.Getenv("PORT")

frontend/style/app/profile/auth.go

@@ -1,160 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/handlers"
-	_ "github.com/mattn/go-sqlite3"
-)
-
-type User struct {
-	ID       int    `json:"id"`
-	Email    string `json:"email"`
-	Password string `json:"password"`
-}
-
-var db *sql.DB
-
-func initDB() {
-	var err error
-	dbFile := "users.db"
-	db, err = sql.Open("sqlite3", dbFile)
-	if err != nil {
-		log.Fatal("Ошибка подключения к базе данных:", err)
-	}
-
-	createTableQuery := `
-    CREATE TABLE IF NOT EXISTS users (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        email TEXT NOT NULL UNIQUE,
-        password TEXT NOT NULL
-    );`
-	_, err = db.Exec(createTableQuery)
-	if err != nil {
-		log.Fatal("Ошибка при создании таблицы:", err)
-	}
-	fmt.Println("База данных готова к работе.")
-}
-
-func registerHandler(w http.ResponseWriter, r *http.Request) {
-	log.Printf("Received request with method: %s", r.Method)
-	if r.Method != http.MethodPost {
-		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
-		return
-	}
-
-	var user User
-	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
-		http.Error(w, "Ошибка обработки JSON", http.StatusBadRequest)
-		return
-	}
-
-	if user.Email == "" || user.Password == "" {
-		http.Error(w, "Email и пароль обязательны", http.StatusBadRequest)
-		return
-	}
-
-	insertQuery := `INSERT INTO users (email, password) VALUES (?, ?)`
-	_, err := db.Exec(insertQuery, user.Email, user.Password)
-	if err != nil {
-		http.Error(w, "Ошибка записи в базу данных", http.StatusInternalServerError)
-		fmt.Println("Ошибка:", err)
-		return
-	}
-
-	w.WriteHeader(http.StatusCreated)
-	json.NewEncoder(w).Encode(map[string]string{"message": "Пользователь успешно зарегистрирован", "email": user.Email})
-}
-
-func loginHandler(w http.ResponseWriter, r *http.Request) {
-	log.Printf("Received request with method: %s", r.Method)
-	if r.Method != http.MethodPost {
-		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
-		return
-	}
-
-	var user User
-	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
-		http.Error(w, "Ошибка обработки JSON", http.StatusBadRequest)
-		return
-	}
-
-	if user.Email == "" || user.Password == "" {
-		http.Error(w, "Email и пароль обязательны", http.StatusBadRequest)
-		return
-	}
-
-	query := `SELECT id, email, password FROM users WHERE email = ? AND password = ?`
-	var dbUser User
-	err := db.QueryRow(query, user.Email, user.Password).Scan(&dbUser.ID, &dbUser.Email, &dbUser.Password)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			http.Error(w, "Неверные учетные данные", http.StatusUnauthorized)
-		} else {
-			http.Error(w, "Ошибка при проверке учетных данных", http.StatusInternalServerError)
-		}
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]string{"message": "Вход успешен", "email": dbUser.Email})
-}
-
-func getUsersHandler(w http.ResponseWriter, r *http.Request) {
-	log.Printf("Received request with method: %s", r.Method)
-	if r.Method != http.MethodGet {
-		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
-		return
-	}
-
-	rows, err := db.Query(`SELECT id, email, password FROM users`)
-	if err != nil {
-		http.Error(w, "Ошибка чтения из базы данных", http.StatusInternalServerError)
-		return
-	}
-	defer rows.Close()
-
-	var users []User
-	for rows.Next() {
-		var user User
-		if err := rows.Scan(&user.ID, &user.Email, &user.Password); err != nil {
-			http.Error(w, "Ошибка обработки данных", http.StatusInternalServerError)
-			return
-		}
-		users = append(users, user)
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(users)
-}
-
-func main() {
-	initDB()
-	defer db.Close()
-
-	// Setup CORS
-	cors := handlers.CORS(
-		handlers.AllowedOrigins([]string{"*"}),
-		handlers.AllowedMethods([]string{"GET", "POST"}),
-		handlers.AllowedHeaders([]string{"Content-Type"}),
-	)
-
-	// Register handlers
-	http.HandleFunc("/api/register", registerHandler)
-	http.HandleFunc("/api/login", loginHandler)
-	http.HandleFunc("/api/users", getUsersHandler)
-
-	// Start server with CORS middleware
-	port := os.Getenv("PORT")
-	if port == "" {
-		port = "8080"
-	}
-
-	fmt.Println("Go-сервер запущен на порту", port)
-	log.Fatal(http.ListenAndServe(":"+port, cors(http.DefaultServeMux)))
-}