OMEGA WORD

[lordmukendi]

Describe the bug

const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const dotenv = require('dotenv');

dotenv.config();
const app = express();
app.use(express.json());
app.use(cors());

// Connexion à la base de données MongoDB
mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true
}).then(() => console.log('MongoDB connecté'))
.catch(err => console.log(err));

// Modèle Utilisateur
const UserSchema = new mongoose.Schema({
username: String,
email: String,
password: String,
country: String,
createdAt: { type: Date, default: Date.now }
});

const User = mongoose.model('User', UserSchema);

// Route d'inscription
app.post('/register', async (req, res) => {
try {
const { username, email, password, country } = req.body;
const newUser = new User({ username, email, password, country });
await newUser.save();
res.status(201).json({ message: 'Utilisateur enregistré avec succès' });
} catch (error) {
res.status(500).json({ error: 'Erreur lors de l'inscription' });
}
});

// Route pour récupérer tous les utilisateurs
app.get('/users', async (req, res) => {
try {
const users = await User.find();
res.json(users);
} catch (error) {
res.status(500).json({ error: 'Erreur lors de la récupération des utilisateurs' });
}
});

const PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(Serveur en écoute sur le port ${PORT}));

Link to the Bolt URL that caused the error

https://bolt.new/~/sb1-wfsyuhdu

Validations

• Please make your project public or accessible by URL. This will allow anyone trying to help you to easily reproduce the issue and provide assistance.

Steps to reproduce

import React, { useState } from 'react';
import axios from 'axios';

const Register = () => {
const [formData, setFormData] = useState({
username: '',
email: '',
password: '',
country: ''
});

const handleChange = (e) => {
    setFormData({ ...formData, [e.target.name]: e.target.value });
};

const handleSubmit = async (e) => {
    e.preventDefault();
    try {
        await axios.post('http://localhost:5000/register', formData);
        alert('Inscription réussie !');
    } catch (error) {
        alert('Erreur lors de l'inscription');
    }
};

return (
    <div className="flex flex-col items-center justify-center min-h-screen bg-gray-100">
        <div className="bg-white p-8 rounded shadow-md w-96">
            <h2 className="text-xl font-bold mb-4">Inscription</h2>
            <form onSubmit={handleSubmit}>
                <input type="text" name="username" placeholder="Nom d'utilisateur" onChange={handleChange} className="w-full mb-2 p-2 border rounded" required />
                <input type="email" name="email" placeholder="Email" onChange={handleChange} className="w-full mb-2 p-2 border rounded" required />
                <input type="password" name="password" placeholder="Mot de passe" onChange={handleChange} className="w-full mb-2 p-2 border rounded" required />
                <input type="text" name="country" placeholder="Pays" onChange={handleChange} className="w-full mb-4 p-2 border rounded" required />
                <button type="submit" className="w-full bg-blue-500 text-white p-2 rounded">S'inscrire</button>
            </form>
        </div>
    </div>
);

};

export default Register;

Expected behavior

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const mongoose = require('mongoose');
const cors = require('cors');

dotenv.config();
const app = express();
const server = http.createServer(app);
const io = new Server(server, {
cors: {
origin: '*',
methods: ['GET', 'POST']
}
});

// Connexion MongoDB
mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true
}).then(() => console.log('MongoDB connecté pour la messagerie'))
.catch(err => console.log(err));

// Modèle Message
const MessageSchema = new mongoose.Schema({
sender: String,
receiver: String,
content: String,
timestamp: { type: Date, default: Date.now }
});
const Message = mongoose.model('Message', MessageSchema);

// Gestion des connexions Socket.io
io.on('connection', (socket) => {
console.log('Un utilisateur est connecté');

socket.on('sendMessage', async ({ sender, receiver, content }) => {
    const newMessage = new Message({ sender, receiver, content });
    await newMessage.save();
    io.emit('receiveMessage', newMessage);
});

socket.on('disconnect', () => {
    console.log('Un utilisateur s'est déconnecté');
});

});

const PORT = process.env.PORT || 5001;
server.listen(PORT, () => console.log(Serveur de messagerie en écoute sur le port ${PORT}));

Screen Recording / Screenshot

const express = require('express');
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
const cors = require('cors');
const dotenv = require('dotenv');

dotenv.config();
const app = express();
app.use(express.json());
app.use(cors());

// Route pour créer un paiement
app.post('/create-payment-intent', async (req, res) => {
try {
const { amount, currency } = req.body;
const paymentIntent = await stripe.paymentIntents.create({
amount,
currency,
payment_method_types: ['card'],
});
res.json({ clientSecret: paymentIntent.client_secret });
} catch (error) {
res.status(500).json({ error: error.message });
}
});

const PORT = process.env.PORT || 5002;
app.listen(PORT, () => console.log(Serveur de monétisation en écoute sur le port ${PORT}));

Platform

Browser name = Chrome
Full version = 132.0.0.0
Major version = 132
navigator.appName = Netscape
navigator.userAgent = Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 OPR/117.0.0.0 (Edition ms_store)
performance.memory = {
  "totalJSHeapSize": 52109787,
  "usedJSHeapSize": 47481719,
  "jsHeapSizeLimit": 2160066560
}
Username = mukendilord5@gmail.com
Chat ID = 230b4870c28c
Client version = 357ece6
Server version = 357ece6

Additional context

import express from 'express';
import mongoose from 'mongoose';
import cors from 'cors';

dotenv.config();
const app = express();
app.use(express.json());
app.use(cors());

// Connexion MongoDB
mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true
}).then(() => console.log('MongoDB connecté pour les fonctionnalités surprises'))
.catch(err => console.log(err));

// Modèle pour les Statistiques d'Engagement
const EngagementSchema = new mongoose.Schema({
userId: String,
views: Number,
likes: Number,
comments: Number,
lastActive: { type: Date, default: Date.now }
});
const Engagement = mongoose.model('Engagement', EngagementSchema);

// Route pour récupérer les statistiques d'un utilisateur
app.get('/engagement/:userId', async (req, res) => {
try {
const stats = await Engagement.findOne({ userId: req.params.userId });
res.json(stats || { views: 0, likes: 0, comments: 0 });
} catch (error) {
res.status(500).json({ error: 'Erreur lors de la récupération des statistiques' });
}
});

// Route pour mettre à jour les statistiques d'un utilisateur
app.post('/engagement/update', async (req, res) => {
try {
const { userId, views, likes, comments } = req.body;
const stats = await Engagement.findOneAndUpdate(
{ userId },
{ $inc: { views, likes, comments }, lastActive: new Date() },
{ new: true, upsert: true }
);
res.json(stats);
} catch (error) {
res.status(500).json({ error: 'Erreur lors de la mise à jour des statistiques' });
}
});

const PORT = process.env.PORT || 5003;
app.listen(PORT, () => console.log(Serveur des fonctionnalités surprises en écoute sur le port ${PORT}));