implement wihslist and secret santa

backend/src/db_client.py

@@ -1,18 +1,46 @@
 from enum import Enum
 import mysql.connector
 import os
+import random
 from mysql.connector import pooling
 
 STARTUP_TABLE_CREATION_QUERIES = {
     "users": """CREATE TABLE IF NOT EXISTS users (
         Name varchar(255),
         Attendance bool,
-        Password VARCHAR(2048)
+        Password VARCHAR(2048),
+        WishListUrl VARCHAR(2048)
     );""",
     "sessions": """CREATE TABLE IF NOT EXISTS sessions (
         Token VARCHAR(2048),
         Name varchar(255)
     );""",
+    "hosting": """CREATE TABLE IF NOT EXISTS hosting (
+        id SERIAL,
+        Name varchar(255),
+        Capacity INT,
+        reservedBy varchar(255)
+    );""",
+    "santa": """CREATE TABLE IF NOT EXISTS santa (
+        Name varchar(255),
+        Santa varchar(255)
+    );""",
+}
+
+INJECT_TABLE_CREATION_QUERIES = {
+    "hosting": """
+INSERT INTO hosting (Name, Capacity, reservedBy)
+SELECT name, capacity, reservedBy FROM (
+    SELECT 'Матрац 160см' AS name, 2 AS capacity, '' AS reservedBy
+    UNION ALL
+    SELECT 'Кровать 120см', 2, ''
+    UNION ALL
+    SELECT 'Матрац 90см', 1, ''
+    UNION ALL
+    SELECT 'Диван', 1, ''
+) AS temp
+WHERE NOT EXISTS (SELECT 1 FROM hosting WHERE Name = temp.name);
+""",
 }
 
 class Severity(Enum):
@@ -33,6 +61,7 @@ class DBClient:
         self.pool = self.create_pool()  # Create a connection pool
         
         self.initialize_database()
+        self.initialize_secret_santa()  # Initialize Secret Santa
 
     def validate_env_variables(self):
         if not self.db_server or not self.db_port or not self.password or not self.database:
@@ -53,6 +82,59 @@ class DBClient:
     def initialize_database(self):
         self.query(STARTUP_TABLE_CREATION_QUERIES['users'])
         self.query(STARTUP_TABLE_CREATION_QUERIES['sessions'])
+        self.query(STARTUP_TABLE_CREATION_QUERIES['hosting'])
+        self.query(INJECT_TABLE_CREATION_QUERIES['hosting'])
+
+    def initialize_secret_santa(self):
+        table_exists = self.query("SHOW TABLES LIKE 'santa';")
+
+        if not table_exists:
+            self.query(STARTUP_TABLE_CREATION_QUERIES['santa'])
+
+        count_query = self.query('SELECT COUNT(*) FROM santa;')
+        if count_query[0][0] > 0:
+            self.app.logger.warning('The santa table is not empty. No assignments will be made.')
+            return
+        
+        attendees = self.query('SELECT Name FROM users WHERE Attendance = 1;')
+
+        if not attendees:
+            return
+        
+        attendees = [user[0] for user in attendees] 
+        couples = [("Тюлень", "Тюлениха"), ("Медведь", "Ксения")]
+        
+        max_attempts = 1000 
+
+        for attempt in range(max_attempts):
+            shuffled_attendees = attendees.copy()
+            random.shuffle(shuffled_attendees)
+            
+            santa_assignments = {}
+            valid = True
+
+            for index, user in enumerate(shuffled_attendees):
+                prev_user = shuffled_attendees[index - 1]
+                next_user = shuffled_attendees[(index + 1) % len(shuffled_attendees)]
+                
+                if any(user in couple and (prev_user in couple or next_user in couple) for couple in couples):
+                    valid = False
+                    break
+
+                santa_assignments[user] = prev_user
+
+            if valid:
+                break
+
+        else:
+            self.app.logger.warning('Could not find valid Santa assignments after multiple attempts.')
+            return
+
+        self.app.logger.info(f'Santa assignments: {santa_assignments}')
+
+        for user, santa in santa_assignments.items():
+            self.query('INSERT INTO santa (Name, Santa) VALUES (%s, %s);', (user, santa))
+ 
 
     def query(self, query_str, params=None):    
         max_retries = 3
@@ -63,7 +145,7 @@ class DBClient:
                 connection = self.pool.get_connection()
                 with connection.cursor() as cursor:
                     cursor.execute(query_str, params)
-                    if 'SELECT' in query_str:
+                    if 'SELECT' in query_str or 'SHOW' in query_str:
                         results = cursor.fetchall()
                         self.app.logger.info(f'Query results: {results}')
                         return results

