git clone https://github.com/yourusername/django-chatapp.git

NOTE: Earlier experimental WebSocket code (Channels) is present in history but not required for current functionality.

Browser
	├─ Loads room page (HTML rendered by Django)
	├─ JavaScript polls /rooms/<slug>/messages/?after=<last_id>
	├─ Sends new message via POST /rooms/<slug>/messages/create/
	└─ Appends any new JSON messages to the DOM

Django Views
	├─ rooms() -> list rooms
	├─ room() -> initial HTML + last N messages
	├─ room_messages() -> JSON incremental fetch
	└─ create_message() -> JSON create

Database
	├─ Room(id, name, slug)
	└─ Message(id, room_id, user_id, content, date_added)

The polling approach keeps logic simple: the client only asks for messages with an id greater than the latest it has.

Room:

name (CharField)
slug (SlugField, unique)

Message:

room (FK -> Room)
user (FK -> User)
content (Text)
date_added (auto timestamp)
ordering = date_added asc

JSON message shape:

{
	"id": 42,
	"content": "Hello world",
	"username": "alice",
	"date": "13:57:02"
}

1. Page renders last 25 messages (oldest at top).
2. JS determines the highest message id (lastId).
3. A setInterval runs every 2000 ms calling the JSON endpoint with ?after=lastId.
4. New messages (if any) are appended; lastId updates.
5. Sending a message (Enter / Send) POSTs, then triggers an immediate fetch.

Advantages (for beginners):

• No extra dependency beyond Django.
• Easy to debug with browser network tab.

Limitations:

• Slight delay (up to polling interval).
• Inefficient if many rooms/users; WebSockets or Server-Sent Events scale better.

# Clone your fork / this repo
git clone https://github.com/vijay-x-Raj/Django_ChatApp.git
cd Django_ChatApp

# (Optional) create virtual environment
python -m venv venv
source venv/Scripts/activate  # or: . venv/Scripts/activate

# Install dependencies
pip install -r requirements.txt

# Apply migrations
python manage.py migrate

# (Optional) create initial user
python manage.py createsuperuser

# Run dev server
python manage.py runserver

Visit: http://127.0.0.1:8000/ then sign in and go to /rooms/.

Pseudo-flow in the room script:

lastId = highestExistingId();
setInterval(async () => {
	const res = await fetch(`/rooms/<slug>/messages/?after=${lastId}`);
	const { messages } = await res.json();
	for (const m of messages) { append(m); lastId = m.id; }
}, 2000);

To reduce latency you can lower the interval (e.g. 1000 ms) or swap in WebSockets later.

Current create URL: /rooms/<slug>/messages/create/

RESTful alternative:

POST /api/rooms/<slug>/messages/
GET  /api/rooms/<slug>/messages/?after=<id>

Both share the same collection path; method distinguishes action.

Why not WebSockets now? Keeping onboarding simple; polling teaches data flow first. You can swap in Channels later by running an ASGI server (daphne / uvicorn) and wiring the template back to the consumer.

Will polling scale? For a handful of users, yes. For hundreds of concurrent rooms, move to push (WebSockets or SSE) + Redis.

How do I change the polling interval? Edit the setInterval(poll, 2000); line in room.html.

How many past messages load? Currently the last 25. Adjust the slice in room/views.py.

• Remove unused channels dependency if you commit to polling only.
• Add tests for room_messages and create_message endpoints.
• Add pagination (e.g. ?before=<id> for older history).
• Add Dockerfile for easier onboarding.

MIT (adjust if needed). Feel free to use and extend.

Happy building! ✨

If you’d like a WebSocket or SSE branch set up next, just ask.