Configuration Guide

Overview

This guide covers all configuration options for Checawaa, including email setup, user management, scheduler settings, security configuration, and customization options.

Most configuration is done through editing the main application file (app.py) and JSON data files. Changes typically require restarting the application to take effect.

Initial Setup

Prerequisites

Before configuring Checawaa, ensure you have:

Python environment

Python 3.7 or higher installed on your server

Required packages

Install dependencies from requirements.txt:

pip install flask flask-login flask-mail reportlab apscheduler

File permissions

Ensure the application has write access to the data directory for storing JSON files

Network access

Open ports for:

Port 5000 (or your chosen port) for HTTP access
Port 587 for SMTP email (if using Gmail)

First-Time Configuration Checklist

1. Change the secret key

Default: 'clave_secreta_muy_segura'Action required: Set a unique, random secret key for session security.

2. Configure email settings

Update SMTP credentials to your organization’s email server.

3. Create user accounts

Replace default users with your actual employees.

4. Test the system

Verify login, tracking, and email functionality.

Email Configuration

SMTP Settings

Checawaa uses Flask-Mail to send automated reminders and notifications. Configure these settings in app.py:

Gmail Configuration
Microsoft 365 / Outlook
Custom SMTP Server
SendGrid

Current default configuration:

app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = 'your-app-password'

Never use your actual Gmail password. Use an App Password instead.

Setting up Gmail App Password:

Enable 2-Factor Authentication

Go to Google Account Security settings and enable 2FA

Generate App Password

Visit: https://myaccount.google.com/apppasswordsSelect “Mail” and “Other” device

Copy the 16-character password

Format: xxxx xxxx xxxx xxxxUse this in MAIL_PASSWORD (remove spaces)

app.config['MAIL_SERVER'] = 'smtp.office365.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = 'your-password'

If using MFA, you may need to create an app-specific password in your Microsoft account settings.

app.config['MAIL_SERVER'] = 'smtp.yourcompany.com'
app.config['MAIL_PORT'] = 587  # or 465 for SSL
app.config['MAIL_USE_TLS'] = True  # False if using SSL
app.config['MAIL_USE_SSL'] = False  # True if using port 465
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = 'secure-password'

Contact your IT department for the correct SMTP settings.

app.config['MAIL_SERVER'] = 'smtp.sendgrid.net'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = 'apikey'  # Literally "apikey"
app.config['MAIL_PASSWORD'] = 'your-sendgrid-api-key'

Get your API key from: https://app.sendgrid.com/settings/api_keys

Email Sender Configuration

The sender email address appears in the “From” field:

# In app.py, function: enviar_recordatorio_automatizado
msg = Message("⚠️ Recordatorio Automático: Inicia tu Turno", 
              sender=app.config['MAIL_USERNAME'],  # Uses configured email
              recipients=destinatarios)

Use a professional, recognizable sender address like [email protected] or [email protected] for better email delivery rates.

Testing Email Configuration

After configuring email settings, test the functionality:

Start the application

python app.py

Access the monitoring panel at /monitor

Click 'Notificar Faltantes'

This manually triggers the email reminder system

Check employee inboxes

Verify emails are received (check spam folders if not in inbox)

Troubleshooting Email Issues

Authentication errors

Error: SMTPAuthenticationError or similarSolutions:

Verify username and password are correct
For Gmail: ensure you’re using an App Password, not regular password
Check if 2FA is required for your email service
Confirm “less secure app access” is enabled (if applicable)

Connection timeouts

Error: SMTPServerDisconnected or timeout errorsSolutions:

Verify MAIL_SERVER hostname is correct
Check firewall allows outbound traffic on port 587/465
Try alternate ports (587 for TLS, 465 for SSL)
Test with telnet smtp.gmail.com 587 to verify connectivity

Emails going to spam

Symptoms: Emails sent but employees don’t see themSolutions:

Check spam folders first
Add sender address to company’s email whitelist
Use a company domain email (not personal Gmail)
Configure SPF and DKIM records for your domain
Avoid excessive use of emojis in subject lines

Security Configuration

Secret Key

The Flask secret key is used to sign session cookies and protect against CSRF attacks: Current configuration:

app.secret_key = 'clave_secreta_muy_segura'

