Front end

.dockerignore

@@ -0,0 +1,6 @@
+**/node_modules
+**/.venv
+backend/db.sqlite3
+backend/submission_json
+backend/form_json
+*.md

.gitignore

@@ -0,0 +1,39 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Data files
+backend/form_json/
+backend/db.sqlite3
+backend/submission_json/
+
+backend/form_generator/static/
+backend/static/
+example-plea-of-guilty.docx
+~$ample-plea-of-guilty.docx

Dockerfile

@@ -0,0 +1,50 @@
+# Dockerfile for the Django + Vue.js application
+
+# --- Stage 1: Build Vue.js Frontend ---
+FROM node:18-alpine AS frontend-builder
+
+# Set working directory for the frontend
+WORKDIR /app/frontend
+
+# Copy package files and install dependencies
+# Using `package-lock.json` ensures reproducible builds
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install --include=dev
+
+# Copy the rest of the frontend source code
+COPY frontend/ ./
+
+# Build the static assets for the frontend
+RUN npm run build
+
+# --- Stage 2: Build Python Backend ---
+FROM python:3.13-slim
+
+# Set environment variables to prevent Python from writing .pyc files
+ENV PYTHONDONTWRITEBYTECODE 1
+# Ensure Python output is sent straight to the terminal
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+# Install Python dependencies from pyproject.toml
+COPY backend/pyproject.toml backend/uv.lock ./
+RUN uv add gunicorn && uv sync
+
+# Copy the backend application code into the container
+COPY backend/ .
+
+# Copy the built frontend assets from the frontend-builder stage
+# Your Django `STATICFILES_DIRS` setting should be configured to include this `/app/static` directory.
+COPY --from=frontend-builder /app/frontend/dist /app/static
+
+# Expose port 8000 to allow communication to the Gunicorn server
+EXPOSE 8000
+
+# Run the application using Gunicorn
+# This command assumes your Django project's WSGI file is located at `form_generator.wsgi`.
+CMD uv run ./manage.py migrate --noinput && uv run gunicorn --bind 0.0.0.0:8000 form_generator.wsgi:application

Dockerfile.dev

@@ -0,0 +1,35 @@
+
+# Development Dockerfile for Django + Vue.js with hot reloading
+FROM node:24-slim
+
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+# Backend deps
+WORKDIR /app/backend
+COPY backend/.python-version ./
+RUN uv python install
+COPY backend/pyproject.toml backend/uv.lock ./
+RUN uv sync
+
+
+# Frontend deps
+WORKDIR /app/frontend
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install --include=dev
+
+WORKDIR /app
+
+# Expose ports for Django and Vite
+EXPOSE 8000 5173
+
+# Entrypoint script for dev: runs both servers with hot reload
+COPY ./dev-entrypoint.sh /app/dev-entrypoint.sh
+RUN chmod +x /app/dev-entrypoint.sh
+
+CMD ["/app/dev-entrypoint.sh"]

README.md

@@ -1,2 +1,23 @@
 # autosubmissions
+
 way to easily generate submissions
+
+run local dev
+
+```sh
+docker build -f Dockerfile.dev -t dev .
+docker run -it --rm -p 8000:8000 -p 5173:5173 -v backend:/app/backend -v /app/backend/.venv -v frontend:/app/frontend -v /app/frontend/node_modules dev
+```
+
+
+build prod container
+
+```sh
+docker build -t prod .
+```
+
+run prod container
+
+```sh
+docker run --rm -it -p 8080:8000 prod
+```

backend/.python-version

@@ -0,0 +1 @@
+3.13

backend/README.md

