UDo | Task Management Platform
A Persian-first, right-to-left task management platform built with Django, Channels, and Tailwind CSS: categorized tasks with priorities and Jalali due dates, configurable reminders, realtime WebSocket updates, and a persistent notification center.
uDo is a Persian-first, right-to-left task management platform built from the ground up with Django 5.2, Django Channels 4, Tailwind CSS 3.4, and vanilla ES modules — no frontend framework. Every page, the error pages included, is Persian and RTL, ships a dark mode and the Dana typeface, and runs the theme bootstrap with a per-request CSP nonce so a saved dark preference never flashes light first.
The task domain is designed around an owner and an optional assignee: every task carries a title, a description, a category, a status (to do, doing, done, canceled), a priority (low, normal, high, urgent), a due date, and a completion timestamp, while categories are personal and reusable — each category name unique per user. Authorization is enforced server-side: the owner edits and deletes, the assignee may complete and view, and superusers see everything — and the task list filters by exactly the same rules, so list-level and direct access to an individual task can never drift apart.
The task list offers search plus status, priority, category, and due-date filters (overdue, today, this week, no due date) and sorts by due date, recency, priority, or title. Every filter option's label is served from the backend inside the JSON response, so new categories — even ones arriving over the realtime channel — appear in the menus instantly and always in sync.
Every task can carry a reminder lead: so many days, hours, or minutes before the due date. The reminder time is always computed on the fly as the due date minus the configured lead, so editing either one re-arms the reminder automatically. Dispatch is idempotent: each task is claimed through an atomic update before anything is sent, so concurrent runs never double-fire; the reminder engine spins as a background thread every 60 seconds and is also available as a management command for cron-driven schedules.
The Jalali calendar lives in a single module: two-way Gregorian–Jalali conversion, parsing of user-submitted Jalali date-time strings, display formatting, relative times, and Persian-digit handling. The timezone policy is explicit: input is interpreted as Tehran local time and stored as UTC, serialized as ISO for machines and rendered in the Persian calendar for humans. Jalali form fields, template filters, and a reusable date/time picker all sit on the same core.
The realtime core runs over WebSocket: every approved user holds two personal channels, user.<id>.tasks and user.<id>.notifications, receiving creation, update, and deletion events for their tasks plus new notifications the moment they happen — and the WebSocket connection passes through the same approval gate as HTTP, closing unapproved users on the spot. Clients reconnect with exponential backoff and fall back to polling automatically whenever the network will not hold a socket, so data never goes stale.
Notifications are persistent and actionable: every notification is stored with a kind, title, body, and link, and the in-app bell keeps the unread count live. Action buttons come from a controlled registry — task.complete, task.review, and task.view — whose payloads are opaque JSON and are never evaluated as code, and recording an action prevents it from running twice. Browser notifications through the Notifications API request permission only from a user gesture, and every outcome — failure included — is surfaced as a Persian toast; silent failure is forbidden.
Authentication runs behind an administrator approval workflow: registration creates an active but unapproved account, and login stays impossible until an administrator approves it — recording who approved and when, and emailing the user the news. Superusers are always approved, and if approval is revoked after login, the session is closed on the very next request. Every sensitive route is restrained by its own rate limit (login, registration, and password reset separately), and route protection is applied to the whole urlpatterns list by default, so forgetting to guard one view is practically impossible.
The security layer is many-sided: the Django admin belongs to superusers only, and every admin URL — the login page included — returns 404 to anyone else so the panel is never even revealed, while the admin mount path itself is configurable through the environment. A CSP header with a per-request nonce covers every response, the error pages (400, 403, 404, 500, and CSRF failure) are all Persian and right-to-left, POST responses always use the standard success/error JSON envelope, and validation is authoritative on the server.
The frontend is Tailwind CSS and vanilla JavaScript only: esbuild splits and minifies the bundles into per-page chunks, and the whole interface component set — modals, drawers, dropdowns, toasts, skeletons — is built without any third-party library. The runtime is production-ready: a single ASGI entrypoint serves HTTP and WebSocket in one process, the channel layer and cache sit on Redis so sessions and rate limits stay shared across processes, PostgreSQL runs in production (SQLite in development), static files are delivered through WhiteNoise, SSL and HSTS are enforced, and settings are read from the environment with django-environ. Every implementation phase — authentication, the task domain, the Jalali calendar, realtime, and notifications — is complete and wired end to end.
- Technologies
- Python Django Tailwind CSS WebSocket
Project team
Soheyl Mohammdi
Founder