CRITICAL: Change this before deploying to production! This default key is publicly visible and insecure.

Generating a Secure Secret Key

Python Method
Command Line
Online Generator

import secrets
print(secrets.token_hex(32))
# Output: a1b2c3d4e5f6...  (64 characters)

Copy the output and use it as your secret key.

python -c "import secrets; print(secrets.token_hex(32))"

Or using openssl:

openssl rand -hex 32

Update in app.py:

app.secret_key = 'your-generated-secret-key-here'

Environment Variables (Recommended)

Instead of hardcoding credentials, use environment variables:

Create a .env file

# .env
SECRET_KEY=your-secret-key
MAIL_USERNAME=[email protected]
MAIL_PASSWORD=your-app-password

Add .env to your .gitignore to prevent committing secrets!

Install python-dotenv

pip install python-dotenv

Load environment variables in app.py

import os
from dotenv import load_dotenv

load_dotenv()

app.secret_key = os.getenv('SECRET_KEY')
app.config['MAIL_USERNAME'] = os.getenv('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.getenv('MAIL_PASSWORD')

Password Security

The current implementation stores passwords in plain text:

{
    "username": "empleado1",
    "pass": "123",  // Plain text - insecure!
    "email": "[email protected]"
}

Security Risk: Plain text passwords are visible to anyone with file access.

Recommended: Hash passwords using bcrypt

Implementing password hashing

Install bcrypt:
```
pip install bcrypt
```

Hash passwords when creating users:

import bcrypt

# When creating a user
password = "123"
hashed = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())

# Store hashed password in usuarios.json
{
    "username": "empleado1",
    "pass": hashed.decode('utf-8'),
    "email": "[email protected]"
}

Verify passwords on login:

# In login route
stored_hash = user['pass'].encode('utf-8')
entered_password = request.form['password'].encode('utf-8')

if bcrypt.checkpw(entered_password, stored_hash):
    login_user(User(user_input))

User Management

User Database Structure

Users are stored in data/usuarios.json:

[
    {
        "username": "admin",
        "pass": "secure-admin-password",
        "email": "[email protected]"
    },
    {
        "username": "empleado1",
        "pass": "employee-password",
        "email": "[email protected]"
    }
]

Adding Users

Determine user details

Username: Unique identifier (e.g., john.doe, employee123)
Password: Strong password (or hash if implementing hashing)
Email: Valid email for receiving reminders

Edit usuarios.json

Open data/usuarios.json and add the new user:

{
    "username": "john.doe",
    "pass": "SecurePass123!",
    "email": "[email protected]"
}

Validate JSON syntax

Ensure proper commas between entries and valid JSON structure.Use a JSON validator: https://jsonlint.com/

Test the new account

Try logging in with the new credentials to verify it works.

Bulk User Import

For adding many users at once:

CSV to JSON conversion script

import json
import csv

# Read from CSV
users = []
with open('employees.csv', 'r') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        users.append({
            "username": row['username'],
            "pass": row['password'],
            "email": row['email']
        })

# Write to usuarios.json
with open('data/usuarios.json', 'w') as jsonfile:
    json.dump(users, jsonfile, indent=4)

print(f"Imported {len(users)} users successfully!")

CSV format (employees.csv):

username,password,email
john.doe,Pass123,[email protected]
jane.smith,Pass456,[email protected]

Removing Users

Soft Delete (Recommended)
Hard Delete

Keep attendance history, prevent login:

Open data/usuarios.json

Change the user’s password to a random string:

{
    "username": "former.employee",
    "pass": "DISABLED_ACCOUNT_9x7k2p4m",
    "email": "[email protected]"
}

User can’t log in, but historical data remains

Remove user completely:

Open data/usuarios.json
Delete the entire user object
Ensure JSON remains valid (check commas)
Save the file

Attendance records in registros.json are NOT deleted and will still show the username.

Admin Account Configuration

The admin account is special - it has access to the monitoring panel:

# In app.py, login route
if user_input == 'admin':
    return redirect(url_for('monitor'))

The username must be exactly “admin” (case-sensitive). Any other username is treated as an employee account.

Creating multiple admin accounts: To give monitoring access to multiple people, modify the login logic:

ADMIN_USERS = ['admin', 'supervisor', 'hr.manager']