backend/src/hosting.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+'''
+hosting.py is a source for all hosting endpoints.
+'''
+
+from flask import request, jsonify
+import mysql.connector
+
+def registerHostingEndpoints(app, database):
+    
+    @app.route('/hosting', methods=['GET'])
+    def get_hosting():
+        try:
+            app.logger.info('Fetching hosting data')
+            query = "SELECT id, Name AS name, Capacity AS capacity, reservedBy FROM hosting"
+            result = database.query(query)  # Adjust this depending on your database implementation
+
+            # Transform the result into the required structure
+            furniture_list = [
+                {
+                    "id": row[0],
+                    "name": row[1],
+                    "capacity": row[2],
+                    "reservedBy": row[3]
+                } for row in result
+            ]
+            
+            hosting_data = {
+                "furniture": furniture_list
+            }
+
+            app.logger.info(f'Fetched data: {hosting_data}')
+            return jsonify(hosting_data), 200
+        except mysql.connector.Error as err:
+            app.logger.error(f"Database error: {err}")
+            return jsonify({"error": "Database error occurred"}), 500
+        except Exception as e:
+            app.logger.error(f"Unexpected error: {e}")
+            return jsonify({"error": "Internal server error"}), 500
+
+    
+    @app.route('/hosting/<int:id>', methods=['POST'])
+    def update_hosting(id):
+        data = request.get_json()
+        reserved_by = data.get('reservedBy')
+        
+        if not reserved_by:
+            return jsonify({"error": "reservedBy field is required"}), 400
+
+        try:
+            app.logger.info(f'Updating hosting with ID {id} to reserved by {reserved_by}')
+            query = "UPDATE hosting SET reservedBy=%s WHERE id=%s"
+            params = (reserved_by, id)
+            database.query(query, params)  # Adjust this depending on your database implementation
+            app.logger.info(f'Successfully updated hosting ID {id}')
+            return jsonify({"message": "Successfully updated"}), 200
+        except mysql.connector.Error as err:
+            app.logger.error(f"Database error: {err}")
+            return jsonify({"error": "Database error occurred"}), 500
+        except Exception as e:
+            app.logger.error(f"Unexpected error: {e}")
+            return jsonify({"error": "Internal server error"}), 500
+
+    @app.route('/hosting/<int:id>/unreserve', methods=['POST'])
+    def unreserve_item(id):
+        token = request.json.get('token')
+
+        if not token:
+            return jsonify(success=False, message="Token is required"), 400
+
+        query_session = "SELECT * FROM sessions WHERE Token=%s"
+
+        try:
+            result = database.query(query_session, params=(token,))
+            if not result:
+                return jsonify(success=False, message="Token is invalid or expired"), 401
+            
+            user_name = result[0][1]  # Assuming user name is in the second column of session result
+            
+            # Check if the item is reserved by the user
+            reservation_check_query = """
+            SELECT * FROM hosting WHERE id = %s AND reservedBy = %s
+            """
+            reservation_check_result = database.query(reservation_check_query, params=(id, user_name))
+            
+            if not reservation_check_result:
+                return jsonify(success=False, message="Item is not reserved by you or does not exist"), 404
+            
+            # Proceed to unreserve the item
+            unreserve_query = """
+            UPDATE hosting SET reservedBy = '' WHERE id = %s
+            """
+            database.query(unreserve_query, params=(id,))
+            
+            return jsonify(success=True, message="Item unreserved successfully"), 200
+
+        except Exception as e:
+            return jsonify(success=False, message=str(e)), 500
+
+    @app.route('/hosting/create', methods=['POST'])
+    def create_and_reserve_item():
+        token = request.json.get('token')
+        name = request.json.get('name')           # Name of the item to create
+        capacity = request.json.get('capacity')   # Capacity of the item
+
+        if not token:
+            return jsonify(success=False, message="Token is required"), 400
+        if not name:
+            return jsonify(success=False, message="Забыл имя"), 400
+        if capacity is None:
+            return jsonify(success=False, message="Забыл количество мест"), 400
+
+        query_session = "SELECT * FROM sessions WHERE Token=%s"
+
+        try:
+            # Verify user by token
+            result = database.query(query_session, params=(token,))
+            if not result:
+                return jsonify(success=False, message="Token is invalid or expired"), 401
+            
+            user_name = result[0][1]  # Assuming user name is in the second column of session result
+            
+            # Check if the item already exists
+            item_check_query = "SELECT * FROM hosting WHERE Name = %s"
+            item_check_result = database.query(item_check_query, params=(name,))
+            
+            if item_check_result:  # If an item with the same name already exists
+                return jsonify(success=False, message="Уже существует"), 400
+
+            # Insert the new item and reserve it for the user
+            insert_query = """
+            INSERT INTO hosting (Name, Capacity, reservedBy)
+            VALUES (%s, %s, %s)
+            """
+            params = (name, capacity, user_name)  # Reserve the item to the user
+            database.query(insert_query, params=params)
+
+            return jsonify(success=True, message="Создано"), 201
+
+        except Exception as e:
+            return jsonify(success=False, message=str(e)), 500
+
+
+

backend/src/server.py

@@ -10,6 +10,7 @@ from flask_cors import CORS
 from dotenv import load_dotenv
 from db_client import DBClient
 from user import registerUserEndpoints
