Merge pull request larymak#365 from AHNAF14924/main

Multi User Chat Application

Author: larymak

OTHERS/Multi_User_Chat_Application/README.md

@@ -0,0 +1,66 @@
+# Overview
+The **Multi-User Chat Application** is a Python-based chat application designed to provide real-time text-based communication among multiple users.
+
+# Features
+The chat application includes the following key features:
+* **User Nicknames:** Users can set and display personalized nicknames within the chat.
+* **Private Messaging:** Users can send private messages to specific recipients.
+* **Message Logging:** All chat messages are logged on the server for historical reference.
+* **Error Handling:** The application handles various error scenarios for a stable user experience.
+
+# Technologies Used
+The project was implemented using the following technologies:
+* **Python:** The primary programming language used for both the server and client applications.
+* **Python's socket library:** Utilized for network communication between the server and clients.
+* **Threading:** Implemented to enable concurrent handling of multiple client connections on the server.
+
+# Installation and Usage
+To install and use the chat application, follow these steps:
+* Clone the project repository from [GitHub URL](https://github.com/AHNAF14924/Multi-User-Chat-Application.git)
+* Open the terminal/command prompt.
+* Navigate to the project directory.
+* Start the server by running python `server.py`
+* Run the client by executing python `client.py`
+ ## Server Setup
+ * Choose one of the computers to act as the server. This computer will run the server code.
+ * Modify the server code to use the computer's local IP address (e.g., '192.168.x.x' or '10.0.x.x') in the host variable. This allows other computers to connect to the server.
+ * Run the server code on the chosen computer.
+ 
+ Example server code (change 'host' to the local IP address):
+
+ ```
+ host = '192.168.x.x'  # Use the local IP address of the server computer
+port = 12345  # You can keep the same port
+ ```
+Start the server:
+```
+python3 server.py
+```
+## Client Setup
+* On each of the other computers, you will run the client code.
+* Modify the client code to use the IP address of the computer running the server in the server_host variable.
+* Run the client code on each computer.
+
+Example client code (change 'server_host' to the server's IP address):
+```
+server_host = '192.168.x.x'  # Use the server's local IP address
+server_port = 12345  # Keep the same port as the server
+```
+Start the client on each computer:
+
+```
+python3 client.py
+```
+## Join the Chat
+
+* After starting the client on each computer, you will be prompted to set a nickname. Enter a unique nickname for each user.
+* Once the nickname is set, you can start sending messages by typing in the terminal of each client. Messages will be sent to the server and broadcast to all connected clients.
+
+## Sending Messages
+
+* To send a regular message, type your message and press Enter. It will be broadcast to all connected clients.
+* To send a private message to a specific user, use the "@" symbol followed by the recipient's nickname, a space, and your message. For example: `@JohnDoe Hi, John!`
+
+## Exiting the Application
+To exit the chat application:
+* Type `exit` in the terminal and press Enter. This will disconnect you from the chat and close the client application.

OTHERS/Multi_User_Chat_Application/client.py

@@ -0,0 +1,61 @@
+import tkinter as tk
+from tkinter import scrolledtext
+import threading
+import socket
+
+# Create a socket
+client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+# Define the server's host and port
+server_host = '192.168.0.11'  # Change this to the server's IP or hostname
+server_port = 12345
+
+# Connect to the server
+client.connect((server_host, server_port))
+
+# Function to send a message
+def send_message():
+    message = message_entry.get()
+    client.send(message.encode('utf-8'))
+    message_entry.delete(0, tk.END)
+    chat_text.config(state=tk.NORMAL)
+    chat_text.insert(tk.END, "You: " + message + "\n")
+    chat_text.config(state=tk.DISABLED)
+
+# Function to receive and display messages from the server
+def receive_messages():
+    while True:
+        try:
+            message = client.recv(1024).decode('utf-8')
+            chat_text.config(state=tk.NORMAL)
+            if message.startswith("Server: "):
+                chat_text.insert(tk.END, message + "\n")
+            else:
+                chat_text.insert(tk.END, message + "\n")
+            chat_text.config(state=tk.DISABLED)
+        except:
+            print("Connection closed.")
+            client.close()
+            break
+
+# Create a GUI for the client
+client_gui = tk.Tk()
+client_gui.title("Chat Client")
+
+chat_text = scrolledtext.ScrolledText(client_gui, wrap=tk.WORD)
+chat_text.config(state=tk.DISABLED)
+chat_text.pack()
+
+message_entry = tk.Entry(client_gui)
+message_entry.pack()
+
+send_button = tk.Button(client_gui, text="Send", command=send_message)
+send_button.pack()
+
+# Create a thread to receive messages
+receive_thread = threading.Thread(target=receive_messages)
+receive_thread.start()
+
+# Main GUI loop
+client_gui.mainloop()
+

OTHERS/Multi_User_Chat_Application/server.py

@@ -0,0 +1,83 @@
+import socket
+import threading
+
+# Create a socket
+server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+# Define the host and port
+host = '192.168.0.11'  # Listen on all available network interfaces
+port = 12345
+
+# Bind the socket to the host and port
+server.bind((host, port))
+
+# Listen for incoming connections
+server.listen()
+
+print(f"Server listening on {host}:{port}")
+
+# Store client connections and nicknames in dictionaries
+clients = {}
+nicknames = {}
+
+# Function to broadcast messages to all connected clients
+def broadcast(message, sender=None):
+    for client_socket, nickname in zip(clients, nicknames):
+        if client_socket != sender:
+            try:
+                client_socket.send(message.encode('utf-8'))
+            except:
+                remove_client(client_socket)
+
+# Function to handle client connections
+def handle_client(client_socket):
+    try:
+        # Request and store the user's nickname
+        client_socket.send("Enter your nickname: ".encode('utf-8'))
+        nickname = client_socket.recv(1024).decode('utf-8')
+        nicknames[client_socket] = nickname
+        print(f"Nickname of {nickname} is set.")
+
+        # Welcome message
+        welcome_message = f"Welcome, {nickname}!"
+        client_socket.send(welcome_message.encode('utf-8'))
+
+        while True:
+            message = client_socket.recv(1024)
+            if not message:
+                remove_client(client_socket)
+                break
+            elif message.decode('utf-8').lower() == 'exit':
+                remove_client(client_socket)
+            elif message.decode('utf-8').startswith('@'):
+                # Private message
+                recipient = message.decode('utf-8').split(' ')[0][1:]
+                if recipient in nicknames.values():
+                    recipient_socket = list(nicknames.keys())[list(nicknames.values()).index(recipient)]
+                    recipient_socket.send(f"(Private) {nickname}: {message.decode('utf-8')[len(recipient) + 2:]}".encode('utf-8'))
+                else:
+                    client_socket.send("Recipient not found.".encode('utf-8'))
+            else:
+                # Broadcast regular message
+                broadcast(f"{nickname}: {message.decode('utf-8')}", sender=client_socket)
+    except:
+        remove_client(client_socket)
+
+# Function to remove a client from the server
+def remove_client(client_socket):
+    if client_socket in clients:
+        print(f"Connection closed with {nicknames[client_socket]}")
+        del nicknames[client_socket]
+        clients.pop(client_socket)
+        client_socket.close()
+
+# Main server loop
+while True:
+    client_socket, client_address = server.accept()
+    print(f"Accepted connection from {client_address}")
+    clients[client_socket] = client_address
+
+    # Start a thread to handle the client
+    client_thread = threading.Thread(target=handle_client, args=(client_socket,))
+    client_thread.start()
+