@@ -0,0 +1,149 @@
+## How to run locally
+
+```shell
+uv run ./manage.py runserver
+```
+
+## System Architecture
+
+This document provides a high-level overview of the system architecture, designed to help new engineers understand the codebase and contribute effectively.
+
+### High-Level Architecture
+
+The application is a full-stack solution composed of a Vue.js frontend and a Django backend. The backend serves a REST API for managing forms and submissions, and it also handles the generation of `.docx` documents based on submitted data.
+
+```mermaid
+graph TD
+    subgraph Frontend
+        A[Vue.js SPA]
+    end
+
+    subgraph Backend
+        B[Django REST Framework]
+        C[PostgreSQL Database]
+        D[Docx Generator]
+    end
+
+    A -->|API Requests| B
+    B -->|CRUD Operations| C
+    B -->|Generates| D
+```
+
+### API Endpoints
+
+The backend exposes a REST API for managing forms and submissions. The following endpoints are available:
+
+| Method | Endpoint                  | ViewSet             | Description                                         |
+|--------|---------------------------|---------------------|-----------------------------------------------------|
+| GET    | `/api/forms/`             | `FormViewSet`       | Retrieve a list of all forms.                       |
+| GET    | `/api/forms/{id}/`        | `FormViewSet`       | Retrieve a specific form by its ID.                 |
+| POST   | `/api/forms/`             | `FormViewSet`       | Create a new form.                                  |
+| PUT    | `/api/forms/{id}/`        | `FormViewSet`       | Update an existing form.                            |
+| DELETE | `/api/forms/{id}/`        | `FormViewSet`       | Delete a form.                                      |
+| GET    | `/api/submissions/`       | `SubmissionViewSet` | Retrieve a list of all submissions.                 |
+| GET    | `/api/submissions/{id}/`  | `SubmissionViewSet` | Retrieve a specific submission by its ID.           |
+| POST   | `/api/submissions/`       | `SubmissionViewSet` | Create a new submission.                            |
+| PUT    | `/api/submissions/{id}/`  | `SubmissionViewSet` | Update an existing submission.                      |
+| DELETE | `/api/submissions/{id}/`  | `SubmissionViewSet` | Delete a submission.                                |
+| GET    | `/api/submissions/{id}/generate_doc/` | `SubmissionViewSet` | Generate a `.docx` document for a submission. |
+
+### Database Schema
+
+The database schema is designed to store forms, questions, submissions, and answers in a structured manner. The following diagram illustrates the relationships between the different models:
+
+```mermaid
+erDiagram
+    Form {
+        int id PK
+        string name
+        string description
+        string template_type
+        json template_config
+        json sections
+    }
+
+    Question {
+        int id PK
+        int form_id FK
+        string text
+        string question_type
+        int order
+        string output_template
+        bool hidden
+        int section_id
+    }
+
+    Option {
+        int id PK
+        int question_id FK
+        string text
+    }
+
+    Submission {
+        int id PK
+        int form_id FK
+        string client_honorific
+        string client_first_name
+        string client_surname
+        date submission_date
+    }
+
+    Answer {
+        int id PK
+        int submission_id FK
+        int question_id FK
+        string value
+    }
+
+    Form ||--o{ Question : "has"
+    Question ||--o{ Option : "has"
+    Form ||--o{ Submission : "has"
+    Submission ||--o{ Answer : "has"
+    Question ||--o{ Answer : "is for"
+
+    Question }o--o{ Question : "triggers"
+    Option }o--o{ Question : "triggers"
+```
+
+### Form Submission Workflow
+
+The following sequence diagram illustrates the process of a user submitting a form, from interacting with the frontend to the data being saved in the backend.
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Frontend (Vue.js)
+    participant Backend (Django)
+    participant Database
+    User->>Frontend: Fills out form
+    Frontend->>Backend: POST /api/submissions/
+    Backend->>Backend: Validates submission data
+    alt Validation Successful
+        Backend->>Database: Creates Submission and Answer records
+        Database-->>Backend: Returns created records
+        Backend-->>Frontend: 201 Created
+    else Validation Failed
+        Backend-->>Frontend: 400 Bad Request with error details
+    end
+```
+
+### Document Generation Process
+
+The system can generate `.docx` documents from form submissions. This process is initiated by a GET request to a specific API endpoint. The following diagram shows the workflow:
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Frontend (Vue.js)
+    participant Backend (Django)
+    participant DocGenerator
+    participant Database
+    User->>Frontend: Clicks "Generate Document"
+    Frontend->>Backend: GET /api/submissions/{id}/generate_doc/
+    Backend->>Database: Fetches Submission, Answers, and Form data
+    Database-->>Backend: Returns data
+    Backend->>DocGenerator: Initializes with submission data
+    DocGenerator->>DocGenerator: Builds .docx file in memory
+    DocGenerator-->>Backend: Returns .docx file stream
+    Backend-->>Frontend: Responds with the .docx file
+    Frontend-->>User: Prompts to download file

backend/form_generator/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for form_generator project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "form_generator.settings")
+
+application = get_asgi_application()