KeepItGoingServer/README.md

KeepItGoing Server

A powerful Django-based task management system with time tracking, tag organization, and real-time collaboration features.

Features

Task Management

• Hierarchical Tasks: Support for parent tasks and subtasks
• Priority Levels: Low, Medium, High, and Urgent
• Status Tracking: Pending, In Progress, Completed, Cancelled
• Due Dates & Times: Set specific due dates and times for tasks
• Recurrence: Daily, Weekly, Bi-weekly, Monthly, Yearly, and Custom patterns

Organization

• Tag-Based System: Organize tasks with multiple colored tags
• Smart Filtering: View tasks by All, Today, Upcoming, Overdue, or Completed
• Auto-Tag Assignment: New tasks automatically inherit the active filter tag
• Flexible Sorting: Sort by due date (earliest/latest) or priority (high-to-low/low-to-high)

Time Tracking

• Start/Stop Timers: Built-in time tracking for tasks
• Time Entry History: View detailed time logs for each task
• Formatted Display: Time shown as H:MM:SS with visual indicators
• Running Timer Display: Always visible timer in the UI when tracking time

Collaboration & User Management

• Task Sharing: Share individual tasks or entire tags with other users
• Multi-user Support: Full authentication and user management
• Email Verification: Secure email verification for new user registrations
• Admin Approval: Optional admin approval workflow for new users
• User Profiles: Customizable profiles with timezone and notification preferences
• Password Management: Secure password change functionality
• Shared Views: See tasks shared with you alongside your own

User Interface

• 3-Pane Layout: Sidebar navigation, task list, and detail panel
• Responsive Design: Works on desktop, tablet, and mobile
• Dark Mode: Built-in dark/light theme toggle
• Quick Add: Fast task creation from any filter view
• Inline Actions: Toggle completion, start/stop timers without leaving the list

API & Sync

• RESTful API: Full REST API for programmatic access
• Mobile App Support: Sync protocol for Android app
• Real-time Updates: Task changes sync across devices
• Conflict Resolution: Handles offline changes and syncing

Tech Stack

• Backend: Django 5.x, Django REST Framework
• Database: SQLite (development), PostgreSQL-compatible
• Task Queue: Celery with Redis
• Authentication: JWT tokens with session support
• Frontend: HTML5, CSS3, Vanilla JavaScript
• Deployment: Docker support included

Installation

Prerequisites

• Python 3.12+
• pip
• virtualenv (recommended)

Quick Start

1. Clone the repository

   git clone https://git.firebugit.com/Firebug_IT/KeepItGoingServer.git
   cd KeepItGoingServer
   

2. Create virtual environment

   python3 -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   

3. Install dependencies

   pip install -r requirements.txt
   

4. Configure environment

   cp .env.example .env
   # Edit .env with your settings
   

5. Run migrations

   export DJANGO_SETTINGS_MODULE=config.settings.development
   python manage.py migrate
   

6. Create superuser

   python manage.py createsuperuser
   

7. Run development server

   python manage.py runserver
   

8. Access the application

   • Web Interface: http://localhost:8000
   • Admin Panel: http://localhost:8000/admin
   • API Root: http://localhost:8000/api/

Configuration

Settings Modules

The project uses different settings modules for different environments:

• config.settings.development - Local development
• config.settings.production - Production deployment
• config.settings.selfhosted - Self-hosted instances

Set via environment variable:

export DJANGO_SETTINGS_MODULE=config.settings.development

Database Configuration

The application supports multiple database backends. Choose the one that fits your needs.

SQLite3 (Default - Development)

SQLite3 is the default database and requires no additional setup. It's perfect for development and single-user scenarios.

Configuration in config/settings/development.py:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Pros:

• Zero configuration
• No separate database server needed
• Perfect for development and testing

Cons:

• Not recommended for production with multiple users
• Limited concurrent write operations
• No network access (local file only)

PostgreSQL (Recommended for Production)

PostgreSQL is the recommended database for production deployments.

1. Install PostgreSQL:

# Ubuntu/Debian
sudo apt-get install postgresql postgresql-contrib libpq-dev

