Added many changes, main is added login and regestration backend, also modified frontend

backend/.gitignore

@@ -1 +1,3 @@
 /target
+.env
+Cargo.lock

backend/Cargo.toml

@@ -7,4 +7,14 @@ edition = "2021"
 unused_imports = "allow"
 
 [dependencies]
-actix-web = "4"
+actix-web = "4.0"
+serde = { version = "1.0.216", features = ["derive"] }
+serde_json = "1.0"
+mongodb = "3.1.1"
+bcrypt = "0.16.0"
+jsonwebtoken = "9.3.0"
+dotenv = "0.15"
+env_logger = "0.11.5"
+log = "0.4"
+actix-cors = "0.7.0"
+futures-util = "0.3.31"

backend/src/config.rs

@@ -0,0 +1,4 @@
+pub fn init() {
+    // Initialize any configurations if needed
+    // Currently, this function is empty as we are not using logging
+}

backend/src/main.rs

@@ -1,19 +1,37 @@
-use actix_web::{get, web, App, HttpServer, Responder};
+mod config;
+mod models;
+mod routes;
+mod services;
+mod utils;
 
-#[get("/")]
+use actix_cors::Cors;
-async fn index() -> impl Responder {
+use actix_web::{web, App, HttpServer};
-    "Hello, World!"
+use dotenv::from_filename;
-}
+use std::env;
-
+use env_logger::Env;
-#[get("/{name}")]
+use log::info;
-async fn hello(name: web::Path<String>) -> impl Responder {
-    format!("Hello {}!", &name)
-}
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    HttpServer::new(|| App::new().service(index).service(hello))
+    from_filename("src/.env").ok(); // Load environment variables from src/.env file
-        .bind(("127.0.0.1", 8080))?
+    env_logger::init_from_env(Env::default().default_filter_or("info")); // Initialize the logger
-        .run()
+    config::init(); // Initialize configurations
-        .await
+    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    info!("DATABASE_URL: {}", db_url); // Print the DATABASE_URL to verify
+    let db = utils::db::MongoRepo::init(&db_url).await;
+
+    HttpServer::new(move || {
+        App::new()
+            .wrap(
+                Cors::default()
+                    .allow_any_origin()
+                    .allow_any_method()
+                    .allow_any_header()
+            )
+            .app_data(web::Data::new(db.clone()))
+            .configure(routes::init)
+    })
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
 }

backend/src/models/counter.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Counter {
+    pub id: String,
+    pub seq: i32,
+}

backend/src/models/mod.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct User {
+    pub id: Option<String>,
+    pub name: String,
+    pub email: String,
+    pub password: String,
+}
+pub mod counter;
+pub use counter::Counter; // Add this line to re-export the Counter struct

backend/src/routes/mod.rs

@@ -0,0 +1,8 @@
+use actix_web::web;
+
+mod user_routes;
+
+pub fn init(cfg: &mut web::ServiceConfig) {
+    cfg.service(user_routes::register);
+    cfg.service(user_routes::login);
+}

backend/src/routes/user_routes.rs