+from hosting import registerHostingEndpoints
 import logging
 
 load_dotenv()
@@ -23,6 +24,7 @@ allowed_origins = [
 CORS(app, resources={r"*": {"origins": allowed_origins}})  # Only allow example.com
 database = DBClient(app)
 registerUserEndpoints(app=app, database=database)
+registerHostingEndpoints(app=app, database=database)
 
 if __name__ == "__main__":
     app.run(debug=True)

backend/src/user.py

@@ -133,11 +133,96 @@ def registerUserEndpoints(app, database):
             
             attendance_status = attendance_result[0][0]
             
-            return jsonify(success=True, attendance=bool(attendance_status)), 200
+            return jsonify(success=True, attendance=attendance_status), 200
+
+        except Exception as e:
+            return jsonify(success=False, message=str(e)), 500
+
+    @app.route('/users/attendance/all', methods=['GET'])
+    def get_attendance_all():
+        token = request.args.get('token')
+
+        if not token:
+            return jsonify(success=False, message="Token is required"), 400
+
+        query_session = "SELECT * FROM sessions WHERE Token=%s"
+        
+        try:
+            result = database.query(query_session, params=(token,))
+            if not result:
+                return jsonify(success=False, message="Token is invalid or expired"), 401
+
+            attendance_query = "SELECT Name, Attendance FROM users"
+            attendance_result = database.query(attendance_query)
+
+            if not attendance_result:
+                return jsonify(success=False, message="No users found"), 404
+            
+            attendance_list = [{"name": row[0], "attendance": row[1]} for row in attendance_result]
+            
+            return jsonify(success=True, attendance_list=attendance_list), 200
 
         except Exception as e:
             return jsonify(success=False, message=str(e)), 500
 
 
+    @app.route('/users/wishlist', methods=['PUT'])
+    def update_wishlist():
+        data = request.json
+        token = data.get('token')
+        wishlist_url = data.get('wishlist')
 
+        if wishlist_url is None:
+            return jsonify(success=False, message="Wishlist URL is required"), 400
 
+        query_session = "SELECT * FROM sessions WHERE Token=%s"        
+        try:
+            result = database.query(query_session, params=(token,))
+            if not result:
+                return jsonify(success=False, message="Token is invalid or expired"), 401
+
+            user_name = result[0][1] 
+            wishlist_query = "UPDATE users SET WishListUrl = %s WHERE Name = %s"
+            update_result = database.query(wishlist_query, params=(wishlist_url, user_name))
+
+            return jsonify(success=True, message="WishListUrl updated successfully"), 200
+
+        except Exception as e:
+            return jsonify(success=False, message=str(e)), 500
+
+    @app.route('/users/santa', methods=['GET'])
+    def get_santainfo():
+        token = request.args.get('token')
+
+        if not token:
+            return jsonify(success=False, message="Token is required"), 400
+
+        query_session = "SELECT * FROM sessions WHERE Token=%s"
+        
+        try:
+            result = database.query(query_session, params=(token,))
+            if not result:
+                return jsonify(success=False, message="Token is invalid or expired"), 401
+
+            user_name = result[0][1]
+            
+            santa_query = "SELECT Name FROM santa WHERE Santa = %s"
+            santa_result = database.query(santa_query, params=(user_name,))
+            
+            if not santa_result:
+                return jsonify(success=False, message=f"User's {user_name} Santa info not found"), 404
+
+            santa_to = santa_result[0][0]
+
+            wishlist_query = "SELECT WishListUrl FROM users WHERE Name = %s"
+            wishlist_result = database.query(wishlist_query, params=(santa_to,))
+
+            santa_info = {
+                "santa_to": santa_to,
+                "wishlist": wishlist_result[0][0]
+            }
+            
+            return jsonify(success=True, santa_info=santa_info), 200
+
+        except Exception as e:
+            return jsonify(success=False, message=str(e)), 500

frontend/src/App.css

@@ -264,6 +264,15 @@ nav ul {
   justify-content: space-around; /* Space the items evenly */
 }
 
+nav ul li p {
+  color: white;
+  text-decoration: none;  
+}
+
+nav ul li p:hover {
+  text-decoration: underline;
+}
+
 nav li {
   display: inline;
 }

frontend/src/App.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import { useState } from 'react';
 import './App.css';
 import Greeting from './components/Greeting';
 import Hosting from './components/Hosting';
@@ -6,17 +6,31 @@ import InitialSetup from './components/InitialSetup';
 import Program from './components/Program';
 import Snowflakes from './components/Snowflakes';
 import { FullScreenLoading } from './components/Loading';
+import SecretSanta from './components/SecretSanta';
+import Suggestions from './components/Suggestions';
+import AttendanceTable from './components/AttendnaceTable';
 
 function App() {
   const [isNavOpen, setIsNavOpen] = useState(false);
 
+  const handleLogout = () => {
+    const cookies = document.cookie.split(";");
+
+    for (let cookie of cookies) {
+      const cookieName = cookie.split("=")[0].trim();
+      // Set the cookie's expiration date to the past to delete it
+      document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/;`;
+    }
+    window.location.reload();
+  };
+
   const toggleNav = () => {
     setIsNavOpen(!isNavOpen);
   };
 
   return (
     <>
-      <FullScreenLoading/>
+      <FullScreenLoading />
       <Snowflakes />
       <InitialSetup />
 
@@ -35,6 +49,18 @@ function App() {
           <li>
             <a href="#program">Программа</a>
           </li>
+          <li>
+            <a href="#suggestions">Пожелания</a>
+          </li>
+          <li>
+            <a href="#santa">Secret Santa</a>
+          </li>
+          <li>
+            <a href="#attendance-table">Кто празднует?</a>
+          </li>
+          <li>
+            <button onClick={() => handleLogout()}>Выйти</button>
+          </li>
         </ul>
       </nav>
 
@@ -47,6 +73,15 @@ function App() {
       <div id="program">
         <Program />
       </div>
+      <div id="suggestions">
+        <Suggestions />
+      </div>
+      <div id="santa">
+        <SecretSanta />
+      </div>
+      <div id="attendance-table">
+        <AttendanceTable />
+      </div>
     </>
   );
 }

frontend/src/NotificationContext.tsx

@@ -2,7 +2,7 @@
 
 import React, { createContext, useContext, useState } from 'react';
 
-type NotificationType = 'success' | 'error';
+export type NotificationType = 'success' | 'error';
 
 interface NotificationContextType {
   notify: (message: string, type: NotificationType) => void;

frontend/src/components/AttendnaceTable.tsx

@@ -0,0 +1,63 @@
+import { useEffect, useState } from "react";
+import useFetchUser from "../utils/fetchUser";
+import CenteredContainer from "./ChildrenContainer";
+import type { User } from "../types";
+
+const processAttendance = (attendance: boolean | null): string => {
+    if (attendance == null) {
+        return "Пока не ответил"
+    }
+    return (attendance == true) ? "Да!" : "Не в этот раз"
+}
+
+function AttendanceTable() {
+
+    const {getAttendanceAll} = useFetchUser()
+    const [userAttendanceData, setUserAttendnaceData] = useState<User[]>([])
+
+    const fetchUserData = async () => {
+        const userData = await getAttendanceAll()
+        setUserAttendnaceData(userData)
+    }
+
+    const handleRefresh = () => {
+        fetchUserData()
+    }
+
+    useEffect(() => {
+        fetchUserData()
+    }, [])
+
+    return (
+        <>
+            <CenteredContainer>
+                <h2>Кто празднует?</h2>
+                {userAttendanceData && (
+                    <div className="table-wrapper">
+                        <table>
+                            <thead>
+                                <tr>
+                                    <th>Пятка</th>
+                                    <th>Празднует с нами?</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {userAttendanceData && userAttendanceData.map((item) => (
+                                    <tr>
+                                        <td>{item.name}</td>
+                                        <td>{processAttendance(item.attendance)}</td>
+                                    </tr>
+                                ))}
+                            </tbody>
+                        </table>
+                        <p className="scroll-instruction">Таблицу можно скроллить</p>
+                    </div>
+                )}
+                <br/>
+                <button onClick={handleRefresh}>Обновить</button>
+            </CenteredContainer>
+        </>
+    )
+}
+
+export default AttendanceTable;

frontend/src/components/Greeting.tsx

@@ -1,17 +1,51 @@
 import { useCookies } from "react-cookie";
 import CenteredContainer from "./ChildrenContainer";
 import useFetchUser from "../utils/fetchUser";
+import type React from "react";
+import ApologyMessage from "./Attendance";
+import { useState } from "react";
 
-function Greeting() {
+const Attendance: React.FC = () => {
-    const [cookie] = useCookies<string>(['userName'])
+    const { updateAttendance, getAttendance } = useFetchUser()
-    const userName = cookie.userName;
+    const [attendance, setAttendance] = useState<boolean | null>(null)
-    const { updateAttendance } = useFetchUser()
+    const fetchAttendance = async () => {
+            const is = await getAttendance()
+            setAttendance(is)
+        }
+    fetchAttendance()
 
     const handleUpdate = async (status: boolean) => {
         await updateAttendance(status)
         window.location.reload();
     }
 
+    if (attendance == false) {
+        return (<ApologyMessage/>)
+    }
+
+    return (
+        <>
+            {attendance == null && (
+                <>
+                    <h3>Присоеденишься?</h3>
+                    <p>(Можно и потом ответить)</p>
+                    <button style={localStyles.buttonOk} onClick={() => handleUpdate(true)}>Да!</button>
+                    <button style={localStyles.buttonNok} onClick={() => handleUpdate(false)}>Не смогу в этот раз</button>
+                </>
+            )}
+            {attendance == true && (
+                <>
+                <h3>Круто! Ты с нами!</h3>
+                <p>Если все же по разным обстоятельствам ты не сможешь/не захочешь, то всегда можно передумать</p>
+                <button style={localStyles.buttonNok} onClick={() => handleUpdate(false)}>Все же никак</button>
+                </>)}
+        </>)
+}
+
+function Greeting() {
+    const [cookie] = useCookies<string>(['userName'])
+    const userName = cookie.userName;
+
     return (
         <>
             <CenteredContainer>
@@ -24,11 +58,9 @@ function Greeting() {
                     Приглашаем тебя отпраздновать предстоящий Новый Год <b>2025-2026</b> с нами в сосновой избе, в которой, ко всему прочему, будет праздноваться годовщина нашей жизни в ней!
 
                     Наши двери открыты с <b>30.12.2025</b>. Праздник обычно длится до <b>01.01.2025</b>, но если тебе или твоим спутникам будет безумно плохо, то можно остаться и до второго числа.
-                <h3>Присоеденишься?</h3>
+
-                <p>(Можно и потом ответить)</p>
-                <button style={localStyles.buttonOk} onClick={() => handleUpdate(true)}>Да!</button>
-                <button style={localStyles.buttonNok}onClick={() => handleUpdate(false)}>Не смогу в этот раз</button>
                 </p>
+                <Attendance/>
             </CenteredContainer>
         </>
     )

frontend/src/components/Hosting.tsx

@@ -1,43 +1,82 @@
 import useFetchHosting from "../utils/fetchHosting";
-import { useNotification } from "../NotificationContext";
+import { useNotification, type NotificationType } from "../NotificationContext";
 import { useCookies } from "react-cookie";
 import CenteredContainer from "./ChildrenContainer";
+import { useState } from "react";
 
 
 interface ReserveButtonProps {
     update: (name: string, id: number) => void,
+    unreserve: (token: string, id: number) => void,
     reservedBy: string,
+    notify: (message: string, type: NotificationType) => void,
     id: number,
 }
 
 const ReserveButton: React.FC<ReserveButtonProps> = (props) => {
-    const { reservedBy, update, id } = props;
+    const { reservedBy, update, id, unreserve, notify } = props;
     const [cookie] = useCookies<string>(['userName'])
+    const [tokenCookie] = useCookies<string>(['apiToken'])
     const userName = cookie.userName;
     const isReserved = reservedBy !== '';
-    const notify = useNotification();
 
-    const handleReserve = async () => {
+    const handleReserve = async (name: string) => {
         try {
-            await update(userName, id);
+            await update(name, id);
-            notify(`Успешно забронировано для ${userName}`, 'success');
+            notify(`Успешно забронировано для ${name}`, 'success');
         } catch (error) {
             notify(`Не удалось забронировать: ${error instanceof Error ? error.message : 'Unknown error'}`, 'error');
         }
     };
 
+    const handleUnreserve = async () => {
+        try {
+            await unreserve(tokenCookie.apiToken, id);
+            notify(`Удалось разбронировать ${name}`, 'success');
+        } catch (error) {
+            notify(`Не удалось разбронировать: ${error instanceof Error ? error.message : 'Unknown error'}`, 'error');
+        }
+    }
+
     return (
         <>
-            <button onClick={handleReserve} disabled={isReserved}>
+            <button onClick={() => handleReserve(userName)} disabled={isReserved}>
                 {isReserved ? `${reservedBy}` : 'Занять'}
             </button>
+            {(reservedBy == userName) && (
+                <button onClick={() => handleUnreserve()} disabled={false}>❌</button>
+            )}
         </>
     );
 };
 
-function Hosting() {
 
-    const { data, error, loading, update } = useFetchHosting();
+const Hosting = () => {
+    const { data, error, loading, update, unreserveHosting, createHosting } = useFetchHosting();
+    const [name, setName] = useState('');
+    const [capacity, setCapacity] = useState('');
+    const [tokenCookie] = useCookies<string>(['apiToken'])
+    const notify = useNotification();
+
+    const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
+        event.preventDefault(); // Prevent the default form submission
+
+        if (!name || !capacity) {
+            notify('Надо заполнить все поля', 'error');
+            return;
+        }
+        try {
+            await createHosting(tokenCookie.apiToken, name, Number(capacity));
+            
+            // Reset form fields
+            setName('');
+            setCapacity('');
+            notify('Удалось создать!', 'success');
+        } catch (error) {
+            notify(`Не удалось создать: ${error instanceof Error ? error.message : 'Unknown error'}`, 'error');
+        }
+    };
+
     return (
         <>
             <CenteredContainer>
@@ -50,35 +89,66 @@ function Hosting() {
                     (Лучше бронировать заранее если есть надобность. Оба в 1-1,5км от нашего дома).
                     Спальные места:
                 </p>
-            {loading && <div>Loading...</div>}
+                {loading && <div>Loading...</div>}
-            {error && <div>Error</div>}
+                {error && <div>Error</div>}
-            {data && (
+                {data && (
-                <div className="table-wrapper scroll-indicator">
+                    <div className="table-wrapper scroll-indicator">
-                    <table>
+                        <table>
-                        <thead>
+                            <thead>
-                            <tr>
+                                <tr>
-                                <th>Размещение</th>
+                                    <th>Размещение</th>
-                                <th>Спальных мест</th>
+                                    <th>Спальных мест</th>
-                                <th>Бронирование</th>
+                                    <th>Бронирование</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {Object.entries(data).map(([id, item]) => (
-                                <tr key={id}>
-                                    <td>{item.name}</td>
-                                    <td>{item.capacity}</td>
-                                    <td>{<ReserveButton update={update} reservedBy={item.reservedBy} id={Number(id)} />}</td>
                                 </tr>
-                            ))}
+                            </thead>
-                        </tbody>
+                            <tbody>
-                    </table>
+                                {data.furniture && data.furniture.map((item) => (
-                    <p className="scroll-instruction">Таблицу можно скроллить</p>
+                                    <tr key={item.id}>
-                </div>
+                                        <td>{item.name}</td>
-            )}
+                                        <td>{item.capacity}</td>
+                                        <td>
+                                            <ReserveButton update={update} reservedBy={item.reservedBy} id={item.id} unreserve={unreserveHosting} notify={notify} />
+                                        </td>
+                                    </tr>
+                                ))}
+                            </tbody>
+                        </table>
+                        <p className="scroll-instruction">Таблицу можно скроллить</p>
+                    </div>
+                )}
+                Если вы хотите организовать себе свои спальные места и хотите, чтобы остальные это видели, вы можете добавить свое месо в таблицу.
+                <form onSubmit={handleSubmit}>
+                    <div>
+                        <label>
+                            Размещение:
+                            <input
+                                type="text"
+                                value={name}
+                                onChange={(e) => setName(e.target.value)}
+                                required
+                            />
+                        </label>
+                    </div>
+                    <div>
+                        <label>
+                            Спальных мест:
+                            <input
+                                type="number"
+                                value={capacity}
+                                onChange={(e) => setCapacity(e.target.value)}
+                                required
+                            />
+                        </label>
+                    </div>
+                    <button type="submit">
+                        {'Создать размещение'}
+                    </button>
+                </form>
+
             </CenteredContainer>
             <br />
         </>
     );
-}
+};
 
 export default Hosting;

frontend/src/components/InitialSetup.tsx

@@ -3,7 +3,6 @@ import { useCookies } from 'react-cookie';
 import { GUESTS } from '../constants/constants';
 import useFetchUser from '../utils/fetchUser'; // Import your custom hook
 import { useNotification } from '../NotificationContext';
-import ApologyMessage from './Attendance';
 import {Loading} from './Loading';
 
 const InitialSetup = () => {
@@ -13,9 +12,8 @@ const InitialSetup = () => {
     const [isSubmitted, setIsSubmitted] = useState(false);
     const [password, setPassword] = useState('');
     const [isPasswordSet, setIsPasswordSet] = useState(false); // To track if password is set
-    const [userAttendance, setUserAttendance] = useState<boolean | null>(null);
 
-    const { userSet, passwordCreate, signUser, validToken, getAttendance, isLoading } = useFetchUser(); // Destructure functions from the hook
+    const { userSet, passwordCreate, signUser, validToken, isLoading } = useFetchUser(); // Destructure functions from the hook
     const notify = useNotification();
 
     const checkUserPassword = async (name: string) => {
@@ -35,14 +33,8 @@ const InitialSetup = () => {
         setIsSubmitted(isTokenValid);
     };
 
-    const getUserAttendance = async () => {
-        const attendance = await getAttendance()
-        setUserAttendance(attendance)
-    }
-
     useEffect(() => {
         if (cookie.apiToken !== undefined) { 
-            getUserAttendance()
             validateToken();
         }
     }, [cookie.apiToken]); 
@@ -65,17 +57,12 @@ const InitialSetup = () => {
         }
         validateToken()
     };
-    
+
-    if (isSubmitted && userAttendance !== false) {
+    if (isSubmitted) {
         console.log('Selected', selectedName);
         return null; // or you can redirect to another component or page
     }
 
-    if (userAttendance == false) {
-        return (
-            <ApologyMessage/>
-        )
-    }
 
     if (isLoading) {
         return (

frontend/src/components/SecretSanta.tsx

@@ -0,0 +1,73 @@
+import CenteredContainer from "./ChildrenContainer";
+import useFetchUser from "../utils/fetchUser.tsx"
+import type { SantaInfo } from "../types/index";
+import { useState } from "react";
+import { useNotification } from "../NotificationContext.tsx";
+
+function SecretSanta() {
+
+    const { updateWishlist, getSantaInfo } = useFetchUser()
+    const [santaInfo, setSantaInfo] = useState<SantaInfo | null>(null)
+    const [wishListUrl, setWishListUrl] = useState('')
+
+    const notify = useNotification();
+
+    const fetchSecretSanta = async () => {
+        const santaInfoData = await getSantaInfo()
+        setSantaInfo(santaInfoData)
+    }
+    const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
+        event.preventDefault()
+        const updated = await updateWishlist(wishListUrl)
+
+        if (updated) {
+            notify('Вишлсит обновлен', 'success')
+        } else {
+            notify('Не удалось обновить вишлист, все вопросы к админу', 'error')
+        }
+    }
+
+    return (
+        <>
+            <CenteredContainer>
+                <h2>Secret Santa</h2>
+                <p className="mainText">
+                    {santaInfo ? (
+                        <>
+                            <p>Вы санта для Пятки: <b>{santaInfo.santa_to}</b></p>
+                            {santaInfo.wishlist ? (
+                                <h4>Пятка оставила вам <a href={santaInfo.wishlist}>вишлист</a></h4>
+                            ) : (
+                                <h4>Пятка не оставила вам вишлист, используйте свое воображение. Либо ждите, пока добавит...</h4>
+                            )}
+                        </>
+                    ) : (
+                        <button type="submit" onClick={fetchSecretSanta}>Показать чей я Санта!</button>
+                    )}
+                    <hr style={{ color: 'white'}}/>
+                    <b>Добавить свой вишлист</b>
+                    <form onSubmit={handleSubmit}>
+                        <div>
+                            <label>
+                                Ссылка на вишлист:
+                                <input
+                                    type="url"
+                                    value={wishListUrl}
+                                    onChange={(e) => setWishListUrl(e.target.value)}
+                                    required
+                                />
+                            </label>
+                            <button type="submit" style={{ margin: '20px 0.5em' }}>
+                                {'Отправить'}
+                            </button>
+                        </div>
+
+                    </form>
+
+                </p>
+            </CenteredContainer>
+        </>
+    )
+}
+
+export default SecretSanta;

frontend/src/components/Snowflakes.css

@@ -14,7 +14,7 @@
     top: -10%; /* Start above the top of the screen */
     color: white; /* Snowflake color */
     font-size: 1em; /* Size of the snowflake; adjust as needed */
-    opacity: 0.8; /* Transparency */
+    opacity: 0.5; /* Transparency */
     animation: fall linear infinite; /* Apply the fall animation */
 }
 

frontend/src/components/Snowflakes.tsx

@@ -13,7 +13,7 @@ const Snowflakes: React.FC = () => {
                     className="snowflake"
                     style={{
                         left: `${Math.random() * 100}vw`, // Random position across the full width
-                        animationDuration: `${Math.random() * 3 + 2}s`, // Random fall duration between 2s and 5s
+                        animationDuration: `${Math.random() * 20 + 10}s`, // Random fall duration between 2s and 5s
                     }}
                 >
                     ❄️

frontend/src/components/Suggestions.tsx

@@ -0,0 +1,19 @@
+import CenteredContainer from "./ChildrenContainer";
+
+function Sugegstions() {
+
+    return (
+        <>
+            <CenteredContainer>
+                <h2>Ваши предложения и пожелания</h2>
+                <p className="mainText">
+                    Тут вы можете оставить ваши пожелания/предпочтения для чего-либо. Хотите ли вы купить ракеты, поехат в какой-то из дней куда-то, какое основное блюдо вы бы хотели тд и тп...
+                    <br/><br/>
+                    Таблица в производстве... Ожидайте к <b>середине-концу ноября</b>
+                </p>
+            </CenteredContainer>
+        </>
+    )
+}
+
+export default Sugegstions;

frontend/src/types/index.d.ts

@@ -1,11 +1,22 @@
 // src/types/index.d.ts
 
 export interface Furniture {
-  reservedBy: string;
+    id: number; // Unique identifier for the furniture
-  name: string;
+    name: string; // Name of the furniture
-  capacity: number;
+    capacity: number; // Capacity of the furniture
+    reservedBy: string; // Name of the person who reserved the furniture
 }
 
 export interface Hosting {
-  [key: number]: Furniture;
+    furniture: Furniture[]; // Array of furniture items
+}
+
+export interface User {
+    attendance: boolean | null
+    name: string
+}
+
+export interface SantaInfo {
+  santa_to: string,
+  wishlist: string
 }

frontend/src/utils/fetchHosting.tsx

@@ -2,31 +2,8 @@ import { useState, useEffect } from 'react';
 import type { Hosting } from '../types';
 import { API_URL } from '../constants/constants';
 
-const mockData: Hosting = {
-    1: {
-        reservedBy: "",
-        name: "Матрац 160см",
-        capacity: 2
-    },
-    2: {
-        reservedBy: "Vasya",
-        name: "Кровать 120см",
-        capacity: 2
-    },
-    3: {
-        reservedBy: "",
-        name: "Матрац 90см",
-        capacity: 1
-    },
-    4: {
-        reservedBy: "",
-        name: "Диван",
-        capacity: 1
-    },
-};
-
 const useFetchHosting = () => {
-    const [data, setData] = useState(mockData);
+    const [data, setData] = useState<Hosting|null>(null);
     const [error, setError] = useState<string | null>(null);
     const [loading, setLoading] = useState(false);
 
@@ -69,12 +46,59 @@ const useFetchHosting = () => {
         }
     };
 
+    const unreserveHosting = async (token: string, id: number) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch(`${API_URL}/hosting/${id}/unreserve`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ token })
+            });
+
+            if (!response.ok) { // Check for non-200 responses
+                const errorText = await response.text(); // Capture the response text for further insights
+                throw new Error(`Error ${response.status}: ${errorText}`);
+            }
+
+            // Optional: Fetch the updated data after reservation
+            await fetchData();
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const createHosting = async (token: string, name: string, capacity: number) => {
+        setError(null);
+        try {
+            const response = await fetch(`${API_URL}/hosting/create`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ token, name, capacity })
+            });
+
+            if (!response.ok) { // Check for non-200 responses
+                const errorText = await response.text(); // Capture the response text for further insights
+                console.log(`Error ${response.status}: ${errorText}`)
+                throw new Error(`Error ${response.status}: ${errorText}`);
+            }
+
+            // Optional: Fetch the updated data after reservation
+            await fetchData();
+        } finally {
+        }
+    };
+
 
     useEffect(() => {
-        //fetchData(); // Initial fetch on mount
+        fetchData(); // Initial fetch on mount
     }, []);
 
-    return { data, error, loading, refetch: fetchData, update: updateData };
+    return { data, error, loading, refetch: fetchData, update: updateData, unreserveHosting, createHosting};
 };
 
 export default useFetchHosting;

frontend/src/utils/fetchUser.tsx

@@ -2,6 +2,7 @@ import { useCookies } from 'react-cookie';
 import { API_URL } from '../constants/constants';
 import { hashPassword } from './hashPassword';
 import { useState } from 'react';
+import type { User, SantaInfo } from '../types';
 
 const useFetchUser = () => {
     const [isLoading, setIsLoading] = useState(false)
@@ -114,6 +115,76 @@ const useFetchUser = () => {
         }
     }
 
+    const getAttendance = async (): Promise<boolean | null> => {
+        const token = apiCookie.apiToken
+        try {
+            const response = await fetch(`${API_URL}/users/attendance?token=${encodeURIComponent(token)}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            });
+
+            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+            const data = await response.json();
+
+            if (!data.success) throw new Error(data.message);
+
+            return data.attendance
+        } catch (error) {
+            console.error('Error retrieving attendance:', error);
+            return null
+        }
+    }
+
+    const updateWishlist = async (wishlistUrl: string): Promise<boolean> => {
+        const token = apiCookie.apiToken
+        try {
+            const response = await fetch(`${API_URL}/users/wishlist`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    token,
+                    wishlist: wishlistUrl,
+                }),
+            });
+
+            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+            const data = await response.json();
+
+            if (!data.success) throw new Error(data.message);
+
+            return true; // Attendance updated successfully
+        } catch (error) {
+            console.error('Error updating wishlist:', error);
+            return false; // Attendance update failed
+        }
+    }
+
+    const getSantaInfo = async (): Promise<SantaInfo | null> => {
+        const token = apiCookie.apiToken
+        try {
+            const response = await fetch(`${API_URL}/users/santa?token=${encodeURIComponent(token)}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            });
+  
+            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+            const data = await response.json();
+  
+            if (!data.success) throw new Error(data.message);
+  
+            return data.santa_info
+        } catch (error) {
+            console.error('Error retrieving attendance:', error);
+            return null
+        }
+    }
+
     const updateAttendance = async (attendanceStatus: boolean): Promise<boolean> => {
         const token = apiCookie.apiToken
         try {
@@ -140,10 +211,10 @@ const useFetchUser = () => {
         }
     }
 
-    const getAttendance = async (): Promise<boolean | null> => {
+    const getAttendanceAll = async (): Promise<User[]> => {
         const token = apiCookie.apiToken
         try {
-            const response = await fetch(`${API_URL}/users/attendance?token=${encodeURIComponent(token)}`, {
+            const response = await fetch(`${API_URL}/users/attendance/all?token=${encodeURIComponent(token)}`, {
                 method: 'GET',
                 headers: {
                     'Content-Type': 'application/json',
@@ -154,15 +225,16 @@ const useFetchUser = () => {
             const data = await response.json();
 
             if (!data.success) throw new Error(data.message);
-            
+
-            return data.attendance; // Returns attendance status (true/false)
+            return data.attendance_list
         } catch (error) {
             console.error('Error retrieving attendance:', error);
-            return null; // In case of error or if attendance status is not found
+            return []
         }
     }
 
-    return { userSet, passwordCreate, signUser, validToken, updateAttendance, getAttendance, isLoading };
+
+    return { userSet, passwordCreate, signUser, validToken, updateAttendance, updateWishlist, getAttendance, isLoading, getAttendanceAll, getSantaInfo };
 };
 
 export default useFetchUser;