# macOS
brew install postgresql

2. Create database and user:

sudo -u postgres psql
CREATE DATABASE keepitgoing;
CREATE USER keepitgoing_user WITH PASSWORD 'your_secure_password';
ALTER ROLE keepitgoing_user SET client_encoding TO 'utf8';
ALTER ROLE keepitgoing_user SET default_transaction_isolation TO 'read committed';
ALTER ROLE keepitgoing_user SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE keepitgoing TO keepitgoing_user;
\q

3. Install Python driver:

pip install psycopg2-binary

4. Update settings:

Add to your .env file:

DATABASE_URL=postgresql://keepitgoing_user:your_secure_password@localhost:5432/keepitgoing

Or configure directly in settings:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'keepitgoing',
        'USER': 'keepitgoing_user',
        'PASSWORD': 'your_secure_password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

5. Run migrations:

python manage.py migrate

MariaDB/MySQL

MariaDB and MySQL are also supported for production use.

1. Install MariaDB:

# Ubuntu/Debian
sudo apt-get install mariadb-server libmariadb-dev

# macOS
brew install mariadb

2. Create database and user:

sudo mysql
CREATE DATABASE keepitgoing CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'keepitgoing_user'@'localhost' IDENTIFIED BY 'your_secure_password';
GRANT ALL PRIVILEGES ON keepitgoing.* TO 'keepitgoing_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

3. Install Python driver:

pip install mysqlclient

4. Update settings:

Add to your .env file:

DATABASE_URL=mysql://keepitgoing_user:your_secure_password@localhost:3306/keepitgoing

Or configure directly in settings:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'keepitgoing',
        'USER': 'keepitgoing_user',
        'PASSWORD': 'your_secure_password',
        'HOST': 'localhost',
        'PORT': '3306',
        'OPTIONS': {
            'charset': 'utf8mb4',
            'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
        },
    }
}

5. Run migrations:

python manage.py migrate

Database Migration Between Backends

To migrate data from one database to another:

1. Export data from current database:

python manage.py dumpdata --natural-foreign --natural-primary \
    -e contenttypes -e auth.Permission --indent 4 > data.json

2. Update database settings to new backend

3. Run migrations on new database:

python manage.py migrate --run-syncdb

4. Import data:

python manage.py loaddata data.json

Environment Variables

Key environment variables (see .env.example):

Core Settings