@@ -0,0 +1,148 @@
+use actix_web::{post, web, HttpResponse};
+use bcrypt::{hash, verify};
+use futures_util::stream::TryStreamExt; // Import TryStreamExt
+use mongodb::bson::doc;
+use serde::{Deserialize, Serialize};
+use log::{info, error};
+
+use crate::models::{User as ModelUser, Counter};
+use crate::utils::db::MongoRepo;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct User {
+    pub id: Option<String>,
+    pub name: String,
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AuthRequest {
+    pub email: String,
+    pub password: String,
+}
+
+async fn get_next_id(db: &MongoRepo) -> i32 {
+    let counter_collection = db.collection::<Counter>("counters");
+    let filter = doc! { "id": "user_id" };
+
+    // Check if counter exists
+    let counter = counter_collection
+        .find_one(filter.clone())
+        .await
+        .expect("Failed to check counter");
+
+    match counter {
+        Some(_) => {
+            // Increment existing counter
+            let update = doc! { "$inc": { "seq": 1 } };
+            let updated = counter_collection
+                .find_one_and_update(filter, update)
+                .await
+                .expect("Failed to update counter")
+                .unwrap();
+            updated.seq
+        }
+        None => {
+            // Initialize counter with 100
+            let initial_counter = Counter {
+                id: "user_id".to_string(),
+                seq: 100,
+            };
+            counter_collection
+                .insert_one(initial_counter)
+                .await
+                .expect("Failed to initialize counter");
+            100
+        }
+    }
+}
+
+#[post("/api/users/register")]
+async fn register(
+    db: web::Data<MongoRepo>,
+    user: web::Json<User>,
+) -> HttpResponse {
+    info!("Received registration request for email: {}", user.email);
+
+    let hashed_name = match hash(&user.name, 4) {
+        Ok(hn) => hn,
+        Err(e) => {
+            error!("Error hashing name: {:?}", e);
+            return HttpResponse::InternalServerError().json("Error hashing name");
+        }
+    };
+
+    let hashed_email = match hash(&user.email, 4) {
+        Ok(he) => he,
+        Err(e) => {
+            error!("Error hashing email: {:?}", e);
+            return HttpResponse::InternalServerError().json("Error hashing email");
+        }
+    };
+
+    let hashed_password = match hash(&user.password, 4) {
+        Ok(hp) => hp,
+        Err(e) => {
+            error!("Error hashing password: {:?}", e);
+            return HttpResponse::InternalServerError().json("Error hashing password");
+        }
+    };
+
+    let user_id = get_next_id(&db).await;
+
+    let new_user = ModelUser {
+        id: Some(user_id.to_string()), // Convert user_id to String
+        name: hashed_name,
+        email: hashed_email,
+        password: hashed_password,
+    };
+
+    let user_collection = db.collection::<ModelUser>("users");
+    let result = user_collection
+        .insert_one(new_user)
+        .await;
+
+    match result {
+        Ok(_) => {
+            info!("User registered successfully");
+            HttpResponse::Ok().json("User registered successfully")
+        },
+        Err(e) => {
+            error!("Error inserting user: {:?}", e);
+            HttpResponse::InternalServerError().json("Error registering user")
+        }
+    }
+}
+
+#[post("/api/users/login")]
+async fn login(
+    db: web::Data<MongoRepo>,
+    auth: web::Json<AuthRequest>,
+) -> HttpResponse {
+    info!("Received login request for email: {}", auth.email);
+
+    let user_collection = db.collection::<ModelUser>("users");
+    let users = user_collection
+        .find(doc! {}) // Pass an empty document to find all users
+        .await
+        .unwrap()
+        .try_collect::<Vec<ModelUser>>()
+        .await
+        .unwrap();
+
+    for user in users {
+        if verify(&auth.email, &user.email).unwrap() {
+            if verify(&auth.password, &user.password).unwrap() {
+                info!("Login successful for email: {}", auth.email);
+                return HttpResponse::Ok().json("Login successful");
+            } else {
+                info!("Invalid credentials for email: {}", auth.email);
+                return HttpResponse::Unauthorized().json("Invalid credentials");
+            }
+        }
+    }
+
+    info!("Invalid credentials for email: {}", auth.email);
+    HttpResponse::Unauthorized().json("Invalid credentials")
+}

backend/src/services/mod.rs

@@ -0,0 +1 @@
+// This file can be used to define additional services if needed

backend/src/utils/db.rs

@@ -0,0 +1,20 @@
+use mongodb::{options::ClientOptions, Client, Database};
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct MongoRepo {
+    pub db: Arc<Database>,
+}
+
+impl MongoRepo {
+    pub async fn init(db_url: &str) -> Self {
+        let client_options = ClientOptions::parse(db_url).await.unwrap();
+        let client = Client::with_options(client_options).unwrap();
+        let db = client.database("socialnetwork");
+        MongoRepo { db: Arc::new(db) }
+    }
+
+    pub fn collection<T: Send + Sync>(&self, name: &str) -> mongodb::Collection<T> {
+        self.db.collection(name)
+    }
+}

backend/src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod db;

frontend/src/app/layout.tsx

@@ -1,35 +1,35 @@
-import type { Metadata } from "next";
+import type { Metadata } from 'next';
-import localFont from "next/font/local";
+import localFont from 'next/font/local';
-import "./globals.css";
+import './globals.css';
 
 const geistSans = localFont({
-  src: "./fonts/GeistVF.woff",
+	src: './fonts/GeistVF.woff',
-  variable: "--font-geist-sans",
+	variable: '--font-geist-sans',
-  weight: "100 900",
+	weight: '100 900',
 });
 const geistMono = localFont({
-  src: "./fonts/GeistMonoVF.woff",
+	src: './fonts/GeistMonoVF.woff',
-  variable: "--font-geist-mono",
+	variable: '--font-geist-mono',
-  weight: "100 900",
+	weight: '100 900',
 });
 
 export const metadata: Metadata = {
-  title: "Create Next App",
+	title: 'The social network',
-  description: "Generated by create next app",
+	description: 'social network by deusbog',
 };
 
 export default function RootLayout({
-  children,
+	children,
 }: Readonly<{
-  children: React.ReactNode;
+	children: React.ReactNode;
 }>) {
-  return (
+	return (
-    <html lang="en">
+		<html lang='en'>
-      <body
+			<body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+				className={`${geistSans.variable} ${geistMono.variable} antialiased`}
-      >
+			>
-        {children}
+				{children}
-      </body>
+			</body>
-    </html>
+		</html>
-  );
+	);
 }

frontend/src/app/login/page.tsx

@@ -1,21 +1,54 @@
-import React from 'react';
+'use client';
+
+import React, { useState } from 'react';
 import Link from 'next/link';
+import { useRouter } from 'next/navigation';
 
 export default function Login() {
+	const [email, setEmail] = useState('');
+	const [password, setPassword] = useState('');
+	const [message, setMessage] = useState('');
+	const router = useRouter();
+
+	const handleSubmit = async (e: React.FormEvent) => {
+		e.preventDefault();
+		try {
+			const res = await fetch('http://localhost:8080/api/users/login', {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify({ email, password }),
+			});
+
+			if (res.ok) {
+				localStorage.setItem('email', email);
+				router.push('/success'); // Redirect to the success page
+			} else {
+				setMessage('Error logging in');
+			}
+		} catch (error) {
+			console.error('Error:', error);
+			setMessage('Failed to connect to the server');
+		}
+	};
+
 	return (
 		<div className='flex flex-col items-center justify-center min-h-screen bg-purple-100'>
 			<div className='bg-white p-8 rounded-lg shadow-md w-full max-w-md'>
 				<h1 className='text-2xl font-bold mb-6 text-purple-700'>Login</h1>
-				<form>
+				<form onSubmit={handleSubmit}>
 					<div className='mb-4'>
 						<label className='block text-purple-700 mb-2' htmlFor='email'>
 							Email
 						</label>
 						<input
-							className='w-full p-2 border border-purple-300 rounded'
+							className='w-full p-2 border border-purple-300 rounded text-purple-700'
 							type='email'
 							id='email'
 							name='email'
+							value={email}
+							onChange={(e) => setEmail(e.target.value)}
 							required
 						/>
 					</div>
@@ -24,10 +57,12 @@ export default function Login() {
 							Password
 						</label>
 						<input
-							className='w-full p-2 border border-purple-300 rounded'
+							className='w-full p-2 border border-purple-300 rounded text-purple-700'
 							type='password'
 							id='password'
 							name='password'
+							value={password}
+							onChange={(e) => setPassword(e.target.value)}
 							required
 						/>
 					</div>
@@ -38,6 +73,7 @@ export default function Login() {
 						Login
 					</button>
 				</form>
+				{message && <p className='mt-4 text-purple-700'>{message}</p>}
 				<p className='mt-4 text-purple-700'>
 					Don&apos;t have an account?{' '}
 					<Link href='/register' legacyBehavior>

frontend/src/app/register/page.tsx

@@ -1,21 +1,56 @@
-import React from 'react';
+'use client';
+
+import React, { useState } from 'react';
 import Link from 'next/link';
+import { useRouter } from 'next/navigation';
 
 export default function Register() {
+	const [name, setName] = useState('');
+	const [email, setEmail] = useState('');
+	const [password, setPassword] = useState('');
+	const [message, setMessage] = useState('');
+	const router = useRouter();
+
+	const handleSubmit = async (e: React.FormEvent) => {
+		e.preventDefault();
+		try {
+			const res = await fetch('http://localhost:8080/api/users/register', {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify({ name, email, password }),
+			});
+
+			if (res.ok) {
+				localStorage.setItem('name', name);
+				localStorage.setItem('email', email);
+				router.push('/login');
+			} else {
+				setMessage('Error registering user');
+			}
+		} catch (error) {
+			console.error('Error:', error);
+			setMessage('Failed to connect to the server');
+		}
+	};
+
 	return (
 		<div className='flex flex-col items-center justify-center min-h-screen bg-purple-100'>
 			<div className='bg-white p-8 rounded-lg shadow-md w-full max-w-md'>
 				<h1 className='text-2xl font-bold mb-6 text-purple-700'>Register</h1>
-				<form>
+				<form onSubmit={handleSubmit}>
 					<div className='mb-4'>
 						<label className='block text-purple-700 mb-2' htmlFor='name'>
 							Name
 						</label>
 						<input
-							className='w-full p-2 border border-purple-300 rounded'
+							className='w-full p-2 border border-purple-300 rounded text-purple-700'
 							type='text'
 							id='name'
 							name='name'
+							value={name}
+							onChange={(e) => setName(e.target.value)}
 							required
 						/>
 					</div>
@@ -24,10 +59,12 @@ export default function Register() {
 							Email
 						</label>
 						<input
-							className='w-full p-2 border border-purple-300 rounded'
+							className='w-full p-2 border border-purple-300 rounded text-purple-700'
 							type='email'
 							id='email'
 							name='email'
+							value={email}
+							onChange={(e) => setEmail(e.target.value)}
 							required
 						/>
 					</div>
@@ -36,10 +73,12 @@ export default function Register() {
 							Password
 						</label>
 						<input
-							className='w-full p-2 border border-purple-300 rounded'
+							className='w-full p-2 border border-purple-300 rounded text-purple-700'
 							type='password'
 							id='password'
 							name='password'
+							value={password}
+							onChange={(e) => setPassword(e.target.value)}
 							required
 						/>
 					</div>
@@ -50,6 +89,7 @@ export default function Register() {
 						Register
 					</button>
 				</form>
+				{message && <p className='mt-4 text-purple-700'>{message}</p>}
 				<p className='mt-4 text-purple-700'>
 					Already have an account?{' '}
 					<Link href='/login' legacyBehavior>

frontend/src/app/success/page.tsx

@@ -0,0 +1,18 @@
+import React from 'react';
+import Link from 'next/link';
+
+export default function Success() {
+	return (
+		<div className='flex flex-col items-center justify-center min-h-screen bg-purple-100'>
+			<div className='bg-white p-8 rounded-lg shadow-md w-full max-w-md'>
+				<h1 className='text-2xl font-bold mb-6 text-purple-700'>
+					Login Successful
+				</h1>
+				<p className='text-purple-700'>You have successfully logged in!</p>
+				<Link href='/' legacyBehavior>
+					<a className='mt-4 text-purple-500 hover:underline'>Go to Home</a>
+				</Link>
+			</div>
+		</div>
+	);
+}