Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

Stwórz pełnoprawną w pełni działającą aplikację społecznościowo-randkową w języku React…

  1. User

    Stwórz pełnoprawną w pełni działającą aplikację społecznościowo-randkową w języku React oraz Express. Użyj najlepszych bibliotek i najnowszych zagadnień, nie popełniaj błędów, podawaj pełny kod oraz tłumacz każdy krok.

  2. Claude Assistant

    Stworzenie pełnej aplikacji społecznościowo-randkowej to złożony projekt, który wymaga wielu komponentów. Przedstawię podstawową strukturę takiej aplikacji, skupiając się na kluczowych elementach.

    Aplikacja społecznościowo-randkowa: LoveConnect

    Poniżej znajduje się struktura projektu z najważniejszymi plikami:

    Frontend (React)

    // src/App.js
    import React from 'react';
    import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
    import { AuthProvider } from './contexts/AuthContext';
    import PrivateRoute from './components/PrivateRoute';
    import Navbar from './components/Navbar';
    import Home from './pages/Home';
    import Login from './pages/Login';
    import Register from './pages/Register';
    import Profile from './pages/Profile';
    import Matches from './pages/Matches';
    import Chat from './pages/Chat';
    import './App.css';
    
    function App() {
      return (
        <AuthProvider>
          <Router>
            <Navbar />
            <div className="container">
              <Routes>
                <Route path="/" element={<Home />} />
                <Route path="/login" element={<Login />} />
                <Route path="/register" element={<Register />} />
                <Route path="/profile" element={<PrivateRoute><Profile /></PrivateRoute>} />
                <Route path="/matches" element={<PrivateRoute><Matches /></PrivateRoute>} />
                <Route path="/chat/:id" element={<PrivateRoute><Chat /></PrivateRoute>} />
              </Routes>
            </div>
          </Router>
        </AuthProvider>
      );
    }
    
    export default App;
    
    // src/contexts/AuthContext.js
    import React, { createContext, useState, useEffect } from 'react';
    import axios from 'axios';
    
    export const AuthContext = createContext();
    
    export const AuthProvider = ({ children }) => {
      const [currentUser, setCurrentUser] = useState(null);
      const [loading, setLoading] = useState(true);
    
      useEffect(() => {
        const token = localStorage.getItem('token');
        if (token) {
          axios.defaults.headers.common['Authorization'] = `Bearer ${token}`;
          fetchUser();
        } else {
          setLoading(false);
        }
      }, []);
    
      const fetchUser = async () => {
        try {
          const res = await axios.get('/api/users/me');
          setCurrentUser(res.data);
        } catch (err) {
          localStorage.removeItem('token');
        } finally {
          setLoading(false);
        }
      };
    
      const login = async (email, password) => {
        const res = await axios.post('/api/auth/login', { email, password });
        localStorage.setItem('token', res.data.token);
        axios.defaults.headers.common['Authorization'] = `Bearer ${res.data.token}`;
        await fetchUser();
        return res.data;
      };
    
      const register = async (userData) => {
        const res = await axios.post('/api/auth/register', userData);
        localStorage.setItem('token', res.data.token);
        axios.defaults.headers.common['Authorization'] = `Bearer ${res.data.token}`;
        await fetchUser();
        return res.data;
      };
    
      const logout = () => {
        localStorage.removeItem('token');
        delete axios.defaults.headers.common['Authorization'];
        setCurrentUser(null);
      };
    
      const value = {
        currentUser,
        login,
        register,
        logout,
        loading
      };
    
      return (
        <AuthContext.Provider value={value}>
          {!loading && children}
        </AuthContext.Provider>
      );
    };
    
    // src/pages/Register.js
    import React, { useState, useContext } from 'react';
    import { useNavigate } from 'react-router-dom';
    import { AuthContext } from '../contexts/AuthContext';
    
    const Register = () => {
      const [formData, setFormData] = useState({
        name: '',
        email: '',
        password: '',
        birthdate: '',
        gender: '',
        interestedIn: '',
        bio: '',
        location: ''
      });
      const [error, setError] = useState('');
      const { register } = useContext(AuthContext);
      const navigate = useNavigate();
    
      const handleChange = (e) => {
        setFormData({ ...formData, [e.target.name]: e.target.value });
      };
    
      const handleSubmit = async (e) => {
        e.preventDefault();
        try {
          await register(formData);
          navigate('/profile');
        } catch (err) {
          setError(err.response?.data?.message || 'Wystąpił błąd podczas rejestracji');
        }
      };
    
      return (
        <div className="register-container">
          <h2>Zarejestruj się</h2>
          {error && <div className="error">{error}</div>}
          <form onSubmit={handleSubmit}>
            <div className="form-group">
              <label>Imię</label>
              <input
                type="text"
                name="name"
                value={formData.name}
                onChange={handleChange}
                required
              />
            </div>
            <div className="form-group">
              <label>Email</label>
              <input
                type="email"
                name="email"
                value={formData.email}
                onChange={handleChange}
                required
              />
            </div>
            <div className="form-group">
              <label>Hasło</label>
              <input
                type="password"
                name="password"
                value={formData.password}
                onChange={handleChange}
                required
              />
            </div>
            <div className="form-group">
              <label>Data urodzenia</label>
              <input
                type="date"
                name="birthdate"
                value={formData.birthdate}
                onChange={handleChange}
                required
              />
            </div>
            <div className="form-group">
              <label>Płeć</label>
              <select name="gender" value={formData.gender} onChange={handleChange} required>
                <option value="">Wybierz płeć</option>
                <option value="male">Mężczyzna</option>
                <option value="female">Kobieta</option>
                <option value="other">Inna</option>
              </select>
            </div>
            <div className="form-group">
              <label>Zainteresowany/a</label>
              <select name="interestedIn" value={formData.interestedIn} onChange={handleChange} required>
                <option value="">Wybierz</option>
                <option value="male">Mężczyznami</option>
                <option value="female">Kobietami</option>
                <option value="both">Obiema płciami</option>
              </select>
            </div>
            <div className="form-group">
              <label>O mnie</label>
              <textarea
                name="bio"
                value={formData.bio}
                onChange={handleChange}
                rows="4"
              />
            </div>
            <div className="form-group">
              <label>Lokalizacja</label>
              <input
                type="text"
                name="location"
                value={formData.location}
                onChange={handleChange}
              />
            </div>
            <button type="submit" className="btn-primary">Zarejestruj się</button>
          </form>
        </div>
      );
    };
    
    export default Register;
    

    Backend (Express)

    // server.js
    const express = require('express');
    const mongoose = require('mongoose');
    const cors = require('cors');
    const dotenv = require('dotenv');
    const path = require('path');
    
    // Ładowanie zmiennych środowiskowych
    dotenv.config();
    
    // Import tras
    const authRoutes = require('./routes/auth');
    const userRoutes = require('./routes/users');
    const matchRoutes = require('./routes/matches');
    const messageRoutes = require('./routes/messages');
    
    const app = express();
    
    // Middleware
    app.use(cors());
    app.use(express.json());
    
    // Połączenie z bazą danych
    mongoose.connect(process.env.MONGO_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })
    .then(() => console.log('Połączono z bazą danych MongoDB'))
    .catch(err => console.error('Błąd połączenia z bazą danych:', err));
    
    // Trasy API
    app.use('/api/auth', authRoutes);
    app.use('/api/users', userRoutes);
    app.use('/api/matches', matchRoutes);
    app.use('/api/messages', messageRoutes);
    
    // Serwowanie statycznych plików w produkcji
    if (process.env.NODE_ENV === 'production') {
      app.use(express.static(path.join(__dirname, '../client/build')));
      
      app.get('*', (req, res) => {
        res.sendFile(path.join(__dirname, '../client/build', 'index.html'));
      });
    }
    
    // Obsługa błędów
    app.use((err, req, res, next) => {
      console.error(err.stack);
      res.status(500).send({ message: 'Wystąpił błąd serwera!' });
    });
    
    const PORT = process.env.PORT || 5000;
    
    const server = app.listen(PORT, () => {
      console.log(`Serwer działa na porcie ${PORT}`);
    });
    
    // Konfiguracja Socket.io dla czatu w czasie rzeczywistym
    const io = require('socket.io')(server, {
      cors: {
        origin: process.env.NODE_ENV === 'production' ? false : ['http://localhost:3000'],
        methods: ['GET', 'POST']
      }
    });
    
    io.on('connection', (socket) => {
      console.log('Nowe połączenie socket.io');
      
      socket.on('join', (userId) => {
        socket.join(userId);
        console.log(`Użytkownik ${userId} dołączył do swojego pokoju`);
      });
      
      socket.on('sendMessage', async ({ senderId, receiverId, content }) => {
        try {
          // Zapisz wiadomość w bazie danych
          const message = new Message({
            sender: senderId,
            receiver: receiverId,
            content
          });
          await message.save();
          
          // Wyślij wiadomość do odbiorcy
          io.to(receiverId).emit('newMessage', {
            _id: message._id,
            sender: senderId,
            content,
            createdAt: message.createdAt
          });
        } catch (err) {
          console.error('Błąd wysyłania wiadomości:', err);
        }
      });
      
      socket.on('disconnect', () => {
        console.log('Użytkownik rozłączony');
      });
    });
    
    // models/User.js
    const mongoose = require('mongoose');
    const bcrypt = require('bcryptjs');
    
    const UserSchema = new mongoose.Schema({
      name: {
        type: String,
        required: true
      },
      email: {
        type: String,
        required: true,
        unique: true
      },
      password: {
        type: String,
        required: true
      },
      birthdate: {
        type: Date,
        required: true
      },
      gender: {
        type: String,
        enum: ['male', 'female', 'other'],
        required: true
      },
      interestedIn: {
        type: String,
        enum: ['male', 'female', 'both'],
        required: true
      },
      bio: {
        type: String,
        default: ''
      },
      location: {
        type: String,
        default: ''
      },
      photos: [{
        type: String
      }],
      likes: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
      }],
      dislikes: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
      }]
    }, { timestamps: true });
    
    // Metoda przed zapisem - hashowanie hasła
    UserSchema.pre('save', async function(next) {
      if (!this.isModified('password')) return next();
      
      try {
        const salt = await bcrypt.genSalt(10);
        this.password = await bcrypt.hash(this.password, salt);
        next();
      } catch (err) {
        next(err);
      }
    });
    
    // Metoda porównywania hasła
    UserSchema.methods.comparePassword = async function(candidatePassword) {
      return await bcrypt.compare(candidatePassword, this.password);
    };
    
    module.exports = mongoose.model('User', UserSchema);
    
    // routes/auth.js
    const express = require('express');
    const router = express.Router();
    const jwt = require('jsonwebtoken');
    const User = require('../models/User');
    const { check, validationResult } = require('express-validator');
    
    // Rejestracja użytkownika
    router.post('/register', [
      check('name', 'Imię jest wymagane').not().isEmpty(),
      check('email', 'Podaj prawidłowy adres email').isEmail(),
      check('password', 'Hasło musi mieć co najmniej 6 znaków').isLength({ min: 6 }),
      check('birthdate', 'Data urodzenia jest wymagana').not().isEmpty(),
      check('gender', 'Płeć jest wymagana').isIn(['male', 'female', 'other']),
      check('interestedIn', 'Preferencje są wymagane').isIn(['male', 'female', 'both'])
    ], async (req, res) => {
      // Sprawdzenie błędów walidacji
      const errors = validationResult(req);
      if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
      }
    
      const { name, email, password, birthdate, gender, interestedIn, bio, location } = req.body;
    
      try {
        // Sprawdzenie czy użytkownik już istnieje
        let user = await User.findOne({ email });
        if (user) {
          return res.status(400).json({ message: 'Użytkownik z tym adresem email już istnieje' });
        }
    
        // Sprawdzenie wieku (minimum 18 lat)
        const birthDate = new Date(birthdate);
        const today = new Date();
        let age = today.getFullYear() - birthDate.getFullYear();
        const monthDiff = today.getMonth() - birthDate.getMonth();
        
        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
          age--;
        }
        
        if (age < 18) {
          return res.status(400).json({ message: 'Musisz mieć co najmniej 18 lat, aby się zarejestrować' });
        }
    
        // Tworzenie nowego użytkownika
        user = new User({
          name,
          email,
          password,
          birthdate: birthDate,
          gender,
          interestedIn,
          bio: bio || '',
          location: location || ''
        });
    
        await user.save();
    
        // Generowanie tokenu JWT
        const payload = {
          user: {
            id: user.id
          }
        };
    
        jwt.sign(
          payload,
          process.env.JWT_SECRET,
          { expiresIn: '7d' },
          (err, token) => {
            if (err) throw err;
            res.json({ token });
          }
        );
      } catch (err) {
        console.error(err.message