if user_input in ADMIN_USERS:
    return redirect(url_for('monitor'))

Scheduler Configuration

Automated Reminder Schedule

The automatic reminder system uses APScheduler to send emails at 8:00 AM daily: Current configuration (app.py):

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler(daemon=True)
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    hour=8,
    minute=0
)
scheduler.start()

Changing the Reminder Time

Different Time
Multiple Reminders
Weekdays Only
Custom Schedule

Example: 7:30 AM instead of 8:00 AM

scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    hour=7,    # Changed from 8
    minute=30  # Changed from 0
)

Send reminders at multiple times:

# First reminder at 7:30 AM
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    hour=7,
    minute=30
)

# Second reminder at 8:15 AM
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    hour=8,
    minute=15
)

Skip weekends:

scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    day_of_week='mon-fri',  # Monday to Friday only
    hour=8,
    minute=0
)

Different times for different days:

# 8 AM on Monday-Thursday
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    day_of_week='mon-thu',
    hour=8,
    minute=0
)

# 9 AM on Friday (casual Fridays start later)
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    day_of_week='fri',
    hour=9,
    minute=0
)

Scheduler Troubleshooting

When running Flask in debug mode, the scheduler may execute twice due to the reloader. Always use use_reloader=False:

if __name__ == '__main__':
    app.run(host='0.0.0.0', 
            port=5000, 
            debug=True, 
            use_reloader=False)  # Critical!

Scheduler not running

Symptoms: Automated emails never sendCheck:

Verify scheduler is started: scheduler.start()
Check server logs for scheduler errors
Ensure the application stays running (doesn’t exit)
Confirm timezone settings are correct

Emails sent at wrong time

Symptoms: Reminders arrive at unexpected timesSolutions:

Check server timezone: date or timedatectl

Set timezone explicitly in scheduler:

from pytz import timezone
scheduler.add_job(
    enviar_recordatorio_automatizado,
    'cron',
    hour=8,
    minute=0,
    timezone=timezone('America/New_York')
)

Attendance Settings

Tardiness Threshold

The time that determines if an employee is late: Current setting: 8:30 AM

# In monitor route (app.py:149)
hora_reg = reg.get('hora', '00:00:00')
es_retardo = hora_reg > "08:30:00"

To change the threshold:

Update monitor route logic

# Change to 9:00 AM threshold
es_retardo = hora_reg > "09:00:00"

Update PDF report logic

# In reporte_pdf route (app.py:206)
estado = "RETARDO" if hora > "09:00:00" else "PUNTUAL"

Update reminder time

Adjust the scheduler to send reminders before the new threshold:

# If threshold is 9:00, remind at 8:30
scheduler.add_job(..., hour=8, minute=30)

Ensure consistency across all locations where the threshold is used: monitoring panel, PDF reports, and any custom analytics.

Location Update Frequency

How often employees send their location: Current setting: Every 50 minutes

// In templates/index.html:27
setInterval(enviarUbicacion, 50 * 60 * 1000);

Changing the frequency:

More Frequent (30 min)

setInterval(enviarUbicacion, 30 * 60 * 1000);

Pros: Better accuracy, more data points Cons: More battery usage, higher server load

Less Frequent (90 min)

setInterval(enviarUbicacion, 90 * 60 * 1000);

Pros: Better battery life, lower server load Cons: Less frequent verification

Consider your organization’s needs. If employees are highly mobile, more frequent updates provide better verification. For stationary office workers, less frequent updates may suffice.

Data Storage Configuration

File Locations

Checawaa stores data in JSON files:

DATA_DIR = 'data'
REGISTROS_FILE = os.path.join(DATA_DIR, 'registros.json')  # Attendance records
USUARIOS_FILE = os.path.join(DATA_DIR, 'usuarios.json')    # User accounts

Changing Storage Location

To use a different directory:

# Absolute path
DATA_DIR = '/var/lib/checawaa/data'

# Relative to user home
import os.path
DATA_DIR = os.path.expanduser('~/checawaa_data')

# Network drive (if mounted)
DATA_DIR = '/mnt/company_storage/checawaa'

Ensure the application has read/write permissions to the specified directory.

Database Migration (Moving to SQLite)