• SECRET_KEY - Django secret key (required in production, generate with python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())")
• DEBUG - Enable debug mode (True/False, must be False in production)
• ALLOWED_HOSTS - Comma-separated list of allowed hosts (e.g., tasks.firebugit.com,localhost)
• CSRF_TRUSTED_ORIGINS - HTTPS origins for CSRF (e.g., https://tasks.firebugit.com)
• SITE_DOMAIN - Domain name for email links (e.g., tasks.firebugit.com)

Database

• DATABASE_URL - Database connection string (optional, overrides settings)

Redis & Celery

• REDIS_URL - Redis connection for Celery (e.g., redis://localhost:6379/0)

Email Configuration (Required for Email Verification)

• EMAIL_BACKEND - Email backend (use django.core.mail.backends.smtp.EmailBackend for production)
• EMAIL_HOST - SMTP server hostname (e.g., smtp.gmail.com, smtp.sendgrid.net)
• EMAIL_PORT - SMTP port (587 for TLS, 465 for SSL)
• EMAIL_USE_TLS - Use TLS (True/False, use True for port 587)
• EMAIL_USE_SSL - Use SSL (True/False, use True for port 465)
• EMAIL_HOST_USER - SMTP username/email
• EMAIL_HOST_PASSWORD - SMTP password or API key
• DEFAULT_FROM_EMAIL - From email address (e.g., KeepItGoing <noreply@firebugit.com>)
• SERVER_EMAIL - Server error email address

Email Verification Settings

• EMAIL_VERIFICATION_TOKEN_EXPIRY_HOURS - Hours before verification tokens expire (default: 24)

API Documentation

Authentication

The API supports both session-based and token-based authentication.

Get Token:

POST /api/auth/login/
{
  "email": "user@example.com",
  "password": "password"
}

Use Token:

Authorization: Bearer <token>

Endpoints

Tasks

• GET /api/tasks/ - List all tasks
• POST /api/tasks/ - Create task
• GET /api/tasks/{id}/ - Get task details
• PUT /api/tasks/{id}/ - Update task
• DELETE /api/tasks/{id}/ - Delete task

Tags

• GET /api/tags/ - List all tags
• POST /api/tags/ - Create tag
• GET /api/tags/{id}/ - Get tag details
• PUT /api/tags/{id}/ - Update tag
• DELETE /api/tags/{id}/ - Delete tag

Time Entries

• GET /api/time-entries/ - List time entries
• POST /api/time-entries/ - Create time entry
• POST /api/tasks/{id}/start-timer/ - Start timer
• POST /api/time-entries/{id}/stop/ - Stop timer

Sync (Mobile)

• POST /api/sync/sync/ - Bidirectional sync endpoint

Project Structure

keepitgoing-server/
├── config/              # Project configuration
│   ├── settings/        # Environment-specific settings
│   ├── urls.py          # Main URL configuration
│   └── wsgi.py          # WSGI entry point
├── tasks/               # Task management app
│   ├── models.py        # Task, Tag, TimeEntry models
│   ├── views.py         # API and web views
│   ├── serializers.py   # DRF serializers
│   └── migrations/      # Database migrations
├── users/               # User management app
├── sync/                # Mobile sync app
├── notifications/       # Notification system
├── templates/           # Django templates
│   ├── base.html        # Base template
│   └── tasks/           # Task templates
├── static/              # Static files
│   ├── css/             # Stylesheets
│   └── js/              # JavaScript
├── manage.py            # Django management script
└── requirements.txt     # Python dependencies

Docker Deployment

Development

docker-compose -f docker-compose.dev.yml up

Production

docker-compose up -d

Database Models

Task

• Hierarchical structure (parent/subtasks)
• Multiple tags per task
• Due date and time
• Priority and status
• Recurrence patterns
• Soft delete support

Tag

• Color-coded organization
• Multi-task assignment
• Sort ordering
• Archive capability

TimeEntry

• Start/end timestamps
• Duration calculation
• User association

TaskShare

• Share tasks or entire tags
• User-to-user sharing
• Permission management

Development

Running Tests

python manage.py test

Creating Migrations

python manage.py makemigrations

Collecting Static Files

python manage.py collectstatic

Code Style

• Follow PEP 8 for Python code
• Use meaningful variable names
• Add docstrings to functions and classes

Deployment

Production Setup Guide

This guide covers deploying KeepItGoing Server in a production environment.

Prerequisites

• Ubuntu/Debian Linux server (or similar)
• Root or sudo access
• Domain name pointing to your server
• SSL certificate (Let's Encrypt recommended)

Step 1: System Preparation

# Update system packages
sudo apt update && sudo apt upgrade -y

# Install required system packages
sudo apt install -y python3.12 python3.12-venv python3-pip \
    postgresql postgresql-contrib nginx \
    redis-server git curl

# Install Let's Encrypt certbot (optional, for SSL)
sudo apt install -y certbot python3-certbot-nginx

Step 2: Database Setup

# Create PostgreSQL database and user
sudo -u postgres psql << EOF
CREATE DATABASE keepitgoing;
CREATE USER keepitgoing_user WITH PASSWORD 'STRONG_PASSWORD_HERE';
ALTER ROLE keepitgoing_user SET client_encoding TO 'utf8';
ALTER ROLE keepitgoing_user SET default_transaction_isolation TO 'read committed';
ALTER ROLE keepitgoing_user SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE keepitgoing TO keepitgoing_user;
\q
EOF

Step 3: Application Setup

# Create application user
sudo useradd -m -s /bin/bash keepitgoing
sudo su - keepitgoing

# Clone repository
git clone https://git.firebugit.com/Firebug_IT/KeepItGoingServer.git
cd KeepItGoingServer

# Create virtual environment
python3.12 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt
pip install gunicorn psycopg2-binary

# Create production environment file
cat > .env << 'EOF'
# Django Settings
SECRET_KEY=GENERATE_WITH_get_random_secret_key
DEBUG=False
ALLOWED_HOSTS=tasks.firebugit.com,localhost,127.0.0.1
CSRF_TRUSTED_ORIGINS=https://tasks.firebugit.com
SITE_DOMAIN=tasks.firebugit.com

# Database
DATABASE_URL=postgresql://keepitgoing_user:STRONG_PASSWORD_HERE@localhost:5432/keepitgoing

# Email Configuration (Gmail example)
EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=your-email@gmail.com
EMAIL_HOST_PASSWORD=your-app-password
DEFAULT_FROM_EMAIL=KeepItGoing <noreply@firebugit.com>
SERVER_EMAIL=server@firebugit.com

# Email Verification
EMAIL_VERIFICATION_TOKEN_EXPIRY_HOURS=24

# Redis (for Celery)
REDIS_URL=redis://localhost:6379/0
EOF

# Generate SECRET_KEY
python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"
# Copy the output and replace SECRET_KEY in .env

# Run migrations
export DJANGO_SETTINGS_MODULE=config.settings.production
python manage.py migrate

# Create superuser (admin account)
python manage.py createsuperuser

# Collect static files
python manage.py collectstatic --noinput

# Exit back to root
exit

Step 4: Email Provider Setup

Choose one of the following email providers:

Gmail:

1. Enable 2-factor authentication on your Google account
2. Generate an App Password: https://myaccount.google.com/apppasswords
3. Use the app password in EMAIL_HOST_PASSWORD

EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=your-email@gmail.com
EMAIL_HOST_PASSWORD=your-16-char-app-password

SendGrid:

1. Create SendGrid account and verify sender identity
2. Generate API key from Settings > API Keys
3. Configure:

EMAIL_HOST=smtp.sendgrid.net
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=apikey
EMAIL_HOST_PASSWORD=SG.your-api-key-here

AWS SES:

1. Verify domain in AWS SES console
2. Create SMTP credentials
3. Configure:

EMAIL_HOST=email-smtp.us-east-1.amazonaws.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=your-smtp-username
EMAIL_HOST_PASSWORD=your-smtp-password

Mailgun:

EMAIL_HOST=smtp.mailgun.org
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=postmaster@mg.yourdomain.com
EMAIL_HOST_PASSWORD=your-mailgun-password

Step 5: Gunicorn Service

Create systemd service file for Gunicorn:

sudo nano /etc/systemd/system/keepitgoing.service

Add the following content:

[Unit]
Description=KeepItGoing Gunicorn daemon
After=network.target postgresql.service

[Service]
Type=notify
User=keepitgoing
Group=keepitgoing
WorkingDirectory=/home/keepitgoing/KeepItGoingServer
Environment="PATH=/home/keepitgoing/KeepItGoingServer/venv/bin"
Environment="DJANGO_SETTINGS_MODULE=config.settings.production"
EnvironmentFile=/home/keepitgoing/KeepItGoingServer/.env
ExecStart=/home/keepitgoing/KeepItGoingServer/venv/bin/gunicorn \
    --workers 3 \
    --bind unix:/home/keepitgoing/KeepItGoingServer/gunicorn.sock \
    --timeout 60 \
    --access-logfile /var/log/keepitgoing/access.log \
    --error-logfile /var/log/keepitgoing/error.log \
    config.wsgi:application
ExecReload=/bin/kill -s HUP $MAINPID
KillMode=mixed
TimeoutStopSec=5
PrivateTmp=true

[Install]
WantedBy=multi-user.target

Create log directory:

sudo mkdir -p /var/log/keepitgoing
sudo chown keepitgoing:keepitgoing /var/log/keepitgoing

Enable and start service:

sudo systemctl daemon-reload
sudo systemctl enable keepitgoing
sudo systemctl start keepitgoing
sudo systemctl status keepitgoing

Step 6: Celery Service (Optional, for background tasks)

sudo nano /etc/systemd/system/keepitgoing-celery.service

[Unit]
Description=KeepItGoing Celery Worker
After=network.target redis.service

[Service]
Type=forking
User=keepitgoing
Group=keepitgoing
WorkingDirectory=/home/keepitgoing/KeepItGoingServer
Environment="PATH=/home/keepitgoing/KeepItGoingServer/venv/bin"
Environment="DJANGO_SETTINGS_MODULE=config.settings.production"
EnvironmentFile=/home/keepitgoing/KeepItGoingServer/.env
ExecStart=/home/keepitgoing/KeepItGoingServer/venv/bin/celery -A config worker -l info

[Install]
WantedBy=multi-user.target

Enable and start:

sudo systemctl enable keepitgoing-celery
sudo systemctl start keepitgoing-celery

Step 7: Nginx Configuration

sudo nano /etc/nginx/sites-available/keepitgoing

Add the following configuration:

upstream keepitgoing {
    server unix:/home/keepitgoing/KeepItGoingServer/gunicorn.sock fail_timeout=0;
}

server {
    listen 80;
    server_name tasks.firebugit.com;

    # Redirect HTTP to HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name tasks.firebugit.com;

    # SSL Configuration
    ssl_certificate /etc/letsencrypt/live/tasks.firebugit.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/tasks.firebugit.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # Security Headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    client_max_body_size 10M;

    # Static files
    location /static/ {
        alias /home/keepitgoing/KeepItGoingServer/staticfiles/;
        expires 30d;
        add_header Cache-Control "public, immutable";
    }

    # Media files
    location /media/ {
        alias /home/keepitgoing/KeepItGoingServer/media/;
        expires 7d;
    }

    # Application
    location / {
        proxy_pass http://keepitgoing;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_redirect off;

        # WebSocket support (if needed)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Enable site and restart nginx:

sudo ln -s /etc/nginx/sites-available/keepitgoing /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Step 8: SSL Certificate (Let's Encrypt)

# Obtain SSL certificate
sudo certbot --nginx -d tasks.firebugit.com

# Certbot will automatically configure nginx
# Certificate auto-renews via cron

Step 9: Firewall Setup

# Allow SSH, HTTP, and HTTPS
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo ufw status

Step 10: Initial Admin User and Approval

# Log in to the web interface at https://tasks.firebugit.com/admin
# Use the superuser credentials created in Step 3

# When new users register:
# 1. They receive verification email
# 2. After clicking verification link, you receive admin notification
# 3. Go to Admin > Users > select user(s) > Actions > "Approve selected users"
# 4. User receives approval email and can now log in

Production Checklist

Complete this checklist before going live:

Security:

• Set DEBUG = False in production settings
• Generate and configure strong SECRET_KEY
• Set up proper ALLOWED_HOSTS (only your domain)
• Configure CSRF_TRUSTED_ORIGINS for HTTPS
• Install and configure SSL/TLS certificates
• Enable firewall (ufw) with only necessary ports
• Set strong passwords for database and admin users
• Review and harden SSH configuration
• Configure security headers in nginx

Database:

• Use PostgreSQL (not SQLite) in production
• Configure regular database backups
• Set up database connection pooling if needed
• Verify database user has minimum required permissions

Email:

• Configure production email backend (SMTP)
• Test email delivery (verification and approval emails)
• Verify sender domain/email is whitelisted
• Set up SPF, DKIM, and DMARC records for your domain
• Monitor email delivery rates and bounces

Application:

• Run python manage.py migrate to apply all migrations
• Run python manage.py collectstatic for static files
• Create superuser account for admin access
• Test user registration and email verification flow
• Test admin approval workflow
• Configure SITE_DOMAIN to your production domain
• Set appropriate EMAIL_VERIFICATION_TOKEN_EXPIRY_HOURS

Services:

• Set up Gunicorn systemd service
• Configure nginx as reverse proxy
• Set up Redis for Celery (if using background tasks)
• Configure Celery systemd service (if needed)
• Verify all services start on boot

Monitoring & Logging:

• Set up application logging
• Configure nginx access and error logs
• Set up log rotation
• Configure system monitoring (disk, memory, CPU)
• Set up uptime monitoring
• Configure error alerting (email or Slack)
• Monitor database performance

Backups:

• Configure automated database backups
• Set up media file backups
• Test backup restoration process
• Store backups off-site
• Document backup and recovery procedures

Performance:

• Configure appropriate Gunicorn worker count
• Enable nginx gzip compression
• Set up static file caching
• Configure database connection pooling
• Monitor application performance
• Set up CDN for static files (optional)

Troubleshooting

Gunicorn won't start:

# Check service status
sudo systemctl status keepitgoing

# View logs
sudo journalctl -u keepitgoing -n 50

# Check if socket exists
ls -la /home/keepitgoing/KeepItGoingServer/gunicorn.sock

Emails not sending:

# Test email configuration in Django shell
sudo su - keepitgoing
cd KeepItGoingServer
source venv/bin/activate
export DJANGO_SETTINGS_MODULE=config.settings.production
python manage.py shell

# In the shell:
from django.core.mail import send_mail
send_mail(
    'Test Subject',
    'Test message.',
    'noreply@firebugit.com',
    ['your-email@example.com'],
)
# Check for any errors

Static files not loading:

# Recollect static files
sudo su - keepitgoing
cd KeepItGoingServer
source venv/bin/activate
export DJANGO_SETTINGS_MODULE=config.settings.production
python manage.py collectstatic --noinput

# Check nginx configuration
sudo nginx -t

# Check file permissions
ls -la /home/keepitgoing/KeepItGoingServer/staticfiles/

Database connection errors:

# Test PostgreSQL connection
sudo -u postgres psql keepitgoing

# Check if PostgreSQL is running
sudo systemctl status postgresql

# Verify credentials in .env match database

Permission denied errors:

# Fix ownership
sudo chown -R keepitgoing:keepitgoing /home/keepitgoing/KeepItGoingServer

# Fix socket permissions
sudo chown keepitgoing:www-data /home/keepitgoing/KeepItGoingServer/gunicorn.sock

Maintenance Tasks

Update application:

sudo su - keepitgoing
cd KeepItGoingServer
git pull origin main
source venv/bin/activate
pip install -r requirements.txt
export DJANGO_SETTINGS_MODULE=config.settings.production
python manage.py migrate
python manage.py collectstatic --noinput
exit

# Restart services
sudo systemctl restart keepitgoing

Database backup:

# Manual backup
sudo -u postgres pg_dump keepitgoing > keepitgoing_backup_$(date +%Y%m%d).sql

# Automated backup (add to crontab)
0 2 * * * sudo -u postgres pg_dump keepitgoing | gzip > /backups/keepitgoing_$(date +\%Y\%m\%d).sql.gz

View application logs:

# Gunicorn logs
sudo tail -f /var/log/keepitgoing/error.log
sudo tail -f /var/log/keepitgoing/access.log

# Nginx logs
sudo tail -f /var/log/nginx/error.log
sudo tail -f /var/log/nginx/access.log

# System logs
sudo journalctl -u keepitgoing -f

Mobile App Integration

This server works with the KeepItGoing Android app via the sync endpoint.

Sync Protocol:

• Client sends current state and last sync timestamp
• Server returns updates since last sync
• Server accepts client changes
• Conflict resolution handled server-side

Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

Proprietary - All Rights Reserved Copyright (c) 2025 Firebug IT

Support

For issues and questions:

• Create an issue in the repository
• Email: keith@firebugit.com

Changelog

Version 1.1.0 (2025-01-22)

• Email Verification System: Users must verify email before logging in
• Admin Approval Workflow: Admins approve new users via Django admin
• Email Notifications: Verification, approval, and admin notification emails
• Password Change: Users can change their password from profile page
• Enhanced Registration: Collect first name, last name, and timezone
• Profile Enhancements: Improved profile page with dark/light mode support
• Security: UUID tokens, expiration, one-time use, email enumeration protection
• Custom Authentication: Backend enforces verification and approval

Version 1.0.0 (2025-01-18)

• Initial release
• Complete task management system
• Tag-based organization
• Time tracking
• Multi-user support
• Mobile app sync
• Web interface with dark mode
• Responsive design
• RESTful API

---

Built with ❤️ by Firebug IT