Enterprise TaskFlow Wiki

Home

Project Overview

Enterprise TaskFlow is a comprehensive task management system designed for teams and organizations. It provides secure, role-based access control, real-time analytics, and robust file management capabilities.

Key Features:

Secure authentication with JWT
Role-based access control (Admin/Manager/Employee)
Real-time analytics dashboard
Secure file storage system
Responsive design
Enterprise-grade security

Quick Links

Live Demo (after installation)
API Documentation
Installation Guide
User Guide

Latest Updates

Version 1.0.0 (Current)

Initial stable release
Complete user management system
File upload/download functionality
Analytics dashboard
Security enhancements

Getting Started

Installation Guide

Prerequisites

Node.js 14.0 or higher
npm 6.0 or higher
Modern web browser

Step-by-Step Installation

# 1. Clone the repository
git clone https://github.com/your-username/enterprise-taskflow.git
cd enterprise-taskflow

# 2. Install dependencies
npm install

# 3. Start the server
npm start

# 4. Access the application
# Open http://localhost:3000 in your browser

Default Admin Account

Email: admin@taskflow.com
Password: Admin123!

Quick Start

First Steps

Login using the default admin credentials
Explore the Dashboard to see system metrics
Create Users for your team members
Set up Tasks and assign them to users
Configure Permissions based on roles

Basic Workflow

Admin creates user accounts
Manager creates and assigns tasks
Employees update task progress
Track performance through analytics

System Requirements

Minimum Requirements

Node.js: 14.0+
RAM: 512MB
Storage: 100MB
Browser: Chrome 80+, Firefox 75+, Safari 13+

Recommended Requirements

Node.js: 16.0+
RAM: 1GB
Storage: 500MB
Database: SQLite3 (included)

User Guide

Authentication

Login Process

Navigate to the login page
Enter your email and password
Click "Sign In" or press Enter
System validates credentials and creates secure session

Password Requirements

Minimum 8 characters
No specific character requirements
Securely hashed with bcrypt (12 rounds)

Session Management

Automatic logout after 24 hours of inactivity
Multiple session support
Token revocation on logout

Dashboard

Overview

The dashboard provides real-time insights into your team's productivity and task management.

Key Metrics:

Total Tasks: Complete task count
Pending: Tasks awaiting action
In Progress: Actively worked-on tasks
Completed: Successfully finished tasks
Overdue: Tasks past due date

Recent Activities

Last 5 tasks created or modified
Quick status updates with checkboxes
Assignee information and due dates

Task Management

Creating Tasks

Click "Create Task" button
Fill in required fields:
- Title (required)
- Description (optional)
- Priority (High/Medium/Low)
- Due Date
- Assignee
- Estimated Hours
Click "Create Task" to save

Task Status Lifecycle

Pending → Newly created tasks
In Progress → Work has commenced
Completed → Task finished successfully

Task Prioritization

High: Critical path items (red indicator)
Medium: Important but not urgent (yellow indicator)
Low: Nice-to-have items (green indicator)

User Management

User Roles

Administrator

Full system access
User management capabilities
Permission configuration
System-wide settings

Manager

Team management capabilities
Task creation and assignment
Limited user visibility
File management rights

Employee

Personal task management
File upload/download
Profile self-management

Adding New Users

Navigate to User Management section
Click "Add User"
Complete user profile:
- Name, Email, Role
- Department, Position
- Temporary password
Set appropriate permissions

File Storage

Uploading Files

Click "Upload File" in File Storage section
Select file from local system (max 50MB)
Automatic validation and scanning
Secure storage with access controls

Supported File Types

Documents: PDF, DOC, DOCX, XLS, XLSX
Images: JPG, PNG, GIF, SVG
Archives: ZIP, RAR
Presentations: PPT, PPTX

File Security

Maximum file size: 50MB
Malicious file detection
Access permission enforcement
Uploader attribution

Analytics & Reports

Available Reports

Task Completion Rate: Weekly completion trends
Performance Metrics: On-time completion averages
Team Performance: Individual contributor analytics
Task Distribution: Status breakdown visualization

Report Periods

Last 7 Days
Last 30 Days
Last 90 Days
Last Year

Export Functionality

Generate PDF reports
Export CSV data for external analysis
Print-friendly formats

Administration

System Configuration

Environment Variables

PORT=3000
JWT_SECRET=your-super-secure-jwt-secret
NODE_ENV=production

Database Configuration

SQLite3 for simplicity and performance
Automatic table creation
Index optimization
Query performance monitoring

Security Settings

Security Hardening

Regular security updates
Vulnerability scanning
Penetration testing
Compliance auditing

Access Controls

Role-based permission system
IP-based restrictions (optional)
Session timeout configuration
Password policy enforcement

Backup & Recovery

Backup Procedures

# Backup database
cp taskflow.db backup/taskflow-$(date +%Y%m%d).db

# Backup uploads directory
tar -czf backup/uploads-$(date +%Y%m%d).tar.gz uploads/

Recovery Process

Stop the application
Restore database file
Restore uploads directory
Restart application

Troubleshooting

Common Issues

Login Problems

Verify email/password combination
Check account status (active/inactive)
Clear browser cache and cookies

Performance Issues

Check system resources
Monitor database performance
Review activity logs

Permission Errors

Verify user role assignments
Check group permission settings
Review activity logs for denied access

Support Resources

System documentation
Admin training materials
Technical support contact

Development

API Documentation

Authentication Endpoints

POST   /api/auth/login     // User login
POST   /api/auth/logout    // User logout

Task Endpoints

GET    /api/tasks          // List tasks
POST   /api/tasks          // Create task
PUT    /api/tasks/:id      // Update task
DELETE /api/tasks/:id      // Delete task

User Endpoints

GET    /api/users          // List users (Admin only)
POST   /api/users          // Create user (Admin only)
PUT    /api/users/:id      // Update user (Admin only)

File Endpoints

GET    /api/files          // List files
POST   /api/files/upload   // Upload file
GET    /api/files/:id/download  // Download file
DELETE /api/files/:id      // Delete file

Database Schema

Users Table

CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  email VARCHAR(255) UNIQUE,
  password_hash TEXT,
  name VARCHAR(255),
  role VARCHAR(50),
  department VARCHAR(100),
  position VARCHAR(100),
  avatar_url TEXT,
  is_active BOOLEAN DEFAULT 1,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Tasks Table

CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  title VARCHAR(500),
  description TEXT,
  priority VARCHAR(20),
  status VARCHAR(20),
  due_date DATE,
  assignee_id INTEGER,
  created_by INTEGER,
  estimated_hours DECIMAL(5,2),
  actual_hours DECIMAL(5,2),
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Frontend Architecture

Main Class Structure

class EnterpriseTaskFlow {
  constructor() {
    this.currentUser = null;
    this.token = null;
    this.users = [];
    this.tasks = [];
    this.files = [];
  }

  // Core methods
  initializeApp()
  handleLogin()
  loadTasks()
  loadUsers()
  loadDashboard()
}

Key Components

Login System - Secure authentication flow
Dashboard - Real-time metrics and recent activities
Task Manager - CRUD operations with filtering
User Management - Role-based user administration

Backend Architecture

Security Implementation

const authenticateToken = async (req, res, next) => {
  const token = req.headers['authorization']?.split(' ')[1];
  
  if (!token) return res.status(401).json({ error: 'Access token required' });

  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    const user = await dbGet('SELECT * FROM users WHERE id = ?', [decoded.userId]);
    
    if (!user) return res.status(401).json({ error: 'Invalid token' });
    
    req.user = user;
    next();
  } catch (error) {
    return res.status(403).json({ error: 'Invalid token' });
  }
};

File Upload Configuration

const upload = multer({
  storage: multer.diskStorage({
    destination: 'uploads/',
    filename: (req, file, cb) => {
      const uniqueName = Date.now() + '-' + file.originalname;
      cb(null, uniqueName);
    }
  }),
  limits: { fileSize: 50 * 1024 * 1024 },
  fileFilter: (req, file, cb) => {
    // Validate file types
    cb(null, true);
  }
});

Deployment

Production Setup

Environment Configuration

# Set environment variables
export JWT_SECRET=your-production-secret
export NODE_ENV=production
export PORT=3000

# Start application
npm start

Process Management

# Using PM2 (recommended)
npm install -g pm2
pm2 start server.js --name "taskflow-enterprise"

Docker Deployment

Dockerfile

FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Docker Compose

version: '3.8'
services:
  taskflow:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - JWT_SECRET=your-secret-key
    volumes:
      - ./uploads:/app/uploads
      - ./database:/app/database

Performance Optimization

Database Optimization

Proper indexing on frequently queried columns
Query optimization and caching
Regular database maintenance

Frontend Optimization

Efficient DOM updates
Lazy loading for large datasets
Caching strategies for static assets

Backend Optimization

Connection pooling
Response compression
Rate limiting implementation

Uh oh!