For larger deployments, consider migrating to a database:

SQLite implementation example

import sqlite3

# Initialize database
conn = sqlite3.connect('data/checawaa.db')
cursor = conn.cursor()

# Create tables
cursor.execute('''
CREATE TABLE IF NOT EXISTS usuarios (
    id INTEGER PRIMARY KEY,
    username TEXT UNIQUE NOT NULL,
    password_hash TEXT NOT NULL,
    email TEXT NOT NULL
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS registros (
    id INTEGER PRIMARY KEY,
    usuario TEXT NOT NULL,
    lat REAL NOT NULL,
    lon REAL NOT NULL,
    fecha DATE NOT NULL,
    hora TIME NOT NULL
)
''')

conn.commit()

Benefits:

Better performance with large datasets
Atomic transactions
Query optimization
Concurrent access handling

Server Configuration

Development vs Production

Development
Production

Current configuration:

if __name__ == '__main__':
    app.run(host='0.0.0.0', 
            port=5000, 
            debug=True, 
            use_reloader=False)

debug=True: Shows detailed errors, auto-reloads on changes
host=‘0.0.0.0’: Accessible from any IP
port=5000: Default Flask port

Never run with debug=True in production!Use a production WSGI server like Gunicorn:

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:5000 app:app

-w 4: 4 worker processes
-b 0.0.0.0:5000: Bind to all interfaces on port 5000
app:app: Module and app name

Port Configuration

Change the port if 5000 is already in use:

app.run(host='0.0.0.0', 
        port=8080,  # Change to desired port
        debug=False)

HTTPS/SSL Configuration

For production, always use HTTPS:

Obtain SSL certificate

Options:

Let’s Encrypt (free): https://letsencrypt.org/
Commercial CA: Purchase from provider
Self-signed: For internal testing only

Use a reverse proxy

Nginx configuration:

server {
    listen 443 ssl;
    server_name attendance.company.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location / {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Redirect HTTP to HTTPS

server {
    listen 80;
    server_name attendance.company.com;
    return 301 https://$server_name$request_uri;
}

Customization Options

Branding and Appearance

Application Title
Dashboard Headers
CSS Styling

Login page (templates/login.html:6):

<title>Iniciar Sesión - Tracker</title>

Change to:

<title>Login - Company Attendance System</title>

Employee dashboard (templates/index.html:13):

<h1>Hola, {{ usuario }}</h1>

Admin panel (templates/monitor.html:20):

<h1>📊 Panel Administrativo</h1>

CSS files are located in static/css/:

login.css - Login page styling
index.css - Employee dashboard
monitor.css - Admin panel

Customize colors, fonts, and layout to match your brand.

Email Template Customization

Reminder email content (app.py:81):

msg = Message("⚠️ Recordatorio Automático: Inicia tu Turno", 
              sender=app.config['MAIL_USERNAME'], 
              recipients=destinatarios)
msg.body = "Buenos días. Son las 8:00 AM y el sistema aún no detecta tu registro de hoy. Por favor inicia tu monitoreo."

Customize to your needs:

Bilingual email example

msg.body = """
Good morning / Buenos días,

It's 8:00 AM and the system has not detected your attendance record yet.
Please start your shift tracking.

Son las 8:00 AM y el sistema aún no detecta tu registro de hoy.
Por favor inicia tu monitoreo.

Thank you / Gracias,
Company Attendance System
"""

HTML email with formatting

from flask_mail import Message

msg = Message("⚠️ Attendance Reminder", 
              sender=app.config['MAIL_USERNAME'], 
              recipients=destinatarios)

msg.html = """
<html>
<body style="font-family: Arial, sans-serif;">
    <h2 style="color: #dc3545;">Attendance Reminder</h2>
    <p>Good morning,</p>
    <p>It's 8:00 AM and we haven't received your attendance check-in yet.</p>
    <p><strong>Please log in and start your shift tracking.</strong></p>
    <hr>
    <p style="font-size: 12px; color: #666;">
        This is an automated message from the Company Attendance System.
    </p>
</body>
</html>
"""

PDF Report Customization

Report header (app.py:192):

p.drawString(100, 750, f"REPORTE DE ASISTENCIA - GENERADO: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

Customization options:

Company logo

from reportlab.lib.utils import ImageReader

logo = ImageReader('static/images/company_logo.png')
p.drawImage(logo, 50, 720, width=100, height=50)

Custom header text

p.setFont("Helvetica-Bold", 16)
p.drawString(100, 750, "COMPANY NAME")
p.setFont("Helvetica", 12)
p.drawString(100, 735, "Employee Attendance Report")
p.drawString(100, 720, f"Generated: {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}")

Additional columns

Add more data to the report table:

# Add location column
p.drawString(450, y, "Location")
# Later in loop:
p.drawString(450, y, f"({r['lat']:.4f}, {r['lon']:.4f})")

Performance Optimization

For Large Deployments

Database indexing (if using SQLite)

# Add indexes for faster queries
cursor.execute('CREATE INDEX idx_fecha ON registros(fecha)')
cursor.execute('CREATE INDEX idx_usuario ON registros(usuario)')
cursor.execute('CREATE INDEX idx_usuario_fecha ON registros(usuario, fecha)')

Caching attendance data

from functools import lru_cache
from datetime import datetime, timedelta

@lru_cache(maxsize=128)
def get_attendance_for_date(date_string):
    registros = leer_json(REGISTROS_FILE)
    return [r for r in registros if r['fecha'] == date_string]

# Clear cache after new records
def update_location():
    # ... save new record ...
    get_attendance_for_date.cache_clear()

Pagination for large datasets

# In monitor route, show only recent records
from datetime import datetime, timedelta

thirty_days_ago = (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d")

asistencia = [
    reg for reg in todos_registros 
    if reg.get('fecha', '') >= thirty_days_ago
]

Data Maintenance

Archive Old Records
Cleanup Script

Monthly archiving script:

import json
from datetime import datetime, timedelta

# Archive records older than 90 days
cutoff = (datetime.now() - timedelta(days=90)).strftime("%Y-%m-%d")

registros = leer_json(REGISTROS_FILE)
current = [r for r in registros if r['fecha'] >= cutoff]
archive = [r for r in registros if r['fecha'] < cutoff]

# Save current records
guardar_json(REGISTROS_FILE, current)

# Save archive
archive_file = f"data/archive_{cutoff}.json"
guardar_json(archive_file, archive)

print(f"Archived {len(archive)} records, kept {len(current)}")

Remove duplicate entries:

import json

registros = leer_json(REGISTROS_FILE)

# Remove duplicates (same user, date, time)
seen = set()
unique = []

for r in registros:
    key = (r['usuario'], r['fecha'], r['hora'])
    if key not in seen:
        seen.add(key)
        unique.append(r)

print(f"Removed {len(registros) - len(unique)} duplicates")
guardar_json(REGISTROS_FILE, unique)

Backup and Recovery

Automated Backup Strategy

Create backup script

#!/bin/bash
# backup.sh

BACKUP_DIR="/backups/checawaa"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Backup data directory
tar -czf "$BACKUP_DIR/checawaa_$DATE.tar.gz" data/

# Keep only last 30 days of backups
find "$BACKUP_DIR" -name "checawaa_*.tar.gz" -mtime +30 -delete

echo "Backup completed: checawaa_$DATE.tar.gz"

Schedule with cron

# Run daily at 2 AM
crontab -e

# Add line:
0 2 * * * /path/to/backup.sh

Test restoration

# Extract backup
tar -xzf checawaa_20260305_020000.tar.gz

# Restore files
cp -r data/* /path/to/checawaa/data/

Cloud Backup Integration

AWS S3 backup

import boto3
from datetime import datetime

def backup_to_s3():
    s3 = boto3.client('s3')
    bucket_name = 'company-checawaa-backups'
    
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    
    # Upload usuarios.json
    s3.upload_file(
        USUARIOS_FILE,
        bucket_name,
        f'backups/usuarios_{timestamp}.json'
    )
    
    # Upload registros.json
    s3.upload_file(
        REGISTROS_FILE,
        bucket_name,
        f'backups/registros_{timestamp}.json'
    )
    
    print(f"Backup uploaded to S3: {timestamp}")

Monitoring and Logging

Application Logging

Add comprehensive logging:

import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('checawaa.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

# Use throughout application
logger.info(f"User {current_user.id} logged in")
logger.warning(f"Failed login attempt for user: {user_input}")
logger.error(f"Email sending failed: {str(e)}")

Health Check Endpoint

Add a health check for monitoring tools:

@app.route('/health')
def health_check():
    return jsonify({
        "status": "healthy",
        "timestamp": datetime.datetime.now().isoformat(),
        "scheduler_running": scheduler.running,
        "total_users": len(leer_json(USUARIOS_FILE)),
        "total_records": len(leer_json(REGISTROS_FILE))
    })

Troubleshooting

Common Configuration Issues

Application won't start

Check:

Python version (3.7+ required)
All dependencies installed: pip install -r requirements.txt
No syntax errors in app.py
Port 5000 not already in use: lsof -i :5000
Permissions on data directory

Data not persisting

Causes:

File permission issues (can’t write to data/)
Disk space full
Invalid JSON syntax breaking file writes
Process doesn’t have write access

Solutions:

# Check permissions
ls -la data/

# Fix permissions
chmod 755 data/
chmod 644 data/*.json

# Check disk space
df -h

Scheduler not working

Debugging steps:

Check logs for scheduler errors
Verify scheduler.start() is called
Confirm use_reloader=False
Test manual trigger works: /send-reminders
Check server timezone matches expected

Next Steps

After configuration:

Test all functionality - Login, tracking, emails, reports
Train administrators - Ensure they understand the admin panel
Onboard employees - Provide training on using the system
Monitor initially - Watch for issues in the first week
Establish backup routine - Automate and test backups
Document customizations - Keep notes on any changes made

For additional help with configuration, refer to the Administrator Guide for operational details or the Employee Guide for end-user information.

Get Started

Core Features

User Guides

Deployment

​Overview

​Initial Setup

​Prerequisites

​First-Time Configuration Checklist

​Email Configuration

​SMTP Settings

​Email Sender Configuration

​Testing Email Configuration

​Troubleshooting Email Issues

​Security Configuration

​Secret Key

​Generating a Secure Secret Key

​Environment Variables (Recommended)

​Password Security

​User Management

​User Database Structure

​Adding Users

​Bulk User Import

​Removing Users

​Admin Account Configuration

​Scheduler Configuration

​Automated Reminder Schedule

​Changing the Reminder Time

​Scheduler Troubleshooting

​Attendance Settings

​Tardiness Threshold

​Location Update Frequency

More Frequent (30 min)

Less Frequent (90 min)

​Data Storage Configuration

​File Locations

​Changing Storage Location

​Database Migration (Moving to SQLite)

​Server Configuration

​Development vs Production

​Port Configuration

​HTTPS/SSL Configuration

​Customization Options

​Branding and Appearance

​Email Template Customization

​PDF Report Customization

​Performance Optimization

​For Large Deployments

​Data Maintenance

​Backup and Recovery

​Automated Backup Strategy

​Cloud Backup Integration

​Monitoring and Logging

​Application Logging

​Health Check Endpoint

​Troubleshooting

​Common Configuration Issues

​Next Steps

Build docs developers (and LLMs) love

Overview

Initial Setup

Prerequisites

First-Time Configuration Checklist

Email Configuration

SMTP Settings

Email Sender Configuration

Testing Email Configuration

Troubleshooting Email Issues

Security Configuration

Secret Key

Generating a Secure Secret Key

Environment Variables (Recommended)

Password Security

User Management

User Database Structure

Adding Users

Bulk User Import

Removing Users

Admin Account Configuration

Scheduler Configuration

Automated Reminder Schedule

Changing the Reminder Time

Scheduler Troubleshooting

Attendance Settings

Tardiness Threshold

Location Update Frequency

Data Storage Configuration

File Locations

Changing Storage Location

Database Migration (Moving to SQLite)

Server Configuration

Development vs Production

Port Configuration

HTTPS/SSL Configuration

Customization Options

Branding and Appearance

Email Template Customization

PDF Report Customization

Performance Optimization

For Large Deployments

Data Maintenance

Backup and Recovery

Automated Backup Strategy

Cloud Backup Integration

Monitoring and Logging

Application Logging

Health Check Endpoint

Troubleshooting

Common Configuration Issues

Next Steps