How santoshvandari/accountingsystem works
Project Type and Purpose
• This is a full-stack Accounting System.
• Backend: Django 5 + Django REST Framework (DRF) providing a JWT-secured REST API (accounts, transactions, billing).
• Frontend: React (Vite + Tailwind) as a single-page app (SPA) with role-based UI (admin, manager, cashier), charts, and invoicing.
File-Structure Analysis
• Top level:
• backend/ – Django project
– core/ (settings, URL routing, permissions)
– accounts/ (custom user model, auth, RBAC)
– transactions/ (CRUD)
– billing/ (invoicing, PDF/print endpoints)
– manage.py, requirements.txt
• frontend/ – React app
– src/api (base API client, endpoint index)
– src/contexts (AuthContext for JWT storage)
– src/components (UI library: Buttons, Tables, Modals, etc.)
– src/pages (Dashboard, Transactions, Bills, Users, Settings, Login)
– vite.config.js, .env.example
• docs/ – MARKDOWN docs (API.md, ARCHITECTURE.md, DEVELOPER_GUIDE.md)
README Insights
• Stated features: JWT auth, role-based permissions, transactions, invoicing with PDF print, dashboard charts.
• Tech stack: DRF + simplejwt + drf-yasg, SQLite (dev)/Postgres (prod), React 19 + Tailwind 4 + Recharts.
• Architecture & API documented under docs/.
Main Components
a. User / Browser
– Web browser making HTTP/HTTPS requests
b. Frontend (React SPA)
– Vite dev server / static hosting
– AuthContext + localStorage for JWT
– API client (base.js) for attaching JWT
– Pages & UI components (Dashboard, Transactions, Bills, etc.)
c. API Gateway / Django REST Backend
– core/ (URL routing, global permissions)
– accounts/, transactions/, billing/ apps with Models → Serializers → Views → URLs
– simplejwt for token generation/validation
– drf-yasg providing Swagger/OpenAPI at /docs/
d. Database
– SQLite in development, Postgres in production
e. External Services
– PDF generation (e.g., wkhtmltopdf or frontend print-to-PDF)
– Email/SMS (if billing notifications are added)
– CDN or Object Storage for static assets (optional)
Component Relationships & Data Flow
• Browser → (login request) → React → POST /api/token/ → Django → simplejwt → issues JWT → returned to React → stored in AuthContext.
• For protected routes: React → GET/POST /api/transactions/, /api/billing/ → JWT in Authorization header → Django verifies → performs DB operations → returns JSON.
• Billing PDF: React requests invoice → Django generates PDF or JSON payload → React triggers browser print or calls third-party PDF service.
• Swagger UI: Browser → GET /docs/ → Django/drf-yasg → renders OpenAPI docs.
Architectural Patterns & Design Principles
• Separation of concerns:
• Frontend (UI & client-side state) vs. Backend (business logic & data).
• Django apps per domain (accounts, transactions, billing).
• RESTful API: Resources modeled via serializers and viewsets.
• Component-based UI in React.
• Context API for global auth state.
• Environment-based configuration (dev vs. prod database, CORS, ALLOWED_HOSTS).
Detailed Elements to Capture
• Frontend: AuthContext → API client → UI pages.
• Backend apps: core URLs → app viewsets → serializers → models → database.
• JWT auth flow.
• API documentation endpoint.
• Environment variable configuration points (VITE_API_URL, SECRET_KEY, DATABASE_URL).
• Optionally, CI/CD or containerization if used (not